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);
}