예제 #1
0
        public async Task <Transaction> GetOrBuildTransferTransaction(Guid operationId,
                                                                      BitcoinAddress fromAddress,
                                                                      BitcoinAddress toAddress,
                                                                      string assetId,
                                                                      Money amountToSend,
                                                                      bool includeFee)
        {
            if (await _operationMetaRepository.Exist(operationId))
            {
                var alreadyBuildedTransaction = await _transactionBlobStorage.GetTransaction(operationId, TransactionBlobType.Initial);

                return(Transaction.Parse(alreadyBuildedTransaction));
            }

            var buildedTransaction = await _transactionBuilder.GetTransferTransaction(fromAddress, toAddress, amountToSend, includeFee);

            await _transactionBlobStorage.AddOrReplaceTransaction(operationId, TransactionBlobType.Initial,
                                                                  buildedTransaction.TransactionData.ToHex());

            var operation = OperationMeta.Create(operationId, fromAddress.ToString(), toAddress.ToString(), assetId,
                                                 buildedTransaction.Amount.Satoshi, buildedTransaction.Fee.Satoshi, includeFee);
            await _operationMetaRepository.Insert(operation);

            return(buildedTransaction.TransactionData);
        }
예제 #2
0
        public async Task <string> GetOrBuildTransferTransaction(Guid operationId,
                                                                 BitcoinAddress fromAddress,
                                                                 PubKey fromAddressPubkey,
                                                                 BitcoinAddress toAddress,
                                                                 string assetId,
                                                                 Money amountToSend,
                                                                 bool includeFee)
        {
            if (await _operationMetaRepository.Exist(operationId))
            {
                return(await _transactionBlobStorage.GetTransaction(operationId, TransactionBlobType.Initial));
            }

            var buildedTransaction = await _transactionBuilder.GetTransferTransaction(fromAddress, fromAddressPubkey, toAddress, amountToSend, includeFee);

            var transactionContext =
                Serializer.ToString((tx: buildedTransaction.TransactionData, spentCoins: buildedTransaction.SpentCoins));

            await _transactionBlobStorage.AddOrReplaceTransaction(operationId,
                                                                  TransactionBlobType.Initial,
                                                                  transactionContext);

            var operation = OperationMeta.Create(operationId, fromAddress.ToString(), toAddress.ToString(), assetId,
                                                 buildedTransaction.Amount.Satoshi, buildedTransaction.Fee.Satoshi, includeFee);
            await _operationMetaRepository.Insert(operation);

            return(transactionContext);
        }
예제 #3
0
        public async Task <BuiltTransactionInfo> GetOrBuildTransferTransaction(Guid operationId,
                                                                               BitcoinAddress fromAddress,
                                                                               PubKey fromAddressPubkey,
                                                                               BitcoinAddress toAddress,
                                                                               string assetId,
                                                                               Money amountToSend,
                                                                               bool includeFee)
        {
            var existingOperation = await _operationMetaRepository.Get(operationId);

            if (existingOperation != null)
            {
                var existingAmount = existingOperation.IncludeFee
                    ? existingOperation.AmountSatoshi + existingOperation.FeeSatoshi
                    : existingOperation.AmountSatoshi;

                if (existingOperation.FromAddress != fromAddress.ToString() ||
                    existingOperation.ToAddress != toAddress.ToString() ||
                    existingOperation.AssetId != assetId ||
                    existingOperation.IncludeFee != includeFee ||
                    existingAmount != amountToSend.Satoshi)
                {
                    throw new BusinessException("Conflict in operation parameters", ErrorCode.Conflict);
                }

                return(await GetExistingTransaction(existingOperation.OperationId, existingOperation.Hash));
            }

            var builtTransaction = await _transactionBuilder.GetTransferTransaction(fromAddress, fromAddressPubkey, toAddress, amountToSend, includeFee);

            var builtTransactionInfo = new BuiltTransactionInfo
            {
                TransactionHex = builtTransaction.TransactionData.ToHex(),
                UsedCoins      = builtTransaction.UsedCoins
            };

            var txHash = builtTransaction.TransactionData.GetHash().ToString();

            await _transactionBlobStorage.AddOrReplaceTransaction(operationId, txHash, TransactionBlobType.Initial, builtTransactionInfo.ToJson(_network));

            var operation = OperationMeta.Create(operationId, txHash, fromAddress.ToString(), toAddress.ToString(), assetId,
                                                 builtTransaction.Amount.Satoshi, builtTransaction.Fee.Satoshi, includeFee);

            if (await _operationMetaRepository.TryInsert(operation))
            {
                return(builtTransactionInfo);
            }

            existingOperation = await _operationMetaRepository.Get(operationId);

            return(await GetExistingTransaction(operationId, existingOperation.Hash));
        }