public void ReadWrite(BitcoinStream stream)
{
stream.ReadWrite(ref nVersion);
stream.ReadWrite <TxInList, TxIn>(ref vin);
stream.ReadWrite <TxOutList, TxOut>(ref vout);
stream.ReadWriteStruct(ref nLockTime);
}
//https://en.bitcoin.it/wiki/OP_CHECKSIG
public static uint256 SignatureHash(Script scriptCode, Transaction txTo, int nIn, SigHash nHashType, Money amount, HashVersion sigversion, PrecomputedTransactionData precomputedTransactionData)
{
if (sigversion == HashVersion.Witness)
{
if (amount == null)
{
throw new ArgumentException("The amount of the output being signed must be provided", "amount");
}
uint256 hashPrevouts = uint256.Zero;
uint256 hashSequence = uint256.Zero;
uint256 hashOutputs = uint256.Zero;
if ((nHashType & SigHash.AnyoneCanPay) == 0)
{
hashPrevouts = precomputedTransactionData == null?
GetHashPrevouts(txTo) : precomputedTransactionData.HashPrevouts;
}
if ((nHashType & SigHash.AnyoneCanPay) == 0 && ((uint)nHashType & 0x1f) != (uint)SigHash.Single && ((uint)nHashType & 0x1f) != (uint)SigHash.None)
{
hashSequence = precomputedTransactionData == null?
GetHashSequence(txTo) : precomputedTransactionData.HashSequence;
}
if (((uint)nHashType & 0x1f) != (uint)SigHash.Single && ((uint)nHashType & 0x1f) != (uint)SigHash.None)
{
hashOutputs = precomputedTransactionData == null?
GetHashOutputs(txTo) : precomputedTransactionData.HashOutputs;
}
else if (((uint)nHashType & 0x1f) == (uint)SigHash.Single && nIn < txTo.Outputs.Count)
{
BitcoinStream ss = CreateHashWriter(sigversion);
ss.ReadWrite(txTo.Outputs[nIn]);
hashOutputs = GetHash(ss);
}
BitcoinStream sss = CreateHashWriter(sigversion);
// Version
sss.ReadWrite(txTo.Version);
// Input prevouts/nSequence (none/all, depending on flags)
sss.ReadWrite(hashPrevouts);
sss.ReadWrite(hashSequence);
// The input being signed (replacing the scriptSig with scriptCode + amount)
// The prevout may already be contained in hashPrevout, and the nSequence
// may already be contain in hashSequence.
sss.ReadWrite(txTo.Inputs[nIn].PrevOut);
sss.ReadWrite(scriptCode);
sss.ReadWrite(amount.Satoshi);
sss.ReadWrite((uint)txTo.Inputs[nIn].Sequence);
// Outputs (none/one/all, depending on flags)
sss.ReadWrite(hashOutputs);
// Locktime
sss.ReadWriteStruct(txTo.LockTime);
// Sighash type
sss.ReadWrite((uint)nHashType);
return(GetHash(sss));
}
if (nIn >= txTo.Inputs.Count)
{
Utils.log("ERROR: SignatureHash() : nIn=" + nIn + " out of range\n");
return(uint256.One);
}
// Check for invalid use of SIGHASH_SINGLE
if (nHashType == SigHash.Single)
{
if (nIn >= txTo.Outputs.Count)
{
Utils.log("ERROR: SignatureHash() : nOut=" + nIn + " out of range\n");
return(uint256.One);
}
}
var scriptCopy = new Script(scriptCode._Script);
scriptCopy.FindAndDelete(OpcodeType.OP_CODESEPARATOR);
var txCopy = new Transaction(txTo.ToBytes());
//Set all TxIn script to empty string
foreach (var txin in txCopy.Inputs)
{
txin.ScriptSig = new Script();
}
//Copy subscript into the txin script you are checking
txCopy.Inputs[nIn].ScriptSig = scriptCopy;
var hashType = nHashType & (SigHash)31;
if (hashType == SigHash.None)
{
//The output of txCopy is set to a vector of zero size.
txCopy.Outputs.Clear();
//All other inputs aside from the current input in txCopy have their nSequence index set to zero
foreach (var input in txCopy.Inputs.Where((x, i) => i != nIn))
{
input.Sequence = 0;
}
}
else if (hashType == SigHash.Single)
{
//The output of txCopy is resized to the size of the current input index+1.
txCopy.Outputs.RemoveRange(nIn + 1, txCopy.Outputs.Count - (nIn + 1));
//All other txCopy outputs aside from the output that is the same as the current input index are set to a blank script and a value of (long) -1.
for (var i = 0; i < txCopy.Outputs.Count; i++)
{
if (i == nIn)
{
continue;
}
txCopy.Outputs[i] = new TxOut();
}
//All other txCopy inputs aside from the current input are set to have an nSequence index of zero.
foreach (var input in txCopy.Inputs.Where((x, i) => i != nIn))
{
input.Sequence = 0;
}
}
if ((nHashType & SigHash.AnyoneCanPay) != 0)
{
//The txCopy input vector is resized to a length of one.
var script = txCopy.Inputs[nIn];
txCopy.Inputs.Clear();
txCopy.Inputs.Add(script);
//The subScript (lead in by its length as a var-integer encoded!) is set as the first and only member of this vector.
txCopy.Inputs[0].ScriptSig = scriptCopy;
}
//Serialize TxCopy, append 4 byte hashtypecode
var stream = CreateHashWriter(sigversion);
txCopy.ReadWrite(stream);
stream.ReadWrite((uint)nHashType);
return(GetHash(stream));
}
public virtual void ReadWrite(BitcoinStream stream)
{
var witSupported = (((uint)stream.TransactionOptions & (uint)TransactionOptions.Witness) != 0) &&
stream.ProtocolVersion >= ProtocolVersion.WITNESS_VERSION;
byte flags = 0;
if (!stream.Serializing)
{
stream.ReadWrite(ref nVersion);
/* Try to read the vin. In case the dummy is there, this will be read as an empty vector. */
stream.ReadWrite <TxInList, TxIn>(ref vin);
var hasNoDummy = (nVersion & NoDummyInput) != 0 && vin.Count == 0;
if (hasNoDummy)
{
nVersion = nVersion & ~NoDummyInput;
}
if (vin.Count == 0 && witSupported && !hasNoDummy)
{
/* We read a dummy or an empty vin. */
stream.ReadWrite(ref flags);
if (flags != 0)
{
/* Assume we read a dummy and a flag. */
stream.ReadWrite <TxInList, TxIn>(ref vin);
vin.Transaction = this;
stream.ReadWrite <TxOutList, TxOut>(ref vout);
vout.Transaction = this;
}
}
else
{
/* We read a non-empty vin. Assume a normal vout follows. */
stream.ReadWrite <TxOutList, TxOut>(ref vout);
vout.Transaction = this;
}
wit.SetNull();
if (((flags & 1) != 0) && witSupported)
{
/* The witness flag is present, and we support witnesses. */
flags ^= 1;
//const_cast<CTxWitness*>(&tx.wit)->vtxinwit.resize(tx.vin.size());
wit.Size(vin.Count);
wit.ReadWrite(stream);
}
if (flags != 0)
{
/* Unknown flag in the serialization */
throw new FormatException("Unknown transaction optional data");
}
}
else
{
var version = vin.Count == 0 && vout.Count > 0 ? nVersion | NoDummyInput : nVersion;
stream.ReadWrite(ref version);
if (witSupported)
{
/* Check whether witnesses need to be serialized. */
if (!wit.IsNull())
{
flags |= 1;
}
}
if (flags != 0)
{
/* Use extended format in case witnesses are to be serialized. */
TxInList vinDummy = new TxInList();
stream.ReadWrite <TxInList, TxIn>(ref vinDummy);
stream.ReadWrite(ref flags);
}
stream.ReadWrite <TxInList, TxIn>(ref vin);
vin.Transaction = this;
stream.ReadWrite <TxOutList, TxOut>(ref vout);
vout.Transaction = this;
if ((flags & 1) != 0)
{
wit.Size(vin.Count);
wit.ReadWrite(stream);
}
}
stream.ReadWriteStruct(ref nLockTime);
}
public override void ReadWrite(BitcoinStream stream)
{
bool witSupported = (((uint)stream.TransactionOptions & (uint)TransactionOptions.Witness) != 0) &&
stream.ProtocolVersion >= ProtocolVersion.WITNESS_VERSION;
byte flags = 0;
if (!stream.Serializing)
{
stream.ReadWrite(ref this.nVersion);
// POS time stamp
stream.ReadWrite(ref this.nTime);
/* Try to read the vin. In case the dummy is there, this will be read as an empty vector. */
stream.ReadWrite <TxInList, TxIn>(ref this.vin);
bool hasNoDummy = (this.nVersion & NoDummyInput) != 0 && this.vin.Count == 0;
if (witSupported && hasNoDummy)
{
this.nVersion = this.nVersion & ~NoDummyInput;
}
if (this.vin.Count == 0 && witSupported && !hasNoDummy)
{
/* We read a dummy or an empty vin. */
stream.ReadWrite(ref flags);
if (flags != 0)
{
/* Assume we read a dummy and a flag. */
stream.ReadWrite <TxInList, TxIn>(ref this.vin);
this.vin.Transaction = this;
stream.ReadWrite <TxOutList, TxOut>(ref this.vout);
this.vout.Transaction = this;
}
else
{
/* Assume read a transaction without output. */
this.vout = new TxOutList();
this.vout.Transaction = this;
}
}
else
{
/* We read a non-empty vin. Assume a normal vout follows. */
stream.ReadWrite <TxOutList, TxOut>(ref this.vout);
this.vout.Transaction = this;
}
if (((flags & 1) != 0) && witSupported)
{
/* The witness flag is present, and we support witnesses. */
flags ^= 1;
var wit = new Witness(this.Inputs);
wit.ReadWrite(stream);
}
if (flags != 0)
{
/* Unknown flag in the serialization */
throw new FormatException("Unknown transaction optional data");
}
}
else
{
uint version = (witSupported && (this.vin.Count == 0 && this.vout.Count > 0)) ? this.nVersion | NoDummyInput : this.nVersion;
stream.ReadWrite(ref version);
// the POS time stamp
stream.ReadWrite(ref this.nTime);
if (witSupported)
{
/* Check whether witnesses need to be serialized. */
if (this.HasWitness)
{
flags |= 1;
}
}
if (flags != 0)
{
/* Use extended format in case witnesses are to be serialized. */
var vinDummy = new TxInList();
stream.ReadWrite <TxInList, TxIn>(ref vinDummy);
stream.ReadWrite(ref flags);
}
stream.ReadWrite <TxInList, TxIn>(ref this.vin);
this.vin.Transaction = this;
stream.ReadWrite <TxOutList, TxOut>(ref this.vout);
this.vout.Transaction = this;
if ((flags & 1) != 0)
{
var wit = new Witness(this.Inputs);
wit.ReadWrite(stream);
}
}
stream.ReadWriteStruct(ref this.nLockTime);
}