Exemplo n.º 1
0
        public string GetRawTransaction(string transactionId)
        {
            // Try to find the trx in disk
            SyncRawTransaction rawtrx = TransactionGetByHash(transactionId);

            if (rawtrx != null)
            {
                return(Encoders.Hex.EncodeData(rawtrx.RawTransaction));
            }

            IBlockchainClient client = clientFactory.Create(syncConnection);

            Client.Types.DecodedRawTransaction res = client.GetRawTransactionAsync(transactionId, 0).Result;

            if (res.Hex != null)
            {
                return(res.Hex);
            }

            return(null);
        }
Exemplo n.º 2
0
        public SyncTransactionItems TransactionItemsGet(string transactionId)
        {
            NBitcoin.Transaction transaction;

            // Try to find the trx in disk
            SyncRawTransaction rawtrx = TransactionGetByHash(transactionId);

            if (rawtrx == null)
            {
                BitcoinClient client = CryptoClientFactory.Create(syncConnection.ServerDomain, syncConnection.RpcAccessPort, syncConnection.User, syncConnection.Password, syncConnection.Secure);

                Client.Types.DecodedRawTransaction res = client.GetRawTransactionAsync(transactionId, 0).Result;

                if (res.Hex == null)
                {
                    return(null);
                }

                transaction = syncConnection.Network.Consensus.ConsensusFactory.CreateTransaction(res.Hex);
                transaction.PrecomputeHash(false, true);
            }
            else
            {
                transaction = syncConnection.Network.Consensus.ConsensusFactory.CreateTransaction(rawtrx.RawTransaction);
                transaction.PrecomputeHash(false, true);
            }

            var ret = new SyncTransactionItems
            {
                RBF         = transaction.RBF,
                LockTime    = transaction.LockTime.ToString(),
                Version     = transaction.Version,
                IsCoinbase  = transaction.IsCoinBase,
                IsCoinstake = syncConnection.Network.Consensus.IsProofOfStake && transaction.IsCoinStake,
                Inputs      = transaction.Inputs.Select(v => new SyncTransactionItemInput
                {
                    PreviousTransactionHash = v.PrevOut.Hash.ToString(),
                    PreviousIndex           = (int)v.PrevOut.N,
                    WitScript    = v.WitScript.ToScript().ToHex(),
                    ScriptSig    = v.ScriptSig.ToHex(),
                    SequenceLock = v.Sequence.ToString(),
                }).ToList(),
                Outputs = transaction.Outputs.Select((output, index) => new SyncTransactionItemOutput
                {
                    Address      = ScriptToAddressParser.GetAddress(syncConnection.Network, output.ScriptPubKey)?.FirstOrDefault(),
                    Index        = index,
                    Value        = output.Value,
                    OutputType   = StandardScripts.GetTemplateFromScriptPubKey(output.ScriptPubKey)?.Type.ToString(),
                    ScriptPubKey = output.ScriptPubKey.ToHex()
                }).ToList()
            };


            // try to fetch spent outputs
            foreach (SyncTransactionItemOutput output in ret.Outputs)
            {
                output.SpentInTransaction = GetSpendingTransaction(transactionId, output.Index);
            }

            return(ret);
        }
Exemplo n.º 3
0
        public SyncTransactionItems TransactionItemsGet(string transactionId, Transaction transaction = null)
        {
            if (transaction == null)
            {
                // Try to find the trx in disk
                SyncRawTransaction rawtrx = TransactionGetByHash(transactionId);

                if (rawtrx == null)
                {
                    var client = clientFactory.Create(syncConnection);

                    Client.Types.DecodedRawTransaction res = client.GetRawTransactionAsync(transactionId, 0).Result;

                    if (res.Hex == null)
                    {
                        return(null);
                    }

                    transaction = syncConnection.Network.Consensus.ConsensusFactory.CreateTransaction(res.Hex);
                    transaction.PrecomputeHash(false, true);
                }
                else
                {
                    transaction = syncConnection.Network.Consensus.ConsensusFactory.CreateTransaction(rawtrx.RawTransaction);
                    transaction.PrecomputeHash(false, true);
                }
            }

            bool hasWitness         = transaction.HasWitness;
            int  witnessScaleFactor = syncConnection.Network.Consensus.Options?.WitnessScaleFactor ?? 4;

            int size        = NBitcoin.BitcoinSerializableExtensions.GetSerializedSize(transaction, syncConnection.Network.Consensus.ConsensusFactory);
            int virtualSize = hasWitness ? transaction.GetVirtualSize(witnessScaleFactor) : size;
            int weight      = virtualSize * witnessScaleFactor - (witnessScaleFactor - 1);

            var ret = new SyncTransactionItems
            {
                RBF         = transaction.RBF,
                LockTime    = transaction.LockTime.ToString(),
                Version     = transaction.Version,
                HasWitness  = hasWitness,
                Size        = size,
                VirtualSize = virtualSize,
                Weight      = weight,
                IsCoinbase  = transaction.IsCoinBase,
                IsCoinstake = syncConnection.Network.Consensus.IsProofOfStake && transaction.IsCoinStake,
                Inputs      = transaction.Inputs.Select(v => new SyncTransactionItemInput
                {
                    PreviousTransactionHash = v.PrevOut.Hash.ToString(),
                    PreviousIndex           = (int)v.PrevOut.N,
                    WitScript    = v.WitScript.ToScript().ToHex(),
                    ScriptSig    = v.ScriptSig.ToHex(),
                    InputAddress = scriptInterpeter.GetSignerAddress(syncConnection.Network, v.ScriptSig),
                    SequenceLock = v.Sequence.ToString(),
                }).ToList(),
                Outputs = transaction.Outputs.Select((output, index) => new SyncTransactionItemOutput
                {
                    Address      = scriptInterpeter.InterpretScript(syncConnection.Network, output.ScriptPubKey)?.Addresses?.FirstOrDefault(),
                    Index        = index,
                    Value        = output.Value,
                    OutputType   = scriptInterpeter.InterpretScript(syncConnection.Network, output.ScriptPubKey)?.ScriptType, // StandardScripts.GetTemplateFromScriptPubKey(output.ScriptPubKey)?.Type.ToString(),
                    ScriptPubKey = output.ScriptPubKey.ToHex()
                }).ToList()
            };

            foreach (SyncTransactionItemInput input in ret.Inputs)
            {
                OutputTable outputTable = GetTransactionOutput(input.PreviousTransactionHash, input.PreviousIndex);
                input.InputAddress = outputTable?.Address;
                input.InputAmount  = outputTable?.Value ?? 0;
            }

            // try to fetch spent outputs
            foreach (SyncTransactionItemOutput output in ret.Outputs)
            {
                output.SpentInTransaction = GetTransactionInput(transactionId, output.Index)?.TrxHash;
            }

            if (!ret.IsCoinbase && !ret.IsCoinstake)
            {
                // calcualte fee and feePk
                ret.Fee = ret.Inputs.Sum(s => s.InputAmount) - ret.Outputs.Sum(s => s.Value);
            }

            return(ret);
        }