async Task <TransactionBlock> MainAsync(DagSystem sys, SendTransferBlock send) { // check exists var daoid = send.Tags["daoid"]; var prevBlock = await sys.Storage.FindLatestBlockAsync(daoid) as TransactionBlock; var txInfo = send.GetBalanceChanges(await sys.Storage.FindBlockByHashAsync(send.PreviousHash) as TransactionBlock); var lsb = await sys.Storage.GetLastServiceBlockAsync(); return(await TransactionOperateAsync(sys, send.Hash, prevBlock, () => prevBlock.GenInc <DaoSendBlock>(), (b) => { // send (b as SendTransferBlock).DestinationAccountId = send.AccountID; // treasure change var curBalance = b.Balances.ToDecimalDict(); var curShares = (b as IDao).Treasure.ToDecimalDict(); curBalance["LYR"] -= curShares[send.AccountID]; curShares.Remove(send.AccountID); b.Balances = curBalance.ToLongDict(); (b as IDao).Treasure = curShares.ToLongDict(); })); }
// DEX #region BRK_DEX_DPOREQ public override async Task <APIResultCodes> PreSendAuthAsync(DagSystem sys, SendTransferBlock block, TransactionBlock last) { var symbol = block.Tags.ContainsKey("symbol") ? block.Tags["symbol"] : null; if (symbol == null) { return(APIResultCodes.InvalidName); } var provider = block.Tags.ContainsKey("provider") ? block.Tags["provider"] : null; if (provider == null) { return(APIResultCodes.InvalidName); } if (block.Tags.Count > 3) { return(APIResultCodes.InvalidBlockTags); } var dc = new DexClient(LyraNodeConfig.GetNetworkId()); var asts = await dc.GetSupportedExtTokenAsync(LyraNodeConfig.GetNetworkId()); var ast = asts.Asserts.Where(a => a.Symbol == symbol && a.NetworkProvider == provider) .FirstOrDefault(); if (ast == null) { return(APIResultCodes.InvalidExternalToken); } return(APIResultCodes.Success); }
public override async Task <APIResultCodes> PreSendAuthAsync(DagSystem sys, SendTransferBlock block, TransactionBlock last) { var dexid4 = block.Tags.ContainsKey("dexid") ? block.Tags["dexid"] : null; if (dexid4 == null) { return(APIResultCodes.InvalidAccountId); } decimal wdwmount4 = 0; var wdwamountstr4 = block.Tags.ContainsKey("amount") ? block.Tags["amount"] : null; if (wdwamountstr4 == null || !decimal.TryParse(wdwamountstr4, out wdwmount4) || wdwmount4 <= 0) { return(APIResultCodes.InvalidAmount); } // verify owner var lb4 = await sys.Storage.FindLatestBlockAsync(dexid4) as IBrokerAccount; if (lb4 == null || block.AccountID != lb4.OwnerAccountId) { return(APIResultCodes.InvalidAccountId); } var extaddr = block.Tags.ContainsKey("extaddr") ? block.Tags["extaddr"] : null; if (string.IsNullOrWhiteSpace(extaddr)) { return(APIResultCodes.InvalidExternalAddress); } return(APIResultCodes.Success); }
private static async Task <NewTransferAPIResult2> GetSendToPftAsync(DagSystem sys, string pftid) { Console.WriteLine("CR Dividend: GetSendToPftAsync"); NewTransferAPIResult2 transfer_info = new NewTransferAPIResult2(); SendTransferBlock sendBlock = await sys.Storage.FindUnsettledSendBlockAsync(pftid); if (sendBlock != null) { TransactionBlock previousBlock = await sys.Storage.FindBlockByHashAsync(sendBlock.PreviousHash) as TransactionBlock; if (previousBlock == null) { transfer_info.ResultCode = APIResultCodes.CouldNotTraceSendBlockChain; } else { transfer_info.Transfer = sendBlock.GetBalanceChanges(previousBlock); //CalculateTransaction(sendBlock, previousSendBlock); transfer_info.SourceHash = sendBlock.Hash; transfer_info.NonFungibleToken = sendBlock.NonFungibleToken; transfer_info.ResultCode = APIResultCodes.Success; } } else { transfer_info.ResultCode = APIResultCodes.NoNewTransferFound; } return(transfer_info); }
public override async Task <APIResultCodes> PreSendAuthAsync(DagSystem sys, SendTransferBlock send, TransactionBlock last) { if (send.Tags.Count != 3 || !send.Tags.ContainsKey("daoid") || !send.Tags.ContainsKey("orderid") || string.IsNullOrWhiteSpace(send.Tags["orderid"]) ) { return(APIResultCodes.InvalidBlockTags); } var daoid = send.Tags["daoid"]; var orderid = send.Tags["orderid"]; var daoblk = await sys.Storage.FindLatestBlockAsync(daoid); var orderblk = await sys.Storage.FindLatestBlockAsync(orderid); if (daoblk == null || orderblk == null || (orderblk as IOtcOrder).Order.daoId != (daoblk as TransactionBlock).AccountID) { return(APIResultCodes.InvalidTrade); } if ((orderblk as IBrokerAccount).OwnerAccountId != send.AccountID) { return(APIResultCodes.NotSellerOfTrade); } if ((orderblk as IOtcOrder).OOStatus != OTCOrderStatus.Partial) { return(APIResultCodes.InvalidOrderStatus); } return(APIResultCodes.Success); }
protected Task <TransactionBlock> ChangeStateAsync(DagSystem sys, SendTransferBlock sendBlock) { return(TradeBlockOperateAsync(sys, sendBlock, () => new OtcTradeRecvBlock(), (b) => { var txInfo = sendBlock.GetBalanceChanges(sys.Storage.FindBlockByHash(sendBlock.PreviousHash) as TransactionBlock); var recvBalances = b.Balances.ToDecimalDict(); foreach (var chg in txInfo.Changes) { if (recvBalances.ContainsKey(chg.Key)) { recvBalances[chg.Key] += chg.Value; } else { recvBalances.Add(chg.Key, chg.Value); } } b.Balances = recvBalances.ToLongDict(); (b as IOtcTrade).OTStatus = OTCTradeStatus.FiatReceived; })); }
public void TestSetup() { SimpleLogger.Factory = new NullLoggerFactory(); var probe = CreateTestProbe(); var ta = new TestAuthorizer(probe); sys = ta.TheDagSystem; sys.StartConsensus(); store = ta.TheDagSystem.Storage; af = new AuthorizersFactory(); af.Init(); //p2pStacks = new TestProbe[NodesCount]; //authorizers = new TestAuthorizer[NodesCount]; //for(int i = 0; i < NodesCount; i++) //{ // p2pStacks[i] = CreateTestProbe(); // authorizers[i] = new TestAuthorizer(p2pStacks[i]); // p2pStacks[i].SetAutoPilot(new DelegateAutoPilot((sender, message) => // { // var msg = message as LocalNode.SignedMessageRelay; // if (msg != null) // { // // foreach dagsys sender not same tell it // } // sender.Tell(message, ActorRefs.NoSender); // return AutoPilot.KeepRunning; // })); //} }
public ProtocolHandler(DagSystem system) { this.system = system; _log = new SimpleLogger("ProtocolHandler").Logger; //this.knownHashes = new FIFOSet<UInt256>(Blockchain.Singleton.MemPool.Capacity * 2); //this.sentHashes = new FIFOSet<UInt256>(Blockchain.Singleton.MemPool.Capacity * 2); }
async Task <TransactionBlock> SealTradeAsync(DagSystem sys, SendTransferBlock send) { var tradeid = send.Tags["tradeid"]; var lastblock = await sys.Storage.FindLatestBlockAsync(tradeid) as TransactionBlock; var txInfo = send.GetBalanceChanges(await sys.Storage.FindBlockByHashAsync(send.PreviousHash) as TransactionBlock); var sb = await sys.Storage.GetLastServiceBlockAsync(); return(await TransactionOperateAsync(sys, send.Hash, lastblock, () => lastblock.GenInc <OtcTradeRecvBlock>(), (b) => { // recv (b as ReceiveTransferBlock).SourceHash = send.Hash; // broker (b as IBrokerAccount).RelatedTx = send.Hash; // balance var oldbalance = b.Balances.ToDecimalDict(); if (oldbalance.ContainsKey("LYR")) { oldbalance["LYR"] += txInfo.Changes["LYR"]; } else { oldbalance.Add("LYR", txInfo.Changes["LYR"]); } b.Balances = oldbalance.ToLongDict(); // Trade status (b as IOtcTrade).OTStatus = OTCTradeStatus.Canceled; })); }
public override async Task <APIResultCodes> PreSendAuthAsync(DagSystem sys, SendTransferBlock block, TransactionBlock lastBlock) { if (block.Tags.Count != 2 || !block.Tags.ContainsKey("poolid")) { return(APIResultCodes.InvalidBlockTags); } var poolGenesis = sys.Storage.GetPoolByID(block.Tags["poolid"]); if (poolGenesis == null) { return(APIResultCodes.PoolNotExists); } var chgs = block.GetBalanceChanges(lastBlock); if (chgs.Changes[LyraGlobal.OFFICIALTICKERCODE] != 1m) { return(APIResultCodes.InvalidFeeAmount); } if (!(await sys.Storage.FindLatestBlockAsync(poolGenesis.AccountID) is IPool pool)) { return(APIResultCodes.PoolNotExists); } if (!pool.Shares.ContainsKey(block.AccountID)) { return(APIResultCodes.PoolShareNotExists); } return(APIResultCodes.Success); }
public override async Task <APIResultCodes> PreSendAuthAsync(DagSystem sys, SendTransferBlock block, TransactionBlock lastBlock) { var chgs = block.GetBalanceChanges(lastBlock); if (!chgs.Changes.ContainsKey(LyraGlobal.OFFICIALTICKERCODE)) { return(APIResultCodes.InvalidFeeAmount); } if (block.Tags.Count == 1) { // verify sender is the owner of stkingblock var stks = await sys.Storage.FindAllStakingAccountForOwnerAsync(block.AccountID); if (!stks.Any(a => a.AccountID == block.DestinationAccountId)) { return(APIResultCodes.InvalidStakingAccount); } } else { return(APIResultCodes.InvalidBlockTags); } return(APIResultCodes.Success); }
public override async Task <APIResultCodes> PreSendAuthAsync(DagSystem sys, SendTransferBlock send, TransactionBlock last) { if (send.Tags.Count != 3 || !send.Tags.ContainsKey("daoid") || !send.Tags.ContainsKey("orderid") || string.IsNullOrWhiteSpace(send.Tags["orderid"]) ) { return(APIResultCodes.InvalidBlockTags); } var daoid = send.Tags["daoid"]; var orderid = send.Tags["orderid"]; var daoblk = await sys.Storage.FindLatestBlockAsync(daoid); var orderblk = await sys.Storage.FindLatestBlockAsync(orderid); var ordertx = orderblk as TransactionBlock; // need some balance to close. old bug if (!ordertx.Balances.Any(a => a.Value > 0)) { return(APIResultCodes.InsufficientFunds); } if (daoblk == null || orderblk == null || (orderblk as IOtcOrder).Order.daoId != (daoblk as TransactionBlock).AccountID) { return(APIResultCodes.InvalidTrade); } if ((orderblk as IBrokerAccount).OwnerAccountId != send.AccountID) { return(APIResultCodes.NotSellerOfTrade); } if ((orderblk as IOtcOrder).OOStatus != OTCOrderStatus.Open && (orderblk as IOtcOrder).OOStatus != OTCOrderStatus.Partial && (orderblk as IOtcOrder).OOStatus != OTCOrderStatus.Delist) { return(APIResultCodes.InvalidOrderStatus); } var trades = await sys.Storage.FindOtcTradeForOrderAsync(orderid); if (trades.Any()) { var opened = trades.Cast <IOtcTrade>() .Where(a => a.OTStatus != OTCTradeStatus.Canceled && a.OTStatus != OTCTradeStatus.Closed && a.OTStatus != OTCTradeStatus.DisputeClosed && a.OTStatus != OTCTradeStatus.CryptoReleased ); if (opened.Any()) { return(APIResultCodes.TradesPending); } } return(APIResultCodes.Success); }
protected override async Task <APIResultCodes> AuthorizeImplAsync <T>(DagSystem sys, T tblock) { if (!(tblock is LyraTokenGenesisBlock)) { return(APIResultCodes.InvalidBlockType); } var block = tblock as LyraTokenGenesisBlock; if ((block as LyraTokenGenesisBlock).Ticker != LyraGlobal.OFFICIALTICKERCODE) { return(APIResultCodes.InvalidBlockType); } // Local node validations - before it sends it out to the authorization sample: // 1. check if the account already exists if (await sys.Storage.AccountExistsAsync(block.AccountID)) { return(APIResultCodes.AccountAlreadyExists); // } // check if this token already exists //AccountData genesis_blocks = _accountCollection.GetAccount(AccountCollection.GENESIS_BLOCKS); //if (genesis_blocks.FindTokenGenesisBlock(testTokenGenesisBlock) != null) if (await sys.Storage.FindTokenGenesisBlockAsync(block.Hash, LyraGlobal.OFFICIALTICKERCODE) != null) { return(APIResultCodes.TokenGenesisBlockAlreadyExists); } return(await Lyra.Shared.StopWatcher.TrackAsync(() => base.AuthorizeImplAsync(sys, tblock), "LyraGenesisAuthorizer->TokenGenesisAuthorizer")); }
protected override async Task <APIResultCodes> AuthorizeImplAsync <T>(DagSystem sys, T tblock) { if (!(tblock is PoolSwapOutBlock)) { return(APIResultCodes.InvalidBlockType); } var block = tblock as PoolSwapOutBlock; // also prevent race condition var blk = await sys.Storage.FindBlockByHashAsync(block.PreviousHash); if (blk is ReceiveTransferBlock recv) { if (recv.SourceHash != block.RelatedTx) { return(APIResultCodes.InvalidRelatedTx); } } else { return(APIResultCodes.InvalidBlockSequence); } return(await Lyra.Shared.StopWatcher.TrackAsync(() => base.AuthorizeImplAsync(sys, tblock), "PoolSwapOutAuthorizer->SendTransferAuthorizer")); }
protected override async Task <APIResultCodes> AuthorizeImplAsync <T>(DagSystem sys, T tblock) { if (!(tblock is DexWalletGenesis)) { return(APIResultCodes.InvalidBlockType); } var block = tblock as DexWalletGenesis; if (block.AccountType != AccountTypes.DEX) { return(APIResultCodes.InvalidAccountType); } var dc = new DexClient(LyraNodeConfig.GetNetworkId()); var asts = await dc.GetSupportedExtTokenAsync(LyraNodeConfig.GetNetworkId()); var ast = asts.Asserts.Where(a => a.Symbol == block.ExtSymbol) .FirstOrDefault(); if (ast == null || ast.NetworkProvider != block.ExtProvider) { return(APIResultCodes.UnsupportedDexToken); } return(await Lyra.Shared.StopWatcher.TrackAsync(() => base.AuthorizeImplAsync(sys, tblock), "DexWalletGenesisAuthorizer->DexReceiveAuthorizer")); }
async Task <TransactionBlock> SendTokenFromTradeToOrderAsync(DagSystem sys, SendTransferBlock send) { var tradeid = send.Tags["tradeid"]; var lastblock = await sys.Storage.FindLatestBlockAsync(tradeid) as TransactionBlock; var txInfo = send.GetBalanceChanges(await sys.Storage.FindBlockByHashAsync(send.PreviousHash) as TransactionBlock); var sb = await sys.Storage.GetLastServiceBlockAsync(); return(await TransactionOperateAsync(sys, send.Hash, lastblock, () => lastblock.GenInc <OtcTradeSendBlock>(), (b) => { // send (b as SendTransferBlock).DestinationAccountId = (lastblock as IOtcTrade).Trade.orderId; // broker (b as IBrokerAccount).RelatedTx = send.Hash; // balance var oldbalance = b.Balances.ToDecimalDict(); foreach (var key in b.Balances.Keys) { oldbalance[key] = 0; } b.Balances = oldbalance.ToLongDict(); })); }
// user pay via off-chain ways and confirm payment in OTC trade. public override async Task <APIResultCodes> PreSendAuthAsync(DagSystem sys, SendTransferBlock send, TransactionBlock last) { if (send.Tags.Count != 2 || !send.Tags.ContainsKey("tradeid") || string.IsNullOrWhiteSpace(send.Tags["tradeid"])) { return(APIResultCodes.InvalidBlockTags); } var tradeid = send.Tags["tradeid"]; var tradeblk = await sys.Storage.FindLatestBlockAsync(tradeid); if (tradeblk == null) { return(APIResultCodes.InvalidTrade); } if ((tradeblk as IBrokerAccount).OwnerAccountId != send.AccountID) { return(APIResultCodes.NotOwnerOfTrade); } if ((tradeblk as IOtcTrade).OTStatus != OTCTradeStatus.Open) { return(APIResultCodes.InvalidTradeStatus); } return(APIResultCodes.Success); }
protected async Task <TransactionBlock> SendCollateralToBuyerAsync(DagSystem sys, SendTransferBlock send) { var tradeid = send.Tags["tradeid"]; var tradelatest = await sys.Storage.FindLatestBlockAsync(tradeid) as TransactionBlock; var tradeblk = tradelatest as IOtcTrade; var daolastblock = await sys.Storage.FindLatestBlockAsync(tradeblk.Trade.daoId) as TransactionBlock; var sb = await sys.Storage.GetLastServiceBlockAsync(); return(await TransactionOperateAsync(sys, send.Hash, daolastblock, () => daolastblock.GenInc <DaoSendBlock>(), (b) => { // recv (b as SendTransferBlock).DestinationAccountId = send.AccountID; // broker (b as IBrokerAccount).RelatedTx = send.Hash; // balance var oldbalance = b.Balances.ToDecimalDict(); oldbalance["LYR"] -= tradeblk.Trade.collateral; b.Balances = oldbalance.ToLongDict(); })); }
protected override async Task <APIResultCodes> AuthorizeImplAsync <T>(DagSystem sys, T tblock) { if (!(tblock is PoolWithdrawBlock)) { return(APIResultCodes.InvalidBlockType); } var block = tblock as PoolWithdrawBlock; var send = await sys.Storage.FindBlockByHashAsync(block.RelatedTx) as SendTransferBlock; if (send == null || send.DestinationAccountId != PoolFactoryBlock.FactoryAccount) { return(APIResultCodes.InvalidMessengerAccount); } var blocks = await sys.Storage.FindBlocksByRelatedTxAsync(block.RelatedTx); if (blocks.Count != 0) { return(APIResultCodes.InvalidRelatedTx); } return(await Lyra.Shared.StopWatcher.TrackAsync(() => base.AuthorizeImplAsync(sys, tblock), "PoolWithdrawAuthorizer->SendTransferAuthorizer")); }
public override async Task <APIResultCodes> PreSendAuthAsync(DagSystem sys, SendTransferBlock send, TransactionBlock last) { if (send.Tags.Count != 2 || !send.Tags.ContainsKey("daoid") || string.IsNullOrWhiteSpace(send.Tags["daoid"]) ) { return(APIResultCodes.InvalidBlockTags); } // dao must exists var dao = await sys.Storage.FindLatestBlockAsync(send.Tags["daoid"]); if (dao == null) { return(APIResultCodes.InvalidDAO); } var txInfo = send.GetBalanceChanges(await sys.Storage.FindBlockByHashAsync(send.PreviousHash) as TransactionBlock); if (txInfo.Changes.Count != 1 || !txInfo.Changes.ContainsKey("LYR")) { return(APIResultCodes.InvalidToken); } //min amount to invest var amount = txInfo.Changes["LYR"]; if (amount < 10000) { return(APIResultCodes.InvalidAmount); } return(APIResultCodes.Success); }
protected override async Task <APIResultCodes> AuthorizeImplAsync <T>(DagSystem sys, T tblock) { if (!(tblock is BenefitingBlock)) { return(APIResultCodes.InvalidBlockType); } var block = tblock as BenefitingBlock; if (block.ShareRito < 0 || block.ShareRito > 1) { return(APIResultCodes.InvalidShareRitio); } if (block.Seats < 0 || block.Seats > 100) { return(APIResultCodes.InvalidSeatsCount); } if (block.ShareRito == 0 && block.Seats != 0) { return(APIResultCodes.InvalidSeatsCount); } if (block.ShareRito > 0 && block.Seats == 0) { return(APIResultCodes.InvalidSeatsCount); } return(await Lyra.Shared.StopWatcher.TrackAsync(() => base.AuthorizeImplAsync(sys, tblock), "BenefitingAuthorizer->BrokerAccountSendAuthorizer")); }
protected override async Task <APIResultCodes> AuthorizeImplAsync <T>(DagSystem sys, T tblock) { if (!(tblock is ProfitingGenesis)) { return(APIResultCodes.InvalidBlockType); } var block = tblock as ProfitingGenesis; if (block.AccountType != AccountTypes.Profiting) { return(APIResultCodes.InvalidBlockType); } var send = await sys.Storage.FindBlockByHashAsync(block.RelatedTx) as SendTransferBlock; if (send == null || send.DestinationAccountId != PoolFactoryBlock.FactoryAccount) { return(APIResultCodes.InvalidMessengerAccount); } // first verify account id // create a semi random account for pool. // it can be verified by other nodes. var keyStr = $"{send.Hash.Substring(0, 16)},{block.PType},{block.ShareRito.ToBalanceLong()},{block.Seats},{send.AccountID}"; var AccountId = Base58Encoding.EncodeAccountId(Encoding.ASCII.GetBytes(keyStr).Take(64).ToArray()); if (block.AccountID != AccountId) { return(APIResultCodes.InvalidAccountId); } return(await Lyra.Shared.StopWatcher.TrackAsync(() => base.AuthorizeImplAsync(sys, tblock), "ProfitingGenesisAuthorizer->ProfitingAuthorizer")); }
public override async Task <APIResultCodes> PreSendAuthAsync(DagSystem sys, SendTransferBlock block, TransactionBlock lastBlock) { var chgs = block.GetBalanceChanges(lastBlock); if (!chgs.Changes.ContainsKey(LyraGlobal.OFFICIALTICKERCODE)) { return(APIResultCodes.InvalidFeeAmount); } var pftid = block.Tags.ContainsKey("pftid") ? block.Tags["pftid"] : null; if (pftid == null) { return(APIResultCodes.InvalidAccountId); } var pft = await sys.Storage.FindFirstBlockAsync(pftid) as ProfitingGenesis; if (pft == null) { return(APIResultCodes.InvalidAccountId); } var stkrs = sys.Storage.FindAllStakings(pftid, DateTime.UtcNow); if (!stkrs.Any(a => a.OwnerAccount == block.AccountID) && pft.OwnerAccountId != block.AccountID) { return(APIResultCodes.RequestNotPermited); } return(APIResultCodes.Success); }
protected override async Task <APIResultCodes> VerifyWithPrevAsync(DagSystem sys, Block block, Block previousBlock) { var cons = block as ConsolidationBlock; var uniNow = DateTime.UtcNow; if (sys.ConsensusState != BlockChainState.StaticSync) { // time shift 10 seconds. if (block.TimeStamp < uniNow.AddSeconds(-60) || block.TimeStamp > uniNow.AddSeconds(3)) { _log.LogInformation($"TimeStamp 3: {block.TimeStamp} Universal Time Now: {uniNow}"); return(APIResultCodes.InvalidBlockTimeStamp); } } var board = await sys.Consensus.Ask <BillBoard>(new AskForBillboard()); if (board.CurrentLeader != cons.createdBy) { _log.LogWarning($"Invalid leader. was {cons.createdBy.Shorten()} should be {board.CurrentLeader.Shorten()}"); return(APIResultCodes.InvalidLeaderInConsolidationBlock); } var result = block.VerifySignature(board.CurrentLeader); if (!result) { _log.LogWarning($"VerifySignature failed for ConsolidationBlock Index: {block.Height} with Leader {board.CurrentLeader}"); return(APIResultCodes.BlockSignatureValidationFailed); } return(await base.VerifyWithPrevAsync(sys, block, previousBlock)); }
public override async Task <APIResultCodes> PreSendAuthAsync(DagSystem sys, SendTransferBlock block, TransactionBlock last) { var dexid = block.Tags.ContainsKey("dexid") ? block.Tags["dexid"] : null; if (dexid == null) { return(APIResultCodes.InvalidAccountId); } decimal mintamount = 0; var mintamountstr = block.Tags.ContainsKey("amount") ? block.Tags["amount"] : null; if (mintamountstr == null || !decimal.TryParse(mintamountstr, out mintamount) || mintamount <= 0) { return(APIResultCodes.InvalidAmount); } // verify if sender is dex server if (block.AccountID != LyraGlobal.GetDexServerAccountID(LyraNodeConfig.GetNetworkId())) { return(APIResultCodes.InvalidDexServer); } // verify dex wallet owner var brkr = await sys.Storage.FindLatestBlockAsync(dexid) as IBrokerAccount; if (brkr == null) { return(APIResultCodes.InvalidBrokerAcount); } return(APIResultCodes.Success); }
private async Task <TransactionBlock> GetBlocksAsync(DagSystem sys, SendTransferBlock send) { var blocks = await sys.Storage.FindBlocksByRelatedTxAsync(send.Hash); var resolv = JsonConvert.DeserializeObject <ODRResolution>(send.Tags["data"]); if (blocks.Count < resolv.actions.Length + 1) { // populate tos var tradegen = await sys.Storage.FindFirstBlockAsync(resolv.tradeid) as IOtcTrade; var tos = new Dictionary <Parties, string> { { Parties.Seller, tradegen.Trade.orderOwnerId }, { Parties.Buyer, (tradegen as IBrokerAccount).OwnerAccountId }, { Parties.DAOTreasure, (tradegen as TransactionBlock).AccountID } }; return(await SlashCollateral(sys, send, tos[resolv.actions[blocks.Count - 1].to], resolv.actions[blocks.Count - 1].amount)); } else { return(null); } }
public override async Task <APIResultCodes> PreSendAuthAsync(DagSystem sys, SendTransferBlock block, TransactionBlock last) { var dexid3 = block.Tags.ContainsKey("dexid") ? block.Tags["dexid"] : null; if (dexid3 == null) { return(APIResultCodes.InvalidAccountId); } // verify owner var lb3 = await sys.Storage.FindLatestBlockAsync(dexid3) as IDexWallet; if (lb3 == null || block.AccountID != lb3.OwnerAccountId) { return(APIResultCodes.InvalidAccountId); } var tickerp = $"tether/{lb3.ExtSymbol}"; var userlb = await sys.Storage.FindLatestBlockAsync(block.AccountID) as TransactionBlock; if (userlb == null || !userlb.Balances.ContainsKey(tickerp)) { return(APIResultCodes.InvalidAmount); } return(APIResultCodes.Success); }
protected async Task <TransactionBlock> SlashCollateral(DagSystem sys, SendTransferBlock send, string to, decimal amount) { var blocks = await sys.Storage.FindBlocksByRelatedTxAsync(send.Hash); var resolv = JsonConvert.DeserializeObject <ODRResolution>(send.Tags["data"]); var tradelatest = await sys.Storage.FindLatestBlockAsync(resolv.tradeid) as IOtcTrade; var daolatest = await sys.Storage.FindLatestBlockAsync(tradelatest.Trade.daoId) as TransactionBlock; var daosendblk = await TransactionOperateAsync(sys, send.Hash, daolatest, () => daolatest.GenInc <DaoSendBlock>(), (b) => { // send (b as SendTransferBlock).DestinationAccountId = to; // broker (b as IBrokerAccount).RelatedTx = send.Hash; var oldbalance = daolatest.Balances.ToDecimalDict(); oldbalance["LYR"] -= amount; b.Balances = oldbalance.ToLongDict(); }); return(daosendblk); }
public override async Task <TransactionBlock> ExtraOpsAsync(DagSystem sys, string hash) { var blocks = await sys.Storage.FindBlocksByRelatedTxAsync(hash); if (!blocks.Any(a => a is TokenWithdrawBlock)) { throw new Exception($"TokenWithdrawBlock not found."); } var burnblock = blocks.Where(a => a is TokenWithdrawBlock).First(); var burnbrk = burnblock as IBrokerAccount; var burn = burnblock as TokenWithdrawBlock; var dc = new DexClient(LyraNodeConfig.GetNetworkId()); var ret = await dc.RequestWithdrawAsync(burnbrk.OwnerAccountId, burn.ExtSymbol, burn.ExtProvider, burn.AccountID, hash, burn.WithdrawToExtAddress, burn.BurnAmount, NodeService.Dag.PosWallet.AccountId, Signatures.GetSignature(NodeService.Dag.PosWallet.PrivateKey, hash, NodeService.Dag.PosWallet.AccountId)); if (!ret.Success) { throw new Exception($"Error RequestWithdrawAsync to DEX Server: {ret.Message}"); } return(null); }
public override async Task <APIResultCodes> PreSendAuthAsync(DagSystem sys, SendTransferBlock send, TransactionBlock last) { if (send.Tags.Count != 2 || !send.Tags.ContainsKey("daoid") || string.IsNullOrWhiteSpace(send.Tags["daoid"]) ) { return(APIResultCodes.InvalidBlockTags); } // dao must exists var dao = await sys.Storage.FindLatestBlockAsync(send.Tags["daoid"]); if (dao == null) { return(APIResultCodes.InvalidDAO); } // invest must exists if (!(dao as IDao).Treasure.ContainsKey(send.AccountID)) { return(APIResultCodes.AccountDoesNotExist); } return(APIResultCodes.Success); }