private async Task <Wallet> GetExchangeAccountWallet(string privateKey)
{
// create wallet and update balance
var memStor = new AccountInMemoryStorage();
var fromWallet = new Wallet(memStor, _config.Lyra.NetworkId);
fromWallet.AccountName = "tmpAcct";
await fromWallet.RestoreAccountAsync("", privateKey);
fromWallet.OpenAccount("", fromWallet.AccountName);
APIResultCodes result = APIResultCodes.UnknownError;
for (int i = 0; i < 300; i++)
{
result = await fromWallet.Sync(null);
if (result == APIResultCodes.Success)
{
break;
}
}
Trace.Assert(result == APIResultCodes.Success);
return(fromWallet);
}
public async Task HandleFreeTokenSend(WebWalletSendMeFreeTokenAction action, IDispatcher dispatcher)
{
var store = new AccountInMemoryStorage();
var name = Guid.NewGuid().ToString();
Wallet.Create(store, name, "", config["network"], action.faucetPvk);
var faucetWallet = Wallet.Open(store, name, "");
await faucetWallet.Sync(client);
// random amount
var random = new Random();
var randAmount = random.Next(300, 3000);
var result = await faucetWallet.Send(randAmount, action.wallet.AccountId);
if (result.ResultCode == APIResultCodes.Success)
{
await action.wallet.Sync(client);
dispatcher.Dispatch(new WebWalletSendMeFreeTokenResultAction {
Success = true, FreeAmount = randAmount
});
}
else
{
dispatcher.Dispatch(new WebWalletSendMeFreeTokenResultAction {
Success = false
});
}
}
public void TestMethod_ExecuteSellOrder_Success()
{
var inmemory_storage = new AccountInMemoryStorage();
Wallet wallet = new Wallet(inmemory_storage, NETWORK_ID);
wallet.RestoreAccount("", MERCHANT_PRIVATE_KEY);
var node = new RPCClient("Test");
var res = wallet.Sync(node).Result;
var result = wallet.LookForNewTrade(DISCOUNT_TOKEN, REWARD_TOKEN).Result;
var trade = result.GetBlock();
var discount_token = new NonFungibleToken();
discount_token.TokenCode = trade.BuyTokenCode;
discount_token.Denomination = trade.BuyAmount;
discount_token.ExpirationDate = DateTime.Now + TimeSpan.FromDays(365);
discount_token.SerialNumber = discount_token.CalculateHash();
discount_token.RedemptionCode = "TEST";
discount_token.Sign(MERCHANT_PRIVATE_KEY);
//trade.Fee = trade.Fee * 2;
//trade.FeeType = AuthorizationFeeTypes.BothParties;
var execute = wallet.ExecuteSellOrder(trade, null, discount_token).Result;
Assert.AreEqual(APIResultCodes.Success, execute.ResultCode);
}
public async Task UT_TransitWallet_SetupAsync()
{
var memStor = new AccountInMemoryStorage();
Wallet.Create(memStor, "tmpAcct", "", TestConfig.networkId, PRIVATE_KEY_1);
var w1 = Wallet.Open(memStor, "tmpAcct", "");
var syncResult = await w1.SyncAsync(client);
Assert.AreEqual(APIResultCodes.Success, syncResult, $"Error Sycn: {syncResult}");
var balances = w1.GetLastSyncBlock().Balances;
Assert.IsTrue(balances[LyraGlobal.OFFICIALTICKERCODE].ToBalanceDecimal() > 50000m, "Insufficient funds: LYR");
// make sure we have 2 test token
var genResult = await client.GetTokenGenesisBlockAsync(ADDRESS_ID_1, testToken, await SignAPIAsync());
if (genResult.ResultCode == APIResultCodes.TokenGenesisBlockNotFound)
{
var secs = testToken.Split('/');
var result = await w1.CreateTokenAsync(secs[1], secs[0], "", 8, 50000000000, true, "", "", "", Lyra.Core.Blocks.ContractTypes.Cryptocurrency, null);
Assert.IsTrue(result.Successful(), "Failed to create token: " + result.ResultCode);
await w1.SyncAsync(client);
}
}
public SimpleWallet(string networkId, string privateKey)
{
var store = new AccountInMemoryStorage();
var name = Guid.NewGuid().ToString();
Wallet.Create(store, name, "", networkId, privateKey);
LyraWallet = Wallet.Open(store, name, "");
}
public void TestMethod_Account_2_Restore_Success()
{
var inmemory_storage = new AccountInMemoryStorage();
Wallet wallet = new Wallet(inmemory_storage, NETWORK_ID);
var result = wallet.RestoreAccount("", PRIVATE_KEY_2);
// Assert.IsFalse(result.Successful());
Assert.AreEqual(APIResultCodes.Success, result.ResultCode);
}
public async Task TestMethod_Customer_Restore_SuccessAsync()
{
var inmemory_storage = new AccountInMemoryStorage();
Wallet wallet = new Wallet(inmemory_storage, NETWORK_ID);
var result = await wallet.RestoreAccountAsync("", CUSTOMER_PRIVATE_KEY);
// Assert.IsFalse(result.Successful());
Assert.AreEqual(APIResultCodes.Success, result.ResultCode);
}
private async Task <Wallet> GetWalletAsync(string privateKey)
{
var walletStor = new AccountInMemoryStorage();
Wallet.Create(walletStor, "gensisi", "1234", networkId, privateKey);
var w = Wallet.Open(walletStor, "gensisi", "1234", client);
return(w);
}
public async Task TestMethod_Merchant_Sync_SuccessAsync()
{
var inmemory_storage = new AccountInMemoryStorage();
Wallet wallet = new Wallet(inmemory_storage, NETWORK_ID);
await wallet.RestoreAccountAsync("", MERCHANT_PRIVATE_KEY);
var node = new LyraRestClient("Test");
var result = wallet.Sync(node).Result;
Assert.AreEqual(APIResultCodes.Success, result);
}
public void TestMethod_Customer_Sync_Success()
{
var inmemory_storage = new AccountInMemoryStorage();
Wallet wallet = new Wallet(inmemory_storage, NETWORK_ID);
wallet.RestoreAccount("", CUSTOMER_PRIVATE_KEY);
var node = new RPCClient("Test");
var result = wallet.Sync(node).Result;
Assert.AreEqual(APIResultCodes.Success, result);
}
public async Task HandleCreation(WebWalletCreateAction action, IDispatcher dispatcher)
{
var store = new AccountInMemoryStorage();
var name = Guid.NewGuid().ToString();
Wallet.Create(store, name, "", config["network"]);
var wallet = Wallet.Open(store, name, "");
await wallet.Sync(client);
dispatcher.Dispatch(new WebWalletResultAction(wallet, true, UIStage.Main));
}
public async Task <ExchangeAccount> GetExchangeAccount(string accountID, bool refreshBalance = false)
{
var findResult = await _exchangeAccounts.FindAsync(a => a.AssociatedToAccountId == accountID);
var acct = await findResult.FirstOrDefaultAsync();
if (!refreshBalance)
{
return(acct);
}
if (acct != null)
{
// create wallet and update balance
var memStor = new AccountInMemoryStorage();
Wallet.Create(memStor, "tmpAcct", "", "", acct.PrivateKey);
var acctWallet = Wallet.Open(memStor, "tmpAcct", "");
//var acctWallet = new ExchangeAccountWallet(memStor, _config.Lyra.NetworkId);
//acctWallet.AccountName = "tmpAcct";
//acctWallet.RestoreAccount("", acct.PrivateKey);
//acctWallet.OpenAccount("", acctWallet.AccountName);
for (int i = 0; i < 300; i++)
{
var result = await acctWallet.Sync(null);
if (result == APIResultCodes.Success)
{
break;
}
}
{
var transb = acctWallet.GetLatestBlock();
if (transb != null)
{
if (acct.Balance == null)
{
acct.Balance = new Dictionary <string, decimal>();
}
else
{
acct.Balance.Clear();
}
foreach (var b in transb.Balances)
{
acct.Balance.Add(b.Key, b.Value.ToBalanceDecimal());
}
_exchangeAccounts.ReplaceOne(a => a.AssociatedToAccountId == accountID, acct);
}
}
}
return(acct);
}
public async Task HandleFreeToken(WebWalletFreeTokenAction action, IDispatcher dispatcher)
{
var store = new AccountInMemoryStorage();
var name = Guid.NewGuid().ToString();
Wallet.Create(store, name, "", config["network"], action.faucetPvk);
var wallet = Wallet.Open(store, name, "");
await wallet.Sync(client);
dispatcher.Dispatch(new WebWalletFreeTokenResultAction {
faucetBalance = (decimal)wallet.GetLatestBlock().Balances[LyraGlobal.OFFICIALTICKERCODE] / LyraGlobal.TOKENSTORAGERITO
});
}
public static Wallet Restore(string privateKey)
{
var memStor = new AccountInMemoryStorage();
try
{
Wallet.Create(memStor, "tmpAcct", "", TestConfig.networkId, privateKey);
return(Wallet.Open(memStor, "tmpAcct", ""));
}
catch (Exception)
{
return(null);
}
}
public void TestMethod_LookForNewTrade_NoTokensSpecified()
{
var inmemory_storage = new AccountInMemoryStorage();
Wallet wallet = new Wallet(inmemory_storage, NETWORK_ID);
wallet.RestoreAccount("", MERCHANT_PRIVATE_KEY);
var node = new RPCClient("Test");
var res = wallet.Sync(node).Result;
var result = wallet.LookForNewTrade(null, null).Result;
Assert.AreEqual(APIResultCodes.Success, result.ResultCode);
}
public void TestMethod_GetActiveTradeOrders_Success()
{
var inmemory_storage = new AccountInMemoryStorage();
Wallet wallet = new Wallet(inmemory_storage, NETWORK_ID);
wallet.RestoreAccount("", MERCHANT_PRIVATE_KEY);
var node = new RPCClient("Test");
var res = wallet.Sync(node).Result;
var result = wallet.GetActiveTradeOrders(null, null, Core.Blocks.TradeOrderListTypes.All).Result;
Assert.AreEqual(APIResultCodes.Success, result.ResultCode);
}
private async Task<Wallet> RefreshBalanceAsync(string masterKey)
{
// create wallet and update balance
var memStor = new AccountInMemoryStorage();
var acctWallet = new ExchangeAccountWallet(memStor, _network);
acctWallet.AccountName = "tmpAcct";
await acctWallet.RestoreAccountAsync("", masterKey);
acctWallet.OpenAccount("", acctWallet.AccountName);
Console.WriteLine("Sync wallet for " + acctWallet.AccountId);
var rpcClient = await LyraRestClient.CreateAsync(_network, "Windows", "Lyra Client Cli", "1.0a");
await acctWallet.Sync(rpcClient);
return acctWallet;
}
public void TestMethod_LookForNewTrade_BothTokensWrong()
{
var inmemory_storage = new AccountInMemoryStorage();
Wallet wallet = new Wallet(inmemory_storage, NETWORK_ID);
wallet.RestoreAccount("", MERCHANT_PRIVATE_KEY);
var node = new RPCClient("Test");
var res = wallet.Sync(node).Result;
var result = wallet.LookForNewTrade(REWARD_TOKEN, DISCOUNT_TOKEN).Result;
Assert.AreEqual(APIResultCodes.NoTradesFound, result.ResultCode);
}
private async Task <Wallet> RefreshBalanceAsync(string masterKey)
{
// create wallet and update balance
var store = new AccountInMemoryStorage();
var name = Guid.NewGuid().ToString();
Wallet.Create(store, name, "", Program.network_id, masterKey);
var wallet = Wallet.Open(store, name, "");
Console.WriteLine("Sync wallet for " + wallet.AccountId);
var rpcClient = LyraRestClient.Create(Program.network_id, "Windows", $"{LyraGlobal.PRODUCTNAME} Client Cli", "1.0a");
await wallet.SyncAsync(rpcClient);
return(wallet);
}
private static IAccountDatabase GetStorage(string path)
{
IAccountDatabase store;
if (path == null)
{
store = new AccountInMemoryStorage();
}
else
{
store = new SecuredWalletStore(path);
}
return(store);
}
public void TestMethod_Create_LYRA_Token()
{
var inmemory_storage = new AccountInMemoryStorage();
Wallet wallet = new Wallet(inmemory_storage, NETWORK_ID);
wallet.RestoreAccount("", PRIVATE_KEY_1);
var node = new RPCClient("TestAccount1");
var result = wallet.Sync(node).Result;
Assert.AreEqual(APIResultCodes.Success, result);
result = wallet.CreateGenesisForCoreToken();
Assert.AreEqual(APIResultCodes.Success, result);
}
public static Wallet GetWallet(string PrivateKey)
{
var inmemory_storage = new AccountInMemoryStorage();
Wallet wallet = new Wallet(inmemory_storage, NETWORK_ID);
wallet.RestoreAccount("", PrivateKey);
var node = new RPCClient(PrivateKey);
var result = wallet.Sync(node).Result;
if (result == APIResultCodes.Success)
{
return(wallet);
}
throw new Exception("Could not create wallet");
}
public void TestMethod_Create_CUSTOM_Token()
{
var inmemory_storage = new AccountInMemoryStorage();
Wallet wallet = new Wallet(inmemory_storage, NETWORK_ID);
wallet.RestoreAccount("", PRIVATE_KEY_1);
var node = new RPCClient("TestAccount1");
var result = wallet.Sync(node).Result;
Assert.AreEqual(APIResultCodes.Success, result);
result = wallet.CreateToken("USD", "UnitTest", "", 8, 1000000, true, "Slava", "", "", Core.Blocks.Transactions.ContractTypes.Custom, null).Result.ResultCode;
Assert.AreEqual(APIResultCodes.Success, result);
}
public Wallet Restore(string privateKey)
{
client = LyraRestClient.Create(networkId, "Windows", "UnitTest", "1.0");
var memStor = new AccountInMemoryStorage();
try
{
Wallet.Create(memStor, "tmpAcct", "", networkId, privateKey);
return(Wallet.Open(memStor, "tmpAcct", ""));
}
catch (Exception)
{
return(null);
}
}
public void TestMethod_Account_1_Sync_Success()
{
var inmemory_storage = new AccountInMemoryStorage();
Wallet wallet = new Wallet(inmemory_storage, NETWORK_ID);
wallet.RestoreAccount("", PRIVATE_KEY_1);
var node = new RPCClient("TestAccount1");
var result = wallet.Sync(node).Result;
Assert.AreEqual(APIResultCodes.Success, result);
var balances = wallet.GetDisplayBalances();
Assert.IsNotNull(balances);
Console.WriteLine(balances);
}
public static async Task <decimal> GetLyraBalanceAsync(string lyraNetwork, string accountPvk)
{
var store = new AccountInMemoryStorage();
var wallet = Wallet.Create(store, "default", "", lyraNetwork,
accountPvk);
var lyraClient = LyraRestClient.Create(lyraNetwork, Environment.OSVersion.ToString(),
"Nebula Swap", "1.0");
var syncResult = await wallet.Sync(lyraClient);
if (syncResult == APIResultCodes.Success)
{
var block = wallet.GetLatestBlock();
if (block.Balances?.ContainsKey("LYR") == true)
{
return(block.Balances["LYR"].ToBalanceDecimal());
}
}
return(0m);
}
public async Task HandleRestore(WebWalletRestoreAction action, IDispatcher dispatcher)
{
try
{
var store = new AccountInMemoryStorage();
var name = Guid.NewGuid().ToString();
Wallet.Create(store, name, "", config["network"], action.privateKey);
var wallet = Wallet.Open(store, name, "");
if (action.selfVote)
{
wallet.VoteFor = wallet.AccountId;
}
await wallet.Sync(client);
dispatcher.Dispatch(new WebWalletResultAction(wallet, true, UIStage.Main));
}
catch (Exception ex)
{
dispatcher.Dispatch(new WebWalletResultAction(null, false, UIStage.Entry));
}
}
public async Task HandleSwap(WebWalletBeginSwapTLYRAction action, IDispatcher dispatcher)
{
bool IsSuccess = false;
try
{
if (action.fromToken == "LYR" && action.toToken == "TLYR")
{
var syncResult = await action.wallet.Sync(null);
if (syncResult == APIResultCodes.Success)
{
var sendResult = await action.wallet.Send(action.fromAmount,
action.options.lyrPub, "LYR");
if (sendResult.ResultCode == APIResultCodes.Success)
{
logger.LogInformation($"TokenSwap: first stage is ok for {action.fromAddress}");
var(txHash, result) = await SwapUtils.SendEthContractTokenAsync(
action.options.ethUrl, action.options.ethContract, action.options.ethPub,
action.options.ethPvk,
action.toAddress, new BigInteger(action.toAmount * 100000000), // 10^8
action.gasPrice, action.gasLimit,
null);
logger.LogInformation($"TokenSwap: second stage for {action.fromAddress} eth tx hash is {txHash} IsSuccess: {result}");
if (!result)
{
throw new Exception("Eth sending failed.");
}
IsSuccess = true;
}
else
{
throw new Exception("Unable to send from your Lyra wallet.");
}
}
else
{
throw new Exception("Unable to sync Lyra Wallet.");
}
}
if (action.fromToken == "TLYR" && action.toToken == "LYR")
{
var(txHash, result) = await SwapUtils.SendEthContractTokenAsync(
action.options.ethUrl, action.options.ethContract, action.fromAddress,
null,
action.options.ethPub, new BigInteger(action.fromAmount * 100000000), // 10^8
action.gasPrice, action.gasLimit,
action.metamask);
logger.LogInformation($"TokenSwap: first stage for {action.fromAddress} eth tx hash {result} IsSuccess: {result}");
if (result) // test if success transfer
{
var store = new AccountInMemoryStorage();
var wallet = Wallet.Create(store, "default", "", config["network"],
action.options.lyrPvk);
var syncResult = await wallet.Sync(client);
if (syncResult == APIResultCodes.Success)
{
var sendResult = await wallet.Send(action.toAmount,
action.toAddress, "LYR");
if (sendResult.ResultCode == Lyra.Core.Blocks.APIResultCodes.Success)
{
IsSuccess = true;
}
else
{
throw new Exception("Unable to send from your wallet.");
}
}
else
{
throw new Exception("Unable to sync Lyra Wallet.");
}
}
else
{
throw new Exception("Eth sending failed.");
}
}
logger.LogInformation($"TokenSwap: Swapping {action.fromAmount} from {action.fromAddress} to {action.toAddress} is succeed.");
dispatcher.Dispatch(new WebWalletSwapTLYRResultAction {
Success = IsSuccess
});
}
catch (Exception ex)
{
logger.LogInformation($"TokenSwap: Swapping {action.fromAmount} from {action.fromAddress} to {action.toAddress} is failed. Error: {ex}");
dispatcher.Dispatch(new WebWalletSwapTLYRResultAction {
Success = false, errMessage = ex.ToString()
});
}
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
_waitOrder = new AutoResetEvent(false);
try
{
_log.LogInformation($"NodeService: ExecuteAsync Called.");
// something must be initialized first
new AuthorizersFactory().Init();
var walletStore = new LiteAccountDatabase();
var tmpWallet = new Wallet(walletStore, Neo.Settings.Default.LyraNode.Lyra.NetworkId);
string lyra_folder = BaseAccount.GetFullFolderName("Lyra-CLI-" + Neo.Settings.Default.LyraNode.Lyra.NetworkId);
string full_path = BaseAccount.GetFullPath(lyra_folder);
tmpWallet.OpenAccount(full_path, Neo.Settings.Default.LyraNode.Lyra.Wallet.Name);
if (ProtocolSettings.Default.StandbyValidators.Any(a => a == tmpWallet.AccountId))
{
// not update balance for seed nodes.
PosWallet = tmpWallet;
}
else
{
// create wallet and update balance
var memStor = new AccountInMemoryStorage();
var acctWallet = new ExchangeAccountWallet(memStor, Neo.Settings.Default.LyraNode.Lyra.NetworkId);
acctWallet.AccountName = "tmpAcct";
await acctWallet.RestoreAccountAsync("", tmpWallet.PrivateKey);
acctWallet.OpenAccount("", acctWallet.AccountName);
Console.WriteLine("Sync wallet for " + acctWallet.AccountId);
var rpcClient = await LyraRestClient.CreateAsync(Neo.Settings.Default.LyraNode.Lyra.NetworkId, Environment.OSVersion.Platform.ToString(), "Lyra Client Cli", "1.0a");
await acctWallet.Sync(rpcClient);
PosWallet = acctWallet;
}
var sys = new LyraSystem();
sys.Start();
if (_db == null)
{
//BsonSerializer.RegisterSerializer(typeof(decimal), new DecimalSerializer(BsonType.Decimal128));
//BsonSerializer.RegisterSerializer(typeof(decimal?), new NullableSerializer<decimal>(new DecimalSerializer(BsonType.Decimal128)));
client = new MongoClient(Neo.Settings.Default.LyraNode.Lyra.Database.DexDBConnect);
_db = client.GetDatabase("Dex");
var exchangeAccounts = _db.GetCollection <ExchangeAccount>("exchangeAccounts");
var queue = _db.GetCollection <ExchangeOrder>("queuedDexOrders");
var finished = _db.GetCollection <ExchangeOrder>("finishedDexOrders");
// TODO: make it DI
Dealer = new DealEngine(exchangeAccounts, queue, finished);
Dealer.OnNewOrder += (s, a) => _waitOrder.Set();
}
//_watcher = new ZooKeeperWatcher(_log);
//await UsingZookeeper(_zkClusterOptions.ConnectionString, async (zk) => {
// // get Lyra network configurations from /lyra
// // {"mode":"permissioned","seeds":["node1","node2"]}
// var cfg = await zk.getDataAsync("/lyra");
// var runtimeConfig = JsonConvert.DeserializeObject<ConsensusRuntimeConfig>(Encoding.ASCII.GetString(cfg.Data));
// // do copy because the object is global
// _consensus.Mode = runtimeConfig.Mode;
// _consensus.Seeds = runtimeConfig.Seeds;
// _consensus.CurrentSeed = runtimeConfig.CurrentSeed;
// _consensus.PrimaryAuthorizerNodes = runtimeConfig.PrimaryAuthorizerNodes;
// _consensus.BackupAuthorizerNodes = runtimeConfig.BackupAuthorizerNodes;
// _consensus.VotingNodes = runtimeConfig.VotingNodes;
// _log.LogInformation($"NodeService: Got runtimeconfig success.");
//});
// all seeds do node election
//if (_consensus.Seeds.Contains(Neo.Settings.Default.LyraNode.Orleans.EndPoint.AdvertisedIPAddress))
//{
//while(true) // we do nothing without zk
//{
// try
// {
// var electRoot = "/lyra/seedelect";
// var zk = new ZooKeeper(_zkClusterOptions.ConnectionString, ZOOKEEPER_CONNECTION_TIMEOUT, _watcher);
// var stat = await zk.existsAsync(electRoot);
// if (stat == null)
// await zk.createAsync(electRoot, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
// _leader = new LeaderElectionSupport(zk, electRoot, Neo.Settings.Default.LyraNode.Orleans.EndPoint.AdvertisedIPAddress);
// _leader.addListener(this);
// await _leader.start();
// break;
// }
// catch(Exception ex)
// {
// _log.Fail(Orleans.ErrorCode.MembershipShutDownFailure, ex.Message);
// await Task.Delay(1000);
// }
//}
//}
}
catch (Exception ex)
{
throw new Exception("Error Initialize Node Service", ex);
}
while (!stoppingToken.IsCancellationRequested)
{
// do work
if (_waitOrder.WaitOne(1000))
{
_waitOrder.Reset();
await Dealer.MakeDealAsync();
}
else
{
// no new order. do house keeping.
}
}
}
public async Task GenesisAsync()
{
// genesis
_log.LogInformation("all seed nodes are ready. do genesis.");
var svcGen = await CreateServiceGenesisBlockAsync();
await SendBlockToConsensusAndWaitResultAsync(svcGen, ProtocolSettings.Default.StandbyValidators.ToList());
await Task.Delay(5000);
var tokenGen = CreateLyraTokenGenesisBlock(svcGen);
// DEBUG
//_log.LogInformation("genesis block string:\n" + tokenGen.GetHashInput());
await SendBlockToConsensusAndWaitResultAsync(tokenGen);
await Task.Delay(2000);
var pf = await CreatePoolFactoryBlockAsync();
await SendBlockToConsensusAndWaitResultAsync(pf);
await Task.Delay(25000); // because cons block has a time shift.
var consGen = CreateConsolidationGenesisBlock(svcGen, tokenGen, pf);
await SendBlockToConsensusAndWaitResultAsync(consGen);
await Task.Delay(1000);
_log.LogInformation("Genesis is done.");
await Task.Delay(30000);
// distribute staking coin to pre-defined authorizers
var memStore = new AccountInMemoryStorage();
Wallet.Create(memStore, "tmp", "", Settings.Default.LyraNode.Lyra.NetworkId, _sys.PosWallet.PrivateKey);
var gensWallet = Wallet.Open(memStore, "tmp", "");
gensWallet.SetVoteFor(_sys.PosWallet.AccountId);
foreach (var accId in ProtocolSettings.Default.StandbyValidators.Skip(1).Concat(ProtocolSettings.Default.StartupValidators))
{
var client = new LyraAggregatedClient(Settings.Default.LyraNode.Lyra.NetworkId, true, _sys.PosWallet.AccountId);
await client.InitAsync();
await gensWallet.SyncAsync(client);
var amount = LyraGlobal.MinimalAuthorizerBalance + 100000;
var sendResult = await gensWallet.SendAsync(amount, accId);
if (sendResult.ResultCode == APIResultCodes.Success)
{
_log.LogInformation($"Genesis send {amount} successfull to accountId: {accId}");
}
else
{
_log.LogError($"Genesis send {amount} failed to accountId: {accId}");
}
}
}
