public ActionResult Build(
     [FromBody] BuildSingleReceiveTransactionRequest request)
 => StatusCode(StatusCodes.Status501NotImplemented);
 public IResponse <BuildSingleReceiveTransactionResponse> PostTranstactionSingleRecieve(BuildSingleReceiveTransactionRequest model)
 {
     return(Request.Post("/transactions/single/recieve").AddJsonBody(model).Build().Execute <BuildSingleReceiveTransactionResponse>());
 }
 public IActionResult ReceiveSingle([Required, FromBody] BuildSingleReceiveTransactionRequest request)
 {
     return(new StatusCodeResult(StatusCodes.Status501NotImplemented));
 }
Example #4
0
        protected void AddCryptoToWalletWithRecieveTransaction(string walletAddress, string walletKey, bool wait = true)
        {
            //build send transaction
            blockchainApi.Balances.PostBalances(walletAddress);
            var model = new BuildSingleTransactionRequest()
            {
                Amount             = AMOUT_WITH_FEE,
                AssetId            = ASSET_ID,
                FromAddress        = EXTERNAL_WALLET,
                IncludeFee         = false,
                OperationId        = Guid.NewGuid(),
                ToAddress          = walletAddress,
                FromAddressContext = EXTERNAL_WALLET_ADDRESS_CONTEXT
            };

            var    responseTransaction = blockchainApi.Operations.PostTransactions(model).GetResponseObject();
            string operationId         = model.OperationId.ToString();

            var signResponse = blockchainSign.PostSign(new SignRequest()
            {
                PrivateKeys = new List <string>()
                {
                    EXTERNAL_WALLET_KEY
                }, TransactionContext = responseTransaction.TransactionContext
            }).GetResponseObject();

            var response = blockchainApi.Operations.PostTransactionsBroadcast(new BroadcastTransactionRequest()
            {
                OperationId = model.OperationId, SignedTransaction = signResponse.SignedTransaction
            });

            // wait for wallet present in history

            var broadcastedSendTransaction = blockchainApi.Operations.GetOperationId(operationId).GetResponseObject();

            int i = 0;

            while (i++ < 150 && broadcastedSendTransaction.State == BroadcastedTransactionState.InProgress)
            {
                System.Threading.Thread.Sleep(TimeSpan.FromSeconds(2));
                broadcastedSendTransaction = blockchainApi.Operations.GetOperationId(operationId).GetResponseObject();
            }

            Assert.That(broadcastedSendTransaction.State, Is.EqualTo(BroadcastedTransactionState.Completed));

            //BuildSingleReceiveTransactionRequest recieve transaction

            var reciveModel = new BuildSingleReceiveTransactionRequest()
            {
                operationId = Guid.NewGuid(), sendTransactionHash = broadcastedSendTransaction.Hash
            };
            var recieve            = blockchainApi.Operations.PostTranstactionSingleRecieve(reciveModel).GetResponseObject();
            var signReciveResponse = blockchainSign.PostSign(new SignRequest()
            {
                PrivateKeys = new List <string>()
                {
                    walletKey
                }, TransactionContext = recieve.transactionContext
            }).GetResponseObject();

            var responseRecieve = blockchainApi.Operations.PostTransactionsBroadcast(new BroadcastTransactionRequest()
            {
                OperationId = reciveModel.operationId, SignedTransaction = signReciveResponse.SignedTransaction
            });

            if (wait)
            {
                WaitForBalance(walletAddress);
            }
        }
Example #5
0
        protected static void AddCryptoToWalletWithRecieveTransaction(string walletAddress, string walletKey)
        {
            var api  = new BlockchainApi(BlockchainApi);
            var sign = new BlockchainSign(_currentSettings.Value.BlockchainSign);

            //build send transaction
            api.Balances.PostBalances(walletAddress);
            var model = new BuildSingleTransactionRequest()
            {
                Amount             = AMOUT_WITH_FEE,
                AssetId            = ASSET_ID,
                FromAddress        = EXTERNAL_WALLET,
                IncludeFee         = false,
                OperationId        = Guid.NewGuid(),
                ToAddress          = walletAddress,
                FromAddressContext = EXTERNAL_WALLET_ADDRESS_CONTEXT
            };

            var    responseTransaction = api.Operations.PostTransactions(model).GetResponseObject();
            string operationId         = model.OperationId.ToString();

            var signResponse = sign.PostSign(new SignRequest()
            {
                PrivateKeys = new List <string>()
                {
                    EXTERNAL_WALLET_KEY
                }, TransactionContext = responseTransaction.TransactionContext
            }).GetResponseObject();

            var response = api.Operations.PostTransactionsBroadcast(new BroadcastTransactionRequest()
            {
                OperationId = model.OperationId, SignedTransaction = signResponse.SignedTransaction
            });

            // wait for wallet present in history

            var history = api.Operations.GetTransactionHistorToAddress(walletAddress, "500").GetResponseObject();

            int i = 0;

            while (i++ < 150 && api.Operations.GetTransactionHistorToAddress(walletAddress, "500").GetResponseObject().Length == 0)
            {
                System.Threading.Thread.Sleep(TimeSpan.FromSeconds(2));
            }

            history = api.Operations.GetTransactionHistorToAddress(walletAddress, "500").GetResponseObject();
            //BuildSingleReceiveTransactionRequest recieve transaction

            var reciveModel = new BuildSingleReceiveTransactionRequest()
            {
                operationId = Guid.NewGuid(), sendTransactionHash = history.ToList().First().hash
            };
            var recieve            = api.Operations.PostTranstactionSingleRecieve(reciveModel).GetResponseObject();
            var signReciveResponse = sign.PostSign(new SignRequest()
            {
                PrivateKeys = new List <string>()
                {
                    walletKey
                }, TransactionContext = recieve.transactionContext
            }).GetResponseObject();

            var responseRecieve = api.Operations.PostTransactionsBroadcast(new BroadcastTransactionRequest()
            {
                OperationId = reciveModel.operationId, SignedTransaction = signReciveResponse.SignedTransaction
            });

            WaitForBalance(walletAddress);
        }