C# Transaction.AddInput方法代码示例

		public void CanSignTransaction()
		{
			var key = new Key();
			var scriptPubKey = PayToPubkeyHashTemplate.Instance.GenerateScriptPubKey(key.PubKey);

			Transaction tx = new Transaction();
			tx.AddInput(new TxIn(new OutPoint(tx.GetHash(), 0))
			{
				ScriptSig = scriptPubKey
			});
			tx.AddInput(new TxIn(new OutPoint(tx.GetHash(), 1))
			{
				ScriptSig = scriptPubKey
			});
			tx.AddOutput(new TxOut("21", key.PubKey.Hash));
			var clone = tx.Clone();
			tx.Sign(key, false);
			AssertCorrectlySigned(tx, scriptPubKey);
			clone.Sign(key, true);
			AssertCorrectlySigned(clone, scriptPubKey.Hash.ScriptPubKey);
		}

 public static Transaction CreateFakeTx(NetworkParameters @params, ulong nanocoins, Address to)
 {
     var t = new Transaction(@params);
     var o1 = new TransactionOutput(@params, t, nanocoins, to);
     t.AddOutput(o1);
     // Make a previous tx simply to send us sufficient coins. This prev tx is not really valid but it doesn't
     // matter for our purposes.
     var prevTx = new Transaction(@params);
     var prevOut = new TransactionOutput(@params, prevTx, nanocoins, to);
     prevTx.AddOutput(prevOut);
     // Connect it.
     t.AddInput(prevOut);
     return t;
 }

 public Transaction EmitMoney(IDestination destination, Money amount, bool isCoinbase = true, bool indexBalance = false)
 {
     Transaction transaction = new Transaction();
     if (isCoinbase)
         transaction.AddInput(new TxIn()
         {
             ScriptSig = new Script(NoRandom ? new uint256(0).ToBytes() : RandomUtils.GetBytes(32)),
         });
     transaction.AddOutput(new TxOut()
     {
         ScriptPubKey = destination.ScriptPubKey,
         Value = amount
     });
     Add(transaction, indexBalance);
     return transaction;
 }

		private static Transaction CreateCreditingTransaction(Script scriptPubKey)
		{
			var creditingTransaction = new Transaction();
			creditingTransaction.AddInput(new TxIn()
			{
				ScriptSig = new Script(OpcodeType.OP_0, OpcodeType.OP_0)
			});
			creditingTransaction.AddOutput(Money.Zero, scriptPubKey);
			return creditingTransaction;
		}

		private static Transaction CreateSpendingTransaction(Script scriptSig, Transaction creditingTransaction)
		{
			var spendingTransaction = new Transaction();
			spendingTransaction.AddInput(new TxIn(new OutPoint(creditingTransaction, 0))
			{
				ScriptSig = scriptSig
			});
			spendingTransaction.AddOutput(new TxOut()
			{
				ScriptPubKey = new Script(),
				Value = Money.Zero
			});
			return spendingTransaction;
		}

		public void witnessHasPushSizeLimit()
		{
			Key bob = new Key();
			Transaction tx = new Transaction();
			tx.Outputs.Add(new TxOut(Money.Coins(1.0m), bob.PubKey.ScriptPubKey.WitHash));
			WitScriptCoin coin = new WitScriptCoin(tx.Outputs.AsCoins().First(), bob.PubKey.ScriptPubKey);

			Transaction spending = new Transaction();
			spending.AddInput(tx, 0);
			spending.Sign(bob, coin);
			ScriptError error;
			Assert.True(spending.Inputs.AsIndexedInputs().First().VerifyScript(coin, out error));
			spending.Inputs[0].WitScript = new WitScript(new[] { new byte[521] }.Concat(spending.Inputs[0].WitScript.Pushes).ToArray());
			Assert.False(spending.Inputs.AsIndexedInputs().First().VerifyScript(coin, out error));
			Assert.Equal(ScriptError.PushSize, error);
		}

 public void Transactions()
 {
     // This test covers a bug in which Transaction.getValueSentFromMe was calculating incorrectly.
     var tx = TestUtils.CreateFakeTx(_params, Utils.ToNanoCoins(1, 0), _myAddress);
     // Now add another output (ie, change) that goes to some other address.
     var someOtherGuy = new EcKey().ToAddress(_params);
     var output = new TransactionOutput(_params, tx, Utils.ToNanoCoins(0, 5), someOtherGuy);
     tx.AddOutput(output);
     // Note that tx is no longer valid: it spends more than it imports. However checking transactions balance
     // correctly isn't possible in SPV mode because value is a property of outputs not inputs. Without all
     // transactions you can't check they add up.
     _wallet.Receive(tx, null, BlockChain.NewBlockType.BestChain);
     // Now the other guy creates a transaction which spends that change.
     var tx2 = new Transaction(_params);
     tx2.AddInput(output);
     tx2.AddOutput(new TransactionOutput(_params, tx2, Utils.ToNanoCoins(0, 5), _myAddress));
     // tx2 doesn't send any coins from us, even though the output is in the wallet.
     Assert.AreEqual(Utils.ToNanoCoins(0, 0), tx2.GetValueSentFromMe(_wallet));
 }

 public void Bounce()
 {
     // This test covers bug 64 (False double spends). Check that if we create a spend and it's immediately sent
     // back to us, this isn't considered as a double spend.
     var coin1 = Utils.ToNanoCoins(1, 0);
     var coinHalf = Utils.ToNanoCoins(0, 50);
     // Start by giving us 1 coin.
     var inbound1 = TestUtils.CreateFakeTx(_params, coin1, _myAddress);
     _wallet.Receive(inbound1, null, BlockChain.NewBlockType.BestChain);
     // Send half to some other guy. Sending only half then waiting for a confirm is important to ensure the tx is
     // in the unspent pool, not pending or spent.
     Assert.AreEqual(1, _wallet.GetPoolSize(Wallet.Pool.Unspent));
     Assert.AreEqual(1, _wallet.GetPoolSize(Wallet.Pool.All));
     var someOtherGuy = new EcKey().ToAddress(_params);
     var outbound1 = _wallet.CreateSend(someOtherGuy, coinHalf);
     _wallet.ConfirmSend(outbound1);
     _wallet.Receive(outbound1, null, BlockChain.NewBlockType.BestChain);
     // That other guy gives us the coins right back.
     var inbound2 = new Transaction(_params);
     inbound2.AddOutput(new TransactionOutput(_params, inbound2, coinHalf, _myAddress));
     inbound2.AddInput(outbound1.Outputs[0]);
     _wallet.Receive(inbound2, null, BlockChain.NewBlockType.BestChain);
     Assert.AreEqual(coin1, _wallet.GetBalance());
 }

        //public boolean equals(Object other) {
        //    if (!(other instanceof NetworkParameters)) return false;
        //    NetworkParameters o = (NetworkParameters) other;
        //    return o.getId().equals(getId());
        //}
        public Block CreateGenesis(NetworkParameters n)
        {
            Block genesisBlock=new Block(n);
            Transaction transaction=new Transaction(n);
            transaction.AddInput(
                new TransactionInput(n,transaction,Hex.Decode(n.GenesisBlockInputScriptSig))
            );

            ByteArrayOutputStream scriptPubKeyBytes = new ByteArrayOutputStream();
            Script.writeBytes(scriptPubKeyBytes,Hex.Decode(n.GenesisOutputScriptPubKey));
            scriptPubKeyBytes.write(Script.OP_CHECKSIG);
            t.addOutput(new TransactionOutput(n,transaction,Coin.FromCoins(50).Nanocoins,scriptPubKeyBytes.toByteArray()));

            genesisBlock.addTransaction(transaction);
            return genesisBlock;
        }

        private void addOnlyInputToTransaction(Transaction t, TransactionOutPointWithValue prevOut, uint sequence)
        {
            TxIn input = new TxIn(prevOut.outpoint)
            {
                ScriptSig = new Script(Op.GetPushOp(0))
            };
            input.Sequence = sequence;
            t.AddInput(input);

            var hash = prevOut.scriptPubKey.SignatureHash(t, 0, SigHash.All);
            input.ScriptSig = new PayToPubkeyHashTemplate().GenerateScriptSig(new TransactionSignature(coinbaseOutKey.Sign(hash), SigHash.All),coinbaseOutKeyPubKey);
        }