public void SignNeo()
{
var account_id = Signatures.GetAccountIdFromPrivateKey(PrivateKey1);
var result = Signatures.GetSignature(PrivateKey1, message, account_id);
Assert.IsNotNull(result);
}
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);
}
protected void Sign <T>(ref T tblock)
{
if (!(tblock is TransactionBlock))
{
throw new System.ApplicationException("APIResultCodes.InvalidBlockType");
}
var block = tblock as TransactionBlock;
// ServiceHash is excluded when calculating the block hash,
// but it is included when creating/validating the authorization signature
block.ServiceHash = _serviceAccount.GetLatestBlock().Hash;
// sign with the authorizer key
AuthorizationSignature authSignature = new AuthorizationSignature
{
Key = _serviceAccount.AccountId,
Signature = Signatures.GetSignature(_serviceAccount.PrivateKey, block.Hash + block.ServiceHash)
};
if (block.Authorizations == null)
{
block.Authorizations = new List <AuthorizationSignature>();
}
block.Authorizations.Add(authSignature);
}
public LightWallet(SecureString privateKey, string networkId)
{
_securePrivateKey = privateKey;
_networkId = networkId;
_accountId = Signatures.GetAccountIdFromPrivateKey(new NetworkCredential("", _securePrivateKey).Password);
_client = new LyraJsonRPCClient(_networkId, (s) =>
Task.FromResult(Signatures.GetSignature(new NetworkCredential("", _securePrivateKey).Password, s, _accountId)));
}
public void VerifySignatureNeo()
{
var account_id = Signatures.GetAccountIdFromPrivateKey(PrivateKey1);
var signature = Signatures.GetSignature(PrivateKey1, message, account_id);
var result = Signatures.VerifyAccountSignature(message, account_id, signature);
Assert.IsTrue(result);
}
public string Sign(string PrivateKey, string accountId)
{
if (string.IsNullOrWhiteSpace(Hash))
{
Hash = CalculateHash();
}
Signature = Signatures.GetSignature(PrivateKey, Hash, accountId);
return(this.Signature);
}
public string Sign(string PrivateKey, string accountId)
{
if (string.IsNullOrWhiteSpace(Hash))
{
Hash = CalculateHash();
}
//Console.WriteLine($"Hash: {Hash}\nAccountID: {accountId}");
Signature = Signatures.GetSignature(PrivateKey, Hash, accountId);
return(this.Signature);
}
public TransitWallet(string AccountId, string signingPrivateKey, LyraRestClient client)
{
_signingPrivateKey = signingPrivateKey;
_signingAccountId = Signatures.GetAccountIdFromPrivateKey(_signingPrivateKey);
_accountId = AccountId;
_rpcClient = client;
_signer = (hash) => Task.FromResult(Signatures.GetSignature(_signingPrivateKey, hash, _signingAccountId));
}
public TransitWallet(string privateKey, LyraRestClient client)
{
_uniqId = Guid.NewGuid().ToString();
_privateKey = privateKey;
_accountId = Signatures.GetAccountIdFromPrivateKey(privateKey);
_rpcClient = client;
_signer = (hash) => Signatures.GetSignature(_privateKey, hash, _accountId);
}
protected AuthorizationSignature Sign <T>(DagSystem sys, T tblock)
{
if (!(tblock is Block))
{
throw new System.Exception("APIResultCodes.InvalidBlockType");
}
var block = tblock as Block;
// sign with the authorizer key
AuthorizationSignature authSignature = new AuthorizationSignature
{
Key = sys.PosWallet.AccountId,
Signature = Signatures.GetSignature(sys.PosWallet.PrivateKey,
block.Hash, sys.PosWallet.AccountId)
};
return(authSignature);
}
/// <summary>
/// two ways to begin view changing: either one third of all voters requested, or local requested.
///
/// </summary>
/// <returns></returns>
internal async Task BeginChangeViewAsync(ViewChangeReason reason)
{
_log.LogInformation($"BeginChangeViewAsync: VID: {ViewId} Req: {reqMsgs.Count} Reply: {replyMsgs.Count} Commit: {commitMsgs.Count} Votes {commitMsgs.Count}/{LyraGlobal.GetMajority(_context.Board.AllVoters.Count)}/{_context.Board.AllVoters.Count} Replyed: {replySent} Commited: {commitSent}");
_reason = reason;
var lastSb = await _sys.Storage.GetLastServiceBlockAsync();
if (lastSb == null)
{
// genesis?
_log.LogCritical($"BeginChangeViewAsync has null service block. should not happend. error.");
return;
}
_isViewChanging = true;
ShiftView(lastSb.Height + 1);
selectedSuccess = false;
_log.LogInformation($"View change for ViewId {ViewId} begin at {TimeStarted}");
CalculateLeaderCandidate();
var lastCons = await _sys.Storage.GetLastConsolidationBlockAsync();
var req = new ViewChangeRequestMessage
{
From = _sys.PosWallet.AccountId,
ViewID = ViewId,
prevViewID = lastSb.Height,
requestSignature = Signatures.GetSignature(_sys.PosWallet.PrivateKey,
$"{lastSb.Hash}|{lastCons.Hash}", _sys.PosWallet.AccountId),
};
_context.Send2P2pNetwork(req);
await CheckRequestAsync(req);
}
public override async Task <APIResultCodes> PreSendAuthAsync(DagSystem sys, SendTransferBlock send, TransactionBlock last)
{
if (send.Tags.Count != 4 ||
!send.Tags.ContainsKey("tradeid") ||
string.IsNullOrWhiteSpace(send.Tags["tradeid"]) ||
!send.Tags.ContainsKey("orderid") ||
string.IsNullOrWhiteSpace(send.Tags["orderid"]) ||
!send.Tags.ContainsKey("daoid") ||
string.IsNullOrWhiteSpace(send.Tags["daoid"])
)
{
return(APIResultCodes.InvalidBlockTags);
}
var tradeid = send.Tags["tradeid"];
var orderid = send.Tags["orderid"];
var daoid = send.Tags["daoid"];
var tradeblk = await sys.Storage.FindLatestBlockAsync(tradeid);
var daoblk = await sys.Storage.FindLatestBlockAsync((tradeblk as IOtcTrade).Trade.daoId);
if (daoblk == null || tradeblk == null || (daoblk as TransactionBlock).AccountID != daoid ||
(tradeblk as IOtcTrade).Trade.daoId != (daoblk as TransactionBlock).AccountID)
{
return(APIResultCodes.InvalidTrade);
}
if ((tradeblk as IBrokerAccount).OwnerAccountId != send.AccountID)
{
return(APIResultCodes.InvalidTrade);
}
if ((tradeblk as IOtcTrade).OTStatus != OTCTradeStatus.Open)
{
return(APIResultCodes.InvalidTrade);
}
var orderblk = await sys.Storage.FindLatestBlockAsync(orderid);
if (orderblk == null || (tradeblk as IOtcTrade).Trade.orderId != orderid ||
(tradeblk as IOtcTrade).Trade.daoId != daoid)
{
return(APIResultCodes.InvalidTrade);
}
if (Settings.Default.LyraNode.Lyra.NetworkId != "xtest")
{
// check if trade is cancellable
var lsb = sys.Storage.GetLastServiceBlock();
var wallet = sys.PosWallet;
var sign = Signatures.GetSignature(wallet.PrivateKey, lsb.Hash, wallet.AccountId);
var dlrblk = await sys.Storage.FindLatestBlockAsync((tradeblk as IOtcTrade).Trade.dealerId);
var uri = new Uri(new Uri((dlrblk as IDealer).Endpoint), "/api/dealer/");
var dealer = new DealerClient(uri);
var ret = await dealer.GetTradeBriefAsync(tradeid, wallet.AccountId, sign);
if (!ret.Successful() || !ret.Deserialize <TradeBrief>().IsCancellable)
{
return(APIResultCodes.InvalidOperation);
}
}
return(APIResultCodes.Success);
}
private void StartInit()
{
if (0 == GetBlockCount() && NodeService.Instance.PosWallet.AccountId ==
ProtocolSettings.Default.StandbyValidators[0])
{
// do genesis
var authGenesis = new ServiceBlock
{
Index = 1,
UIndex = 1,
NetworkId = _nodeConfig.Lyra.NetworkId,
ShardId = "Primary",
TransferFee = 1,
TokenGenerationFee = 100,
TradeFee = 0.1m,
SvcAccountID = NodeService.Instance.PosWallet.AccountId
};
authGenesis.InitializeBlock(null, NodeService.Instance.PosWallet.PrivateKey,
_nodeConfig.Lyra.NetworkId, authGenesis.ShardId,
NodeService.Instance.PosWallet.AccountId);
authGenesis.UHash = SignableObject.CalculateHash($"{authGenesis.UIndex}|{authGenesis.Index}|{authGenesis.Hash}");
authGenesis.Authorizations = new List <AuthorizationSignature>();
authGenesis.Authorizations.Add(new AuthorizationSignature
{
Key = NodeService.Instance.PosWallet.AccountId,
Signature = Signatures.GetSignature(NodeService.Instance.PosWallet.PrivateKey, authGenesis.Hash, NodeService.Instance.PosWallet.AccountId)
});
// TODO: add more seed's auth info
_store.AddBlock(authGenesis);
// the first consolidate block
var consBlock = new ConsolidationBlock
{
UIndex = 2,
NetworkId = authGenesis.NetworkId,
ShardId = authGenesis.ShardId,
ServiceHash = authGenesis.Hash,
SvcAccountID = NodeService.Instance.PosWallet.AccountId
};
consBlock.InitializeBlock(authGenesis, NodeService.Instance.PosWallet.PrivateKey,
_nodeConfig.Lyra.NetworkId, authGenesis.ShardId,
NodeService.Instance.PosWallet.AccountId);
consBlock.UHash = SignableObject.CalculateHash($"{consBlock.UIndex}|{consBlock.Index}|{consBlock.Hash}");
consBlock.Authorizations = new List <AuthorizationSignature>();
consBlock.Authorizations.Add(new AuthorizationSignature
{
Key = NodeService.Instance.PosWallet.AccountId,
Signature = Signatures.GetSignature(NodeService.Instance.PosWallet.PrivateKey, consBlock.Hash + consBlock.ServiceHash, NodeService.Instance.PosWallet.AccountId)
});
_store.AddBlock(consBlock);
// tell consensus what happened
InSyncing = false;
var board = new BillBoard();
board.Add(NodeService.Instance.PosWallet.AccountId); // add me!
LyraSystem.Singleton.Consensus.Tell(board);
LyraSystem.Singleton.Consensus.Tell(new ConsensusService.BlockChainSynced());
_log.LogInformation("Service Genesis Completed.");
}
else
{
SyncBlocksFromSeeds(0);
}
}
// every method must check if the operation has been done.
// if has been done, return null.
public static async Task <ReceiveTransferBlock> ReceivePoolFactoryFeeAsync(DagSystem sys, SendTransferBlock sendBlock)
{
// check exists
var recv = await sys.Storage.FindBlockBySourceHashAsync(sendBlock.Hash);
if (recv != null)
{
return(null);
}
TransactionBlock prevSend = await sys.Storage.FindBlockByHashAsync(sendBlock.PreviousHash) as TransactionBlock;
if (prevSend == null)
{
return(null); // process missing block
}
var txInfo = sendBlock.GetBalanceChanges(prevSend);
var lsb = await sys.Storage.GetLastServiceBlockAsync();
var receiveBlock = new ReceiveAsFeeBlock
{
AccountID = sendBlock.DestinationAccountId,
VoteFor = null,
ServiceHash = lsb.Hash,
SourceHash = sendBlock.Hash,
Balances = new Dictionary <string, long>(),
Fee = Math.Round(txInfo.Changes[LyraGlobal.OFFICIALTICKERCODE], 8, MidpointRounding.ToZero),
FeeCode = LyraGlobal.OFFICIALTICKERCODE,
FeeType = AuthorizationFeeTypes.FullFee,
};
receiveBlock.AddTag(Block.MANAGEDTAG, ""); // value is always ignored
TransactionBlock latestPoolBlock = await sys.Storage.FindLatestBlockAsync(sendBlock.DestinationAccountId) as TransactionBlock;
var latestBalances = latestPoolBlock.Balances.ToDecimalDict();
var recvBalances = latestPoolBlock.Balances.ToDecimalDict();
receiveBlock.Balances = recvBalances.ToLongDict();
await receiveBlock.InitializeBlockAsync(latestPoolBlock, (hash) => Task.FromResult(Signatures.GetSignature(sys.PosWallet.PrivateKey, hash, sys.PosWallet.AccountId)));
return(receiveBlock);
}
public override async Task <TransactionBlock> ExtraOpsAsync(DagSystem sys, string reqHash)
{
var blocks = await sys.Storage.FindBlocksByRelatedTxAsync(reqHash);
var swout = blocks.FirstOrDefault(a => a is PoolSwapOutBlock);
if (swout != null)
{
return(null);
}
var recv = blocks.FirstOrDefault(a => a is PoolSwapInBlock) as PoolSwapInBlock;
var swapInBlock = recv as PoolSwapInBlock;
var recvBlockPrev = await sys.Storage.FindBlockByHashAsync(recv.PreviousHash) as TransactionBlock;
var recvChgs = swapInBlock.GetBalanceChanges(recvBlockPrev);
var kvp = recvChgs.Changes.First();
var poolGenesis = await sys.Storage.FindFirstBlockAsync(swapInBlock.AccountID) as PoolGenesisBlock;
var cfg = new SwapCalculator(poolGenesis.Token0, poolGenesis.Token1, recvBlockPrev,
kvp.Key, kvp.Value, 0);
var lsb = await sys.Storage.GetLastServiceBlockAsync();
var send = await sys.Storage.FindBlockByHashAsync(swapInBlock.SourceHash) as SendTransferBlock;
var swapOutBlock = new PoolSwapOutBlock
{
AccountID = send.DestinationAccountId,
ServiceHash = lsb.Hash,
DestinationAccountId = send.AccountID,
Balances = new Dictionary <string, long>(),
Tags = null,
Fee = cfg.PayToAuthorizer,
FeeCode = LyraGlobal.OFFICIALTICKERCODE,
FeeType = AuthorizationFeeTypes.Dynamic,
RelatedTx = send.Hash
};
swapOutBlock.AddTag(Block.MANAGEDTAG, ""); // value is always ignored
var poolGenesisBlock = await sys.Storage.FindFirstBlockAsync(recv.AccountID) as PoolGenesisBlock;
var poolLatestBlock = await sys.Storage.FindLatestBlockAsync(recv.AccountID) as TransactionBlock;
var curBalance = poolLatestBlock.Balances.ToDecimalDict();
var nextBalance = poolLatestBlock.Balances.ToDecimalDict();
var tokenOut = cfg.SwapOutToken;
var tokenIn = cfg.SwapInToken;
if (tokenIn == LyraGlobal.OFFICIALTICKERCODE)
{
// tokenIn == LYR
nextBalance[tokenIn] = curBalance[tokenIn] - cfg.PayToAuthorizer; // pool fee leave in the pool
nextBalance[tokenOut] = curBalance[tokenOut] - cfg.SwapOutAmount;
}
else
{
// tokenIn == other token
nextBalance[tokenIn] = curBalance[tokenIn]; // pool fee leave in the pool
nextBalance[tokenOut] = curBalance[tokenOut] - cfg.SwapOutAmount - cfg.PayToAuthorizer;
}
Console.WriteLine($"user should receive {cfg.SwapOutAmount} {cfg.SwapOutToken}");
swapOutBlock.Balances = nextBalance.ToLongDict();
swapOutBlock.Shares = (poolLatestBlock as IPool).Shares;
await swapOutBlock.InitializeBlockAsync(poolLatestBlock, (hash) => Task.FromResult(Signatures.GetSignature(sys.PosWallet.PrivateKey, hash, sys.PosWallet.AccountId)));
// verify
var chgs = swapOutBlock.GetBalanceChanges(poolLatestBlock);
return(swapOutBlock);
}
public void Sign()
{
Signature = Signatures.GetSignature(NodeService.Instance.PosWallet.PrivateKey,
IPAddress, NodeService.Instance.PosWallet.AccountId);
}
public static async Task <ReceiveTransferBlock> ReceiveDaoFeeAsync(DagSystem sys, SendTransferBlock sendBlock)
{
// check exists
var recv = await sys.Storage.FindBlockBySourceHashAsync(sendBlock.Hash);
if (recv != null)
{
return(null);
}
var txInfo = sendBlock.GetBalanceChanges(await sys.Storage.FindBlockByHashAsync(sendBlock.PreviousHash) as TransactionBlock);
var lastblock = await sys.Storage.FindLatestBlockAsync(sendBlock.DestinationAccountId) as TransactionBlock;
var lsb = await sys.Storage.GetLastServiceBlockAsync();
var receiveBlock = new DaoRecvBlock
{
// block
ServiceHash = lsb.Hash,
// transaction
AccountID = sendBlock.DestinationAccountId,
SourceHash = sendBlock.Hash,
Balances = new Dictionary <string, long>(),
Fee = 0,
FeeCode = LyraGlobal.OFFICIALTICKERCODE,
FeeType = AuthorizationFeeTypes.NoFee,
// broker
Name = ((IBrokerAccount)lastblock).Name,
OwnerAccountId = ((IBrokerAccount)lastblock).OwnerAccountId,
RelatedTx = sendBlock.Hash,
// profiting
PType = ((IProfiting)lastblock).PType,
ShareRito = ((IProfiting)lastblock).ShareRito,
Seats = ((IProfiting)lastblock).Seats,
// dao
SellerFeeRatio = ((IDao)lastblock).SellerFeeRatio,
BuyerFeeRatio = ((IDao)lastblock).BuyerFeeRatio,
SellerPar = ((IDao)lastblock).SellerPar,
BuyerPar = ((IDao)lastblock).BuyerPar,
Treasure = ((IDao)lastblock).Treasure.ToDecimalDict().ToLongDict(),
Description = ((IDao)lastblock).Description,
};
receiveBlock.AddTag(Block.MANAGEDTAG, ""); // value is always ignored
var latestBalances = lastblock.Balances.ToDecimalDict();
var recvBalances = lastblock.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);
}
}
receiveBlock.Balances = recvBalances.ToLongDict();
await receiveBlock.InitializeBlockAsync(lastblock, (hash) => Task.FromResult(Signatures.GetSignature(sys.PosWallet.PrivateKey, hash, sys.PosWallet.AccountId)));
return(receiveBlock);
}
protected async Task <TransactionBlock> ChangeStateAsync(DagSystem sys, SendTransferBlock sendBlock)
{
// check exists
var recv = await sys.Storage.FindBlockBySourceHashAsync(sendBlock.Hash);
if (recv != null)
{
return(null);
}
var txInfo = sendBlock.GetBalanceChanges(await sys.Storage.FindBlockByHashAsync(sendBlock.PreviousHash) as TransactionBlock);
var lastblock = await sys.Storage.FindLatestBlockAsync(sendBlock.DestinationAccountId) as TransactionBlock;
var lsb = await sys.Storage.GetLastServiceBlockAsync();
var receiveBlock = new OtcTradeRecvBlock
{
// block
ServiceHash = lsb.Hash,
// transaction
AccountID = sendBlock.DestinationAccountId,
SourceHash = sendBlock.Hash,
Balances = new Dictionary <string, long>(),
Fee = 0,
FeeCode = LyraGlobal.OFFICIALTICKERCODE,
FeeType = AuthorizationFeeTypes.NoFee,
// broker
Name = ((IBrokerAccount)lastblock).Name,
OwnerAccountId = ((IBrokerAccount)lastblock).OwnerAccountId,
RelatedTx = sendBlock.Hash,
// trade
Trade = ((IOtcTrade)lastblock).Trade,
OTStatus = OTCTradeStatus.FiatSent,
};
receiveBlock.AddTag(Block.MANAGEDTAG, ""); // value is always ignored
var latestBalances = lastblock.Balances.ToDecimalDict();
var recvBalances = lastblock.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);
}
}
receiveBlock.Balances = recvBalances.ToLongDict();
await receiveBlock.InitializeBlockAsync(lastblock, (hash) => Task.FromResult(Signatures.GetSignature(sys.PosWallet.PrivateKey, hash, sys.PosWallet.AccountId)));
return(receiveBlock);
}
protected override Task <string> SignMessageAsync(string message)
{
Console.WriteLine($"Signing: {message}");
return(Task.FromResult(Signatures.GetSignature(_privateKey, message, _accountId)));
}
protected async Task <TransactionBlock> TransactionOperateAsync(
DagSystem sys,
string relatedHash,
Block prevBlock,
Func <TransactionBlock> GenBlock,
Action <TransactionBlock> ChangeBlock
)
{
var lsb = await sys.Storage.GetLastServiceBlockAsync();
var nextblock = GenBlock();
// block
nextblock.ServiceHash = lsb.Hash;
nextblock.Tags?.Clear();
nextblock.AddTag(Block.MANAGEDTAG, ""); // value is always ignored
// ibroker
(nextblock as IBrokerAccount).RelatedTx = relatedHash;
if (ChangeBlock != null)
{
ChangeBlock(nextblock);
}
await nextblock.InitializeBlockAsync(prevBlock, (hash) => Task.FromResult(Signatures.GetSignature(sys.PosWallet.PrivateKey, hash, sys.PosWallet.AccountId)));
return(nextblock);
}
private async Task <string> SignAPIAsync()
{
var lsb = await client.GetLastServiceBlockAsync();
return(Signatures.GetSignature(testPrivateKey, lsb.GetBlock().Hash, testPublicKey));
}
private async Task <string> SignAPIAsync()
{
var lsb = await client.GetLastServiceBlockAsync();
return(Signatures.GetSignature(PRIVATE_KEY_1, lsb.GetBlock().Hash, ADDRESS_ID_1));
}
protected async Task <TransactionBlock> TradeBlockOperateAsync(
DagSystem sys,
SendTransferBlock sendBlock,
Func <TransactionBlock> GenBlock,
Action <TransactionBlock> ChangeBlock
)
{
var lastblock = await sys.Storage.FindLatestBlockAsync(sendBlock.DestinationAccountId) as TransactionBlock;
var lsb = await sys.Storage.GetLastServiceBlockAsync();
var nextblock = GenBlock();
// block
nextblock.ServiceHash = lsb.Hash;
// transaction
nextblock.AccountID = sendBlock.DestinationAccountId;
nextblock.Balances = new Dictionary <string, long>();
nextblock.Fee = 0;
nextblock.FeeCode = LyraGlobal.OFFICIALTICKERCODE;
nextblock.FeeType = AuthorizationFeeTypes.NoFee;
// broker
(nextblock as IBrokerAccount).Name = ((IBrokerAccount)lastblock).Name;
(nextblock as IBrokerAccount).OwnerAccountId = ((IBrokerAccount)lastblock).OwnerAccountId;
(nextblock as IBrokerAccount).RelatedTx = sendBlock.Hash;
// trade
(nextblock as IOtcTrade).Trade = ((IOtcTrade)lastblock).Trade;
(nextblock as IOtcTrade).OTStatus = ((IOtcTrade)lastblock).OTStatus;
nextblock.AddTag(Block.MANAGEDTAG, ""); // value is always ignored
var latestBalances = lastblock.Balances.ToDecimalDict();
var recvBalances = lastblock.Balances.ToDecimalDict();
nextblock.Balances = recvBalances.ToLongDict();
ChangeBlock(nextblock);
await nextblock.InitializeBlockAsync(lastblock, (hash) => Task.FromResult(Signatures.GetSignature(sys.PosWallet.PrivateKey, hash, sys.PosWallet.AccountId)));
return(nextblock);
}
public override async Task <TransactionBlock> BrokerOpsAsync(DagSystem sys, SendTransferBlock send)
{
var blocks = await sys.Storage.FindBlocksByRelatedTxAsync(send.Hash);
if (blocks.Any(a => a is PoolWithdrawBlock))
{
return(null);
}
var lsb = await sys.Storage.GetLastServiceBlockAsync();
var recvBlock = await sys.Storage.FindBlockBySourceHashAsync(send.Hash);
var poolGenesis = sys.Storage.GetPoolByID(send.Tags["poolid"]);
var poolId = poolGenesis.AccountID;
PoolWithdrawBlock withdrawBlock = new PoolWithdrawBlock
{
AccountID = poolId,
ServiceHash = lsb.Hash,
DestinationAccountId = send.AccountID,
Balances = new Dictionary <string, long>(),
Tags = null,
Fee = 0,
FeeCode = LyraGlobal.OFFICIALTICKERCODE,
FeeType = AuthorizationFeeTypes.NoFee,
RelatedTx = send.Hash
};
var sendBlock = await sys.Storage.FindBlockByHashAsync(recvBlock.SourceHash) as SendTransferBlock;
withdrawBlock.AddTag(Block.MANAGEDTAG, ""); // value is always ignored
var poolGenesisBlock = await sys.Storage.FindFirstBlockAsync(poolId) as PoolGenesisBlock;
var poolLatestBlock = await sys.Storage.FindLatestBlockAsync(poolId) as TransactionBlock;
var curBalance = poolLatestBlock.Balances.ToDecimalDict();
var curShares = (poolLatestBlock as IPool).Shares.ToRitoDecimalDict();
var nextBalance = poolLatestBlock.Balances.ToDecimalDict();
var nextShares = (poolLatestBlock as IPool).Shares.ToRitoDecimalDict();
var usersShare = curShares[send.AccountID];
var amountsToSend = new Dictionary <string, decimal>
{
{ poolGenesisBlock.Token0, curBalance[poolGenesisBlock.Token0] * usersShare },
{ poolGenesisBlock.Token1, curBalance[poolGenesisBlock.Token1] * usersShare }
};
nextBalance[poolGenesisBlock.Token0] -= amountsToSend[poolGenesisBlock.Token0];
nextBalance[poolGenesisBlock.Token1] -= amountsToSend[poolGenesisBlock.Token1];
nextShares.Remove(send.AccountID);
foreach (var share in curShares)
{
if (share.Key == send.AccountID)
{
continue;
}
nextShares[share.Key] = (share.Value * curBalance[poolGenesisBlock.Token0]) / nextBalance[poolGenesisBlock.Token0];
}
withdrawBlock.Balances = nextBalance.ToLongDict();
withdrawBlock.Shares = nextShares.ToRitoLongDict();
await withdrawBlock.InitializeBlockAsync(poolLatestBlock, (hash) => Task.FromResult(Signatures.GetSignature(sys.PosWallet.PrivateKey, hash, sys.PosWallet.AccountId)));
return(withdrawBlock);
}
public async Task <string> SignAPICallAsync()
{
var syncInfo = await _client.GetSyncHeight();
return(Signatures.GetSignature(NodeService.Instance.PosWallet.PrivateKey, syncInfo.SyncHash, NodeService.Instance.PosWallet.AccountId));
}
public override async Task <TransactionBlock> BrokerOpsAsync(DagSystem sys, SendTransferBlock sendBlock)
{
// assume all send variables are legal
// token0/1, amount, etc.
var blocks = await sys.Storage.FindBlocksByRelatedTxAsync(sendBlock.Hash);
if (blocks.Any(a => a is PoolSwapInBlock))
{
return(null);
}
var lsb = await sys.Storage.GetLastServiceBlockAsync();
var swapInBlock = new PoolSwapInBlock
{
AccountID = sendBlock.DestinationAccountId,
VoteFor = null,
ServiceHash = lsb.Hash,
SourceHash = sendBlock.Hash,
Balances = new Dictionary <string, long>(),
Fee = 0,
FeeCode = LyraGlobal.OFFICIALTICKERCODE,
FeeType = AuthorizationFeeTypes.NoFee,
RelatedTx = sendBlock.Hash
};
swapInBlock.AddTag(Block.MANAGEDTAG, ""); // value is always ignored
TransactionBlock prevSend = await sys.Storage.FindBlockByHashAsync(sendBlock.PreviousHash) as TransactionBlock;
var txInfo = sendBlock.GetBalanceChanges(prevSend);
TransactionBlock latestPoolBlock = await sys.Storage.FindLatestBlockAsync(sendBlock.DestinationAccountId) as TransactionBlock;
PoolGenesisBlock poolGenesis = await sys.Storage.FindFirstBlockAsync(latestPoolBlock.AccountID) as PoolGenesisBlock;
var depositBalance = new Dictionary <string, decimal>();
if (latestPoolBlock.Balances.Any())
{
var lastBalance = latestPoolBlock.Balances.ToDecimalDict();
// the rito must be preserved for every deposition
//var poolRito = lastBalance[poolGenesis.Token0] / lastBalance[poolGenesis.Token1];
foreach (var oldBalance in lastBalance)
{
if (txInfo.Changes.ContainsKey(oldBalance.Key))
{
depositBalance.Add(oldBalance.Key, oldBalance.Value + txInfo.Changes[oldBalance.Key]);
}
else
{
depositBalance.Add(oldBalance.Key, oldBalance.Value);
}
}
var prevBalance = lastBalance[poolGenesis.Token0];
var curBalance = depositBalance[poolGenesis.Token0];
}
else
{
foreach (var token in txInfo.Changes)
{
depositBalance.Add(token.Key, token.Value);
}
}
swapInBlock.Balances = depositBalance.ToLongDict();
swapInBlock.Shares = (latestPoolBlock as IPool).Shares;
await swapInBlock.InitializeBlockAsync(latestPoolBlock, (hash) => Task.FromResult(Signatures.GetSignature(sys.PosWallet.PrivateKey, hash, sys.PosWallet.AccountId)));
return(swapInBlock);
}
public override async Task <TransactionBlock> BrokerOpsAsync(DagSystem sys, SendTransferBlock send)
{
var symbol = send.Tags["symbol"];
var provider = send.Tags["provider"];
// request a wallet from dex server
var dc = new DexClient(LyraNodeConfig.GetNetworkId());
var r1 = await dc.CreateWalletAsync(send.AccountID, symbol, provider,
send.Hash,
NodeService.Dag.PosWallet.AccountId,
Signatures.GetSignature(NodeService.Dag.PosWallet.PrivateKey, send.Hash, NodeService.Dag.PosWallet.AccountId)
);
if (!r1.Success)
{
throw new Exception("DEX Server failed: " + r1.Message);
}
var extw = r1 as DexAddress;
//Assert.IsTrue(extw.Address.StartsWith('T'));
var keyStr = $"{send.Hash.Substring(0, 16)},{symbol},{provider},{send.AccountID}";
var AccountId = Base58Encoding.EncodeAccountId(Encoding.ASCII.GetBytes(keyStr).Take(64).ToArray());
var exists = await sys.Storage.FindDexWalletAsync(send.AccountID, symbol, provider);
if (exists != null)
{
return(null);
}
var sb = await sys.Storage.GetLastServiceBlockAsync();
var wgen = new DexWalletGenesis
{
Height = 1,
ServiceHash = sb.Hash,
Fee = 0,
FeeCode = LyraGlobal.OFFICIALTICKERCODE,
FeeType = AuthorizationFeeTypes.NoFee,
// transaction
AccountID = AccountId, // in fact we not use this account.
Balances = new Dictionary <string, long>(),
// broker
Name = symbol + (String.IsNullOrEmpty(provider) ? "" : $" via {provider}"),
OwnerAccountId = send.AccountID,
RelatedTx = send.Hash,
// Dex wallet
IntSymbol = $"${symbol}",
ExtSymbol = symbol,
ExtProvider = provider,
ExtAddress = extw.Address,
// genesis
AccountType = AccountTypes.DEX
};
wgen.AddTag(Block.MANAGEDTAG, ""); // value is always ignored
wgen.InitializeBlock(null, NodeService.Dag.PosWallet.PrivateKey, AccountId: NodeService.Dag.PosWallet.AccountId);
return(wgen);
}
private async Task TestDepositWithdraw(Wallet dexWallet)
{
//// prepare dex
//string lyrawalletfolder = Wallet.GetFullFolderName(networkId, "wallets");
//var walletStore = new SecuredWalletStore(lyrawalletfolder);
//var dexWallet = Wallet.Open(walletStore, "dex", "");
//await genesisWallet.SendAsync(100000m, dexWallet.AccountId);
//await Task.Delay(1000);
//await dexWallet.SyncAsync(genesisWallet.RPC);
//Assert.IsTrue(dexWallet.BaseBalance >= 100000m);
// external token genesis
var lsbret = await client.GetLastServiceBlockAsync();
Assert.IsTrue(lsbret.Successful());
var lsb = lsbret.GetBlock();
var tgexists = await client.GetTokenGenesisBlockAsync(dexWallet.AccountId, "tether/TRX",
Signatures.GetSignature(dexWallet.PrivateKey, lsb.Hash, dexWallet.AccountId));
if (!tgexists.Successful())
{
var tokenGenesisResult = await dexWallet.CreateTokenAsync("TRX", "tether", "", 8, 0, false, dexWallet.AccountId,
"", "", ContractTypes.Cryptocurrency, null);
Assert.IsTrue(tokenGenesisResult.Successful(), "dex token genesis failed");
}
var dexws = await dexWallet.GetAllDexWalletsAsync(dexWallet.AccountId);
Assert.IsNotNull(dexws, "DEX Wallet not setup.");
var wcnt = dexws.Count(a => (a as IDexWallet).ExtSymbol == "TRX" && (a as IDexWallet).ExtProvider == "native");
Assert.AreEqual(1, wcnt, $"wallet not created properly. created: {wcnt}");
// must fail
await dexWallet.SyncAsync(null);
var getokretx = await dexWallet.DexGetTokenAsync((dexws.First() as TransactionBlock).AccountID, 500m);
Assert.IsTrue(!getokretx.Successful(), "Should not success");
// mint via dex account
/*
* var
* var dexbrk1 = dexws.First() as TransactionBlock;
* var mintRet = await dexWallet.DexMintTokenAsync(dexbrk1.AccountID, 1000m);
* Assert.IsTrue(mintRet.Successful(), "Mint failed.");
* await Task.Delay(1000);
*
* var brk1lstret = await client.GetLastBlockAsync(dexbrk1.AccountID);
* Assert.IsTrue(brk1lstret.Successful());
* var brk1mint = brk1lstret.GetBlock() as TokenMintBlock;
* Assert.IsNotNull(brk1mint);
*
* if (networkId == "xunit")
* {
* Assert.AreEqual(2, brk1mint.Height, "No mint block generated.");
* Assert.AreEqual(1000, brk1mint.Balances["tether/TRX"].ToBalanceDecimal());
* }
*
* // get minted token to owner wallet
* await dexWallet.SyncAsync(null);
* var getokret = await dexWallet.DexGetTokenAsync(dexbrk1.AccountID, 500m);
* Assert.IsTrue(getokret.Successful(), "error get ext token to own wallet");
* await Task.Delay(1500);
* await dexWallet.SyncAsync(null);
* Assert.AreEqual(500m, dexWallet.GetLastSyncBlock().Balances["tether/TRX"].ToBalanceDecimal(), "Ext token amount error");
*
* // put external token to dex wallet
* var putokret = await dexWallet.DexPutTokenAsync(dexbrk1.AccountID, "tether/TRX", 500m);
* Assert.IsTrue(putokret.Successful(), "Put token error");
* await Task.Delay(1500);
* var brk1lstret2 = await client.GetLastBlockAsync(dexbrk1.AccountID);
* Assert.IsTrue(brk1lstret2.Successful());
* var brk1lastblk = brk1lstret2.GetBlock() as TransactionBlock;
* if (networkId == "xunit")
* {
* Assert.AreEqual(1000m, brk1lastblk.Balances["tether/TRX"].ToBalanceDecimal(), "brk1 ext tok balance error");
* }
*
* // withdraw token to external blockchain
* var wdwret = await dexWallet.DexWithdrawTokenAsync(dexbrk1.AccountID, "Txxxxxxxxx", 1000m);
* Assert.IsTrue(wdwret.Successful(), "Error withdraw");
* await Task.Delay(1500);
* var brk1lstret3 = await client.GetLastBlockAsync(dexbrk1.AccountID);
* Assert.IsTrue(brk1lstret3.Successful());
* var brk1lastblk3 = brk1lstret3.GetBlock() as TokenBurnBlock;
* if (networkId == "xunit")
* Assert.AreEqual(0m, brk1lastblk3.Balances["tether/TRX"].ToBalanceDecimal(), "brk1 ext tok burn error");
*
*/
}
