public async Task <ValidateAccountResult> ValidateAccountAsync(RaiAddress acc) { var action = new ValidateAccount(acc); var handler = new ActionHandler <ValidateAccount, ValidateAccountResult>(_node); return(await handler.Handle(action)); }
/// <summary> /// Get account number for the public key /// </summary>> public async Task <GetAccountByPublicKeyResult> GetAccountByPublicKeyAsync(string key) { var action = new GetAccountByPublicKey(key); var handler = new ActionHandler <GetAccountByPublicKey, GetAccountByPublicKeyResult>(_node); return(await handler.Handle(action)); }
/// <summary> /// Returns how many RAW is owned and how many have not yet been received by account. /// </summary> /// <param name="acc">The account to get balance for.</param> /// <returns>Balance of <paramref name="acc"/> in RAW.</returns> public async Task <BalanceResult> GetBalanceAsync(RaiAddress acc) { var action = new GetBalance(acc); var handler = new ActionHandler <GetBalance, BalanceResult>(_node); return(await handler.Handle(action)); }
/// <summary> /// enable_control required /// Send amount from source in wallet to destination /// </summary> /// <param name="wallet">Wallet</param> /// <param name="source">Source</param>create /// <param name="destination">Destination</param> /// <param name="amount">Amount in RAW.</param> /// <returns></returns> public async Task <SendResult> SendAsync(string wallet, RaiAddress source, RaiAddress destination, RaiUnits.RaiRaw amount) { var action = new Send(wallet, source, destination, amount); var handler = new ActionHandler <Send, SendResult>(_node); return(await handler.Handle(action)); }
public async Task <BalancesResult> GetBalancesAsync(IEnumerable <RaiAddress> acc) { var action = new GetBalances(acc); var handler = new ActionHandler <GetBalances, BalancesResult>(_node); return(await handler.Handle(action)); }
/// <summary> /// Get number of blocks for a specific account /// </summary> /// <param name="acc">The account to get block count for.</param> /// <returns>Number of blocks on account.</returns> public async Task <AccountBlockCountResult> GetAccountBlockCountAsync(RaiAddress acc) { var action = new GetAccountBlockCount(acc); var handler = new ActionHandler <GetAccountBlockCount, AccountBlockCountResult>(_node); return(await handler.Handle(action)); }
/// <summary> /// Reports send/receive information for a account /// </summary>> public async Task <AccountHistoryResult> GetAccountHistoryAsync(RaiAddress acc, int count = 1) { var action = new GetAccountHistory(acc, count); var handler = new ActionHandler <GetAccountHistory, AccountHistoryResult>(_node); return(await handler.Handle(action)); }
/// <summary> /// Returns frontier, open block, change representative block, balance, last modified timestamp from local database & block count for account /// </summary> public async Task <AccountInformationResult> GetAccountInformationAsync(RaiAddress acc, bool representative = false, bool weight = false, bool pending = false) { var action = new GetAccountInformation(acc, representative, weight, pending); var handler = new ActionHandler <GetAccountInformation, AccountInformationResult>(_node); return(await handler.Handle(action)); }
/// <summary> /// Returns frontier, open block, change representative block, balance, last modified timestamp from local database & block count for account /// </summary> public async Task <AccountInformationResult> GetAccountInformationAsync(RaiAddress acc) { var action = new GetAccountInformation(acc); var handler = new ActionHandler <GetAccountInformation, AccountInformationResult>(_node); return(await handler.Handle(action)); }
/// <summary> /// enable_control required // Creates a new account, insert next deterministic key in wallet public async Task <CreateAccountResult> CreateAccountAsync(string wallet) { var action = new CreateAccount(wallet); var handler = new ActionHandler <CreateAccount, CreateAccountResult>(_node); return(await handler.Handle(action)); }
public async Task <WorkGenerateResult> GetWorkAsync(string hash) { var action = new WorkGenerate(hash); var handler = new ActionHandler <WorkGenerate, WorkGenerateResult>(_node); return(await handler.Handle(action)); }
public async Task <ProcessBlockResult> ProcessBlockAsync(string block) { var action = new ProcessBlock(block); var handler = new ActionHandler <ProcessBlock, ProcessBlockResult>(_node); return(await handler.Handle(action)); }
private async Task <TResult> Handle <TAction, TResult>(IAction <TResult> action) where TAction : class, IAction <TResult> where TResult : class, IActionResult { var handler = new ActionHandler <TAction, TResult>(_node); return(await handler.Handle(action)); }
public async Task <BlockAccountResult> GetBlockAccountAsync(string hash) { var action = new BlockAccount { Hash = hash }; var handler = new ActionHandler <BlockAccount, BlockAccountResult>(_node); return(await handler.Handle(action)); }
/// <summary> /// Return block by hash. /// </summary> /// <param name="hash">Block hash.</param> /// <returns>Block info.</returns> public async Task <RetrieveBlockResult> GetRetrieveBlockAsync(string hash) { var action = new Actions.RetrieveBlock { Hash = hash }; var handler = new ActionHandler <Actions.RetrieveBlock, RetrieveBlockResult>(_node); return(await handler.Handle(action)); }
/// <summary> /// Get account key /// </summary> /// <param name="account">Account</param> /// <returns>Ket <see cref="AccountKeyResult"/></returns> public async Task <AccountKeyResult> GetAccountKeyAsync(RaiAddress account) { var action = new AccountKey { AccountNumber = account, }; var handler = new ActionHandler <AccountKey, AccountKeyResult>(_node); return(await handler.Handle(action)); }
/// <summary> /// Returns a consecutive list of block hashes in the account chain starting at block up to count. /// Will list all blocks back to the open block of this chain when count is set to "-1". /// The requested block hash is included in the answer. /// </summary> /// <param name="block">Block hash</param> /// <param name="count">Block count</param> /// <returns>Chain <see cref="GetChainResult"/></returns> public async Task <GetChainResult> GetChainAsync(string block, long count = -1) { var action = new GetChain { Block = block, Count = count }; var handler = new ActionHandler <GetChain, GetChainResult>(_node); return(await handler.Handle(action)); }
/// <summary> /// Returns a list of block hashes which have not yet been received by these accounts /// </summary> /// <param name="accounts">List of accounts</param> /// <param name="count">Count</param> /// <param name="source">Is need return a list of pending block hashes with amount and source accounts</param> /// <returns>List of block hashes which have not yet been received by these accounts <see cref="AccountsPendingResult"/></returns> public async Task <AccountsPendingResult> GetAccountsPendingAsync(List <string> accounts, long count = -1, bool source = true) { var action = new AccountsPending { Accounts = accounts, Source = source, Count = count, }; var handler = new ActionHandler <AccountsPending, AccountsPendingResult>(_node); return(await handler.Handle(action)); }
/// <summary> /// Get blocks info /// </summary> /// <param name="hashes">Blocks hashes.</param> /// <param name="pending">Include panding info</param> /// <param name="source">Include source info</param> /// <param name="balance">Include balance info</param> /// <returns>Block info.</returns> public async Task <RetrieveBlocksInfoResult> GetRetrieveBlocksInfoAsync(List <string> hashes, bool pending = false, bool source = false, bool balance = false) { var action = new RetrieveBlocksInfo { Hashes = hashes, Balance = balance, Pending = pending, Source = source }; var handler = new ActionHandler <RetrieveBlocksInfo, RetrieveBlocksInfoResult>(_node); return(await handler.Handle(action)); }
public async Task <BlockCreateResult> BlockCreateSendAsync(string wallet, RaiAddress account, RaiAddress destination, RaiUnits.RaiRaw balance, RaiUnits.RaiRaw amount, string previous) { var action = new BlockCreate { Type = BlockType.send, Wallet = wallet, AccountNumber = account, Destination = destination, Balance = balance, Amount = amount, Previous = previous }; var handler = new ActionHandler <BlockCreate, BlockCreateResult>(_node); return(await handler.Handle(action)); }