/// <summary>
        /// get all unconfirmed transactions
        /// </summary>
        /// <param name="pageIndex"></param>
        /// <param name="limit"></param>
        /// <returns></returns>
        public async Task <object> GetUnconfirmTransactions(int pageIndex = 1, int limit = 100)
        {
            var tempTransactions = UnconfirmedTransactionCache.GetUnconfirmedTransactions(null, pageIndex, limit);
            var result           = tempTransactions.Project(t => t.ToTransactionPreviewModel());

            return(result);
        }
Beispiel #2
0
        public override async Task Start(string[] args)
        {
            await base.Start(args);

            Task.Run(() => ExecuteResultScanner.Start());
            UnconfirmedTransactionCache.RegisterBlockPersistEvent(this.NeoSystem);
        }
Beispiel #3
0
 /// <summary>
 /// broadcast transaction and cache
 /// </summary>
 /// <param name="tx"></param>
 /// <returns></returns>
 public static async Task Broadcast(this Transaction tx)
 {
     Program.Starter.NeoSystem.LocalNode.Tell(new LocalNode.Relay {
         Inventory = tx
     });
     var task = Task.Run(() => UnconfirmedTransactionCache.AddTransaction(tx));
 }
Beispiel #4
0
        /// <summary>
        /// get my wallet unconfirmed transactions
        /// </summary>
        /// <returns></returns>
        public async Task <object> GetMyUnconfirmedTransactions(int pageIndex = 1, int limit = 100)
        {
            if (CurrentWallet == null)
            {
                return(Error(ErrorCode.WalletNotOpen));
            }

            var addresses        = CurrentWallet.GetAccounts().Select(a => a.ScriptHash).ToList();
            var tempTransactions = UnconfirmedTransactionCache.GetUnconfirmedTransactions(addresses, pageIndex, limit);
            var result           = tempTransactions.Project(t => t.ToTransactionPreviewModel());

            return(result);
        }
Beispiel #5
0
        public async Task <object> GetUnconfirmedTransaction(UInt256 txId)
        {
            var transaction = Helpers.GetDefaultSnapshot().GetTransaction(txId);

            if (transaction == null)
            {
                return(Error(ErrorCode.TxIdNotFound));
            }

            var model  = new TransactionModel(transaction);
            var tempTx = UnconfirmedTransactionCache.GetUnconfirmedTransaction(txId);

            if (tempTx?.Transfers.NotEmpty() == true)
            {
                model.Transfers = tempTx.Transfers.Select(n => new TransferModel()
                {
                    From   = n.From,
                    To     = n.To,
                    Amount = new BigDecimal(n.Amount, n.Decimals).ToString(),
                    Symbol = n.Symbol,
                }).ToList();
            }
            return(model);
        }
 public async Task <object> RemoveUnconfirmTransaction(UInt256 txId)
 {
     UnconfirmedTransactionCache.RemoveUnconfirmedTransactions(txId);
     return(true);
 }
Beispiel #7
0
 public override void OnStart(string[] args)
 {
     base.OnStart(args);
     UnconfirmedTransactionCache.RegisterBlockPersistEvent(this.NeoSystem);
 }