public byte[] SignCompact(uint256 hash)
{
var sig = this._ECKey.Sign(hash);
// Now we have to work backwards to figure out the recId needed to recover the signature.
var recId = -1;
for (var i = 0; i < 4; i++)
{
var k = ECKey.RecoverFromSignature(i, sig, hash, this.IsCompressed);
if (k != null && k.GetPubKey(this.IsCompressed).ToHex() == this.PubKey.ToHex())
{
recId = i;
break;
}
}
if (recId == -1)
{
throw new InvalidOperationException("Could not construct a recoverable key. This should never happen.");
}
var headerByte = recId + 27 + (this.IsCompressed ? 4 : 0);
var sigData = new byte[65]; // 1 header + 32 bytes for R + 32 bytes for S
sigData[0] = (byte)headerByte;
Array.Copy(Utils.BigIntegerToBytes(sig.R, 32), 0, sigData, 1, 32);
Array.Copy(Utils.BigIntegerToBytes(sig.S, 32), 0, sigData, 33, 32);
return(sigData);
}
public byte[] SignCompact(uint256 hash, bool forceLowR)
{
if (hash is null)
{
throw new ArgumentNullException(nameof(hash));
}
AssertNotDisposed();
#if HAS_SPAN
Span <byte> vchSig = stackalloc byte[65];
int rec = -1;
var sig = new Secp256k1.SecpRecoverableECDSASignature(_ECKey.Sign(hash, forceLowR, out rec), rec);
sig.WriteToSpanCompact(vchSig.Slice(1), out int recid);
vchSig[0] = (byte)(27 + rec + (IsCompressed ? 4 : 0));
return(vchSig.ToArray());
#else
var sig = _ECKey.Sign(hash, forceLowR);
// Now we have to work backwards to figure out the recId needed to recover the signature.
int recId = -1;
for (int i = 0; i < 4; i++)
{
ECKey k = ECKey.RecoverFromSignature(i, sig, hash, IsCompressed);
if (k != null && k.GetPubKey(IsCompressed).ToHex() == PubKey.ToHex())
{
recId = i;
break;
}
}
if (recId == -1)
{
throw new InvalidOperationException("Could not construct a recoverable key. This should never happen.");
}
int headerByte = recId + 27 + (IsCompressed ? 4 : 0);
byte[] sigData = new byte[65]; // 1 header + 32 bytes for R + 32 bytes for S
sigData[0] = (byte)headerByte;
#pragma warning disable 618
Array.Copy(Utils.BigIntegerToBytes(sig.R, 32), 0, sigData, 1, 32);
Array.Copy(Utils.BigIntegerToBytes(sig.S, 32), 0, sigData, 33, 32);
#pragma warning restore 618
return(sigData);
#endif
}
public CompactSignature SignCompact(uint256 hash, bool forceLowR)
{
if (hash is null)
{
throw new ArgumentNullException(nameof(hash));
}
if (!IsCompressed)
{
throw new InvalidOperationException("This operation is only supported on compressed pubkey");
}
AssertNotDisposed();
#if HAS_SPAN
byte[] sigBytes = new byte[64];
var sig = new Secp256k1.SecpRecoverableECDSASignature(_ECKey.Sign(hash, forceLowR, out var rec), rec);
sig.WriteToSpanCompact(sigBytes, out _);
return(new CompactSignature(rec, sigBytes));
#else
var sig = _ECKey.Sign(hash, forceLowR);
// Now we have to work backwards to figure out the recId needed to recover the signature.
int recId = -1;
for (int i = 0; i < 4; i++)
{
ECKey k = ECKey.RecoverFromSignature(i, sig, hash);
if (k != null && k.GetPubKey(true).ToHex() == PubKey.ToHex())
{
recId = i;
break;
}
}
if (recId == -1)
{
throw new InvalidOperationException("Could not construct a recoverable key. This should never happen.");
}
#pragma warning disable 618
byte[] sigData = new byte[64]; // 1 header + 32 bytes for R + 32 bytes for S
Array.Copy(Utils.BigIntegerToBytes(sig.R, 32), 0, sigData, 0, 32);
Array.Copy(Utils.BigIntegerToBytes(sig.S, 32), 0, sigData, 32, 32);
#pragma warning restore 618
return(new CompactSignature(recId, sigData));
#endif
}
public byte[] SignCompact(uint256 hash, bool forceLowR)
{
if (hash is null)
{
throw new ArgumentNullException(nameof(hash));
}
var sig = _ECKey.Sign(hash, forceLowR);
// Now we have to work backwards to figure out the recId needed to recover the signature.
int recId = -1;
for (int i = 0; i < 4; i++)
{
ECKey k = ECKey.RecoverFromSignature(i, sig, hash, IsCompressed);
if (k != null && k.GetPubKey(IsCompressed).ToHex() == PubKey.ToHex())
{
recId = i;
break;
}
}
if (recId == -1)
{
throw new InvalidOperationException("Could not construct a recoverable key. This should never happen.");
}
int headerByte = recId + 27 + (IsCompressed ? 4 : 0);
byte[] sigData = new byte[65]; // 1 header + 32 bytes for R + 32 bytes for S
sigData[0] = (byte)headerByte;
Array.Copy(Utils.BigIntegerToBytes(sig.R, 32), 0, sigData, 1, 32);
Array.Copy(Utils.BigIntegerToBytes(sig.S, 32), 0, sigData, 33, 32);
return(sigData);
}
public static Op GetPushOp(long value)
{
return(GetPushOp(Utils.BigIntegerToBytes(new BigInteger(value))));
}
internal static Op GetPushOp(BigInteger data)
#endif
{
return(GetPushOp(Utils.BigIntegerToBytes(data)));
}
public static Op GetPushOp(long value)
{
return(GetPushOp(Utils.BigIntegerToBytes(ooo.BigInteger.ValueOf(value))));
}
public static Script operator +(Script a, int value)
{
return(a + Utils.BigIntegerToBytes(value));
}
public static Op GetPushOp(long value)
{
return(GetPushOp(Utils.BigIntegerToBytes(BouncyCastle.Math.BigInteger.ValueOf(value))));
}
public bool EvalScript(Script s, Transaction txTo, int nIn)
{
var script = s.CreateReader();
int pend = (int)script.Inner.Length;
int pbegincodehash = 0;
Stack <bool> vfExec = new Stack <bool>();
Stack <byte[]> altstack = new Stack <byte[]>();
Op opcode = null;
if (s.Length > 10000)
{
return(false);
}
int nOpCount = 0;
try
{
while ((opcode = script.Read()) != null)
{
bool fExec = vfExec.All(o => o); //!count(vfExec.begin(), vfExec.end(), false);
//
// Read instruction
//
if (opcode.PushData != null && opcode.PushData.Length > 520)
{
return(false);
}
// Note how OP_RESERVED does not count towards the opcode limit.
if (opcode.Code > OpcodeType.OP_16 && ++nOpCount > 201)
{
return(false);
}
if (opcode.Code == OpcodeType.OP_CAT ||
opcode.Code == OpcodeType.OP_SUBSTR ||
opcode.Code == OpcodeType.OP_LEFT ||
opcode.Code == OpcodeType.OP_RIGHT ||
opcode.Code == OpcodeType.OP_INVERT ||
opcode.Code == OpcodeType.OP_AND ||
opcode.Code == OpcodeType.OP_OR ||
opcode.Code == OpcodeType.OP_XOR ||
opcode.Code == OpcodeType.OP_2MUL ||
opcode.Code == OpcodeType.OP_2DIV ||
opcode.Code == OpcodeType.OP_MUL ||
opcode.Code == OpcodeType.OP_DIV ||
opcode.Code == OpcodeType.OP_MOD ||
opcode.Code == OpcodeType.OP_LSHIFT ||
opcode.Code == OpcodeType.OP_RSHIFT)
{
return(false); // Disabled opcodes.
}
if (fExec && opcode.PushData != null)
{
_Stack.Push(opcode.PushData);
}
else if (fExec || (OpcodeType.OP_IF <= opcode.Code && opcode.Code <= OpcodeType.OP_ENDIF))
{
switch (opcode.Code)
{
//
// Push value
//
case OpcodeType.OP_1NEGATE:
case OpcodeType.OP_1:
case OpcodeType.OP_2:
case OpcodeType.OP_3:
case OpcodeType.OP_4:
case OpcodeType.OP_5:
case OpcodeType.OP_6:
case OpcodeType.OP_7:
case OpcodeType.OP_8:
case OpcodeType.OP_9:
case OpcodeType.OP_10:
case OpcodeType.OP_11:
case OpcodeType.OP_12:
case OpcodeType.OP_13:
case OpcodeType.OP_14:
case OpcodeType.OP_15:
case OpcodeType.OP_16:
{
// ( -- value)
BigInteger bn = new BigInteger((int)opcode.Code - (int)(OpcodeType.OP_1 - 1));
_Stack.Push(Utils.BigIntegerToBytes(bn));
}
break;
//
// Control
//
case OpcodeType.OP_NOP:
case OpcodeType.OP_NOP1:
case OpcodeType.OP_NOP2:
case OpcodeType.OP_NOP3:
case OpcodeType.OP_NOP4:
case OpcodeType.OP_NOP5:
case OpcodeType.OP_NOP6:
case OpcodeType.OP_NOP7:
case OpcodeType.OP_NOP8:
case OpcodeType.OP_NOP9:
case OpcodeType.OP_NOP10:
break;
case OpcodeType.OP_IF:
case OpcodeType.OP_NOTIF:
{
// <expression> if [statements] [else [statements]] endif
bool fValue = false;
if (fExec)
{
if (_Stack.Count < 1)
{
return(false);
}
var vch = top(_Stack, -1);
fValue = CastToBool(vch);
if (opcode.Code == OpcodeType.OP_NOTIF)
{
fValue = !fValue;
}
_Stack.Pop();
}
vfExec.Push(fValue);
}
break;
case OpcodeType.OP_ELSE:
{
if (vfExec.Count == 0)
{
return(false);
}
var v = vfExec.Pop();
vfExec.Push(!v);
//vfExec.Peek() = !vfExec.Peek();
}
break;
case OpcodeType.OP_ENDIF:
{
if (vfExec.Count == 0)
{
return(false);
}
vfExec.Pop();
}
break;
case OpcodeType.OP_VERIFY:
{
// (true -- ) or
// (false -- false) and return
if (_Stack.Count < 1)
{
return(false);
}
bool fValue = CastToBool(top(_Stack, -1));
if (fValue)
{
_Stack.Pop();
}
else
{
return(false);
}
}
break;
case OpcodeType.OP_RETURN:
{
return(false);
}
//
// Stack ops
//
case OpcodeType.OP_TOALTSTACK:
{
if (_Stack.Count < 1)
{
return(false);
}
altstack.Push(top(_Stack, -1));
_Stack.Pop();
}
break;
case OpcodeType.OP_FROMALTSTACK:
{
if (altstack.Count < 1)
{
return(false);
}
_Stack.Push(top(altstack, -1));
altstack.Pop();
}
break;
case OpcodeType.OP_2DROP:
{
// (x1 x2 -- )
if (_Stack.Count < 2)
{
return(false);
}
_Stack.Pop();
_Stack.Pop();
}
break;
case OpcodeType.OP_2DUP:
{
// (x1 x2 -- x1 x2 x1 x2)
if (_Stack.Count < 2)
{
return(false);
}
var vch1 = top(_Stack, -2);
var vch2 = top(_Stack, -1);
_Stack.Push(vch1);
_Stack.Push(vch2);
}
break;
case OpcodeType.OP_3DUP:
{
// (x1 x2 x3 -- x1 x2 x3 x1 x2 x3)
if (_Stack.Count < 3)
{
return(false);
}
var vch1 = top(_Stack, -3);
var vch2 = top(_Stack, -2);
var vch3 = top(_Stack, -1);
_Stack.Push(vch1);
_Stack.Push(vch2);
_Stack.Push(vch3);
}
break;
case OpcodeType.OP_2OVER:
{
// (x1 x2 x3 x4 -- x1 x2 x3 x4 x1 x2)
if (_Stack.Count < 4)
{
return(false);
}
var vch1 = top(_Stack, -4);
var vch2 = top(_Stack, -3);
_Stack.Push(vch1);
_Stack.Push(vch2);
}
break;
case OpcodeType.OP_2ROT:
{
// (x1 x2 x3 x4 x5 x6 -- x3 x4 x5 x6 x1 x2)
if (_Stack.Count < 6)
{
return(false);
}
var vch1 = top(_Stack, -6);
var vch2 = top(_Stack, -5);
erase(ref _Stack, _Stack.Count - 6, _Stack.Count - 4);
_Stack.Push(vch1);
_Stack.Push(vch2);
}
break;
case OpcodeType.OP_2SWAP:
{
// (x1 x2 x3 x4 -- x3 x4 x1 x2)
if (_Stack.Count < 4)
{
return(false);
}
swap(ref _Stack, -4, -2);
swap(ref _Stack, -3, -1);
}
break;
case OpcodeType.OP_IFDUP:
{
// (x - 0 | x x)
if (_Stack.Count < 1)
{
return(false);
}
var vch = top(_Stack, -1);
if (CastToBool(vch))
{
_Stack.Push(vch);
}
}
break;
case OpcodeType.OP_DEPTH:
{
// -- stacksize
BigInteger bn = new BigInteger(_Stack.Count);
_Stack.Push(Utils.BigIntegerToBytes(bn));
}
break;
case OpcodeType.OP_DROP:
{
// (x -- )
if (_Stack.Count < 1)
{
return(false);
}
_Stack.Pop();
}
break;
case OpcodeType.OP_DUP:
{
// (x -- x x)
if (_Stack.Count < 1)
{
return(false);
}
var vch = top(_Stack, -1);
_Stack.Push(vch);
}
break;
case OpcodeType.OP_NIP:
{
// (x1 x2 -- x2)
if (_Stack.Count < 2)
{
return(false);
}
erase(ref _Stack, _Stack.Count - 2);
}
break;
case OpcodeType.OP_OVER:
{
// (x1 x2 -- x1 x2 x1)
if (_Stack.Count < 2)
{
return(false);
}
var vch = top(_Stack, -2);
_Stack.Push(vch);
}
break;
case OpcodeType.OP_PICK:
case OpcodeType.OP_ROLL:
{
// (xn ... x2 x1 x0 n - xn ... x2 x1 x0 xn)
// (xn ... x2 x1 x0 n - ... x2 x1 x0 xn)
if (_Stack.Count < 2)
{
return(false);
}
int n = (int)CastToBigNum(top(_Stack, -1));
_Stack.Pop();
if (n < 0 || n >= _Stack.Count)
{
return(false);
}
var vch = top(_Stack, -n - 1);
if (opcode.Code == OpcodeType.OP_ROLL)
{
erase(ref _Stack, _Stack.Count - n - 1);
}
_Stack.Push(vch);
}
break;
case OpcodeType.OP_ROT:
{
// (x1 x2 x3 -- x2 x3 x1)
// x2 x1 x3 after first swap
// x2 x3 x1 after second swap
if (_Stack.Count < 3)
{
return(false);
}
swap(ref _Stack, -3, -2);
swap(ref _Stack, -2, -1);
}
break;
case OpcodeType.OP_SWAP:
{
// (x1 x2 -- x2 x1)
if (_Stack.Count < 2)
{
return(false);
}
swap(ref _Stack, -2, -1);
}
break;
case OpcodeType.OP_TUCK:
{
// (x1 x2 -- x2 x1 x2)
if (_Stack.Count < 2)
{
return(false);
}
var vch = top(_Stack, -1);
insert(ref _Stack, _Stack.Count - 2, vch);
}
break;
case OpcodeType.OP_SIZE:
{
// (in -- in size)
if (_Stack.Count < 1)
{
return(false);
}
BigInteger bn = new BigInteger(top(_Stack, -1).Length);
_Stack.Push(Utils.BigIntegerToBytes(bn));
}
break;
//
// Bitwise logic
//
case OpcodeType.OP_EQUAL:
case OpcodeType.OP_EQUALVERIFY:
//case OpcodeType.OP_NOTEQUAL: // use OpcodeType.OP_NUMNOTEQUAL
{
// (x1 x2 - bool)
if (_Stack.Count < 2)
{
return(false);
}
var vch1 = top(_Stack, -2);
var vch2 = top(_Stack, -1);
bool fEqual = Utils.ArrayEqual(vch1, vch2);
// OpcodeType.OP_NOTEQUAL is disabled because it would be too easy to say
// something like n != 1 and have some wiseguy pass in 1 with extra
// zero bytes after it (numerically, 0x01 == 0x0001 == 0x000001)
//if (opcode == OpcodeType.OP_NOTEQUAL)
// fEqual = !fEqual;
_Stack.Pop();
_Stack.Pop();
_Stack.Push(fEqual ? vchTrue : vchFalse);
if (opcode.Code == OpcodeType.OP_EQUALVERIFY)
{
if (fEqual)
{
_Stack.Pop();
}
else
{
return(false);
}
}
}
break;
//
// Numeric
//
case OpcodeType.OP_1ADD:
case OpcodeType.OP_1SUB:
case OpcodeType.OP_NEGATE:
case OpcodeType.OP_ABS:
case OpcodeType.OP_NOT:
case OpcodeType.OP_0NOTEQUAL:
{
// (in -- out)
if (_Stack.Count < 1)
{
return(false);
}
var bn = CastToBigNum(top(_Stack, -1));
switch (opcode.Code)
{
case OpcodeType.OP_1ADD:
bn += BigInteger.One;
break;
case OpcodeType.OP_1SUB:
bn -= BigInteger.One;
break;
case OpcodeType.OP_NEGATE:
bn = -bn;
break;
case OpcodeType.OP_ABS:
if (bn < BigInteger.Zero)
{
bn = -bn;
}
break;
case OpcodeType.OP_NOT:
bn = CastToBigNum(bn == BigInteger.Zero);
break;
case OpcodeType.OP_0NOTEQUAL:
bn = CastToBigNum(bn != BigInteger.Zero);
break;
default:
throw new NotSupportedException("invalid opcode");
}
_Stack.Pop();
_Stack.Push(Utils.BigIntegerToBytes(bn));
}
break;
case OpcodeType.OP_ADD:
case OpcodeType.OP_SUB:
case OpcodeType.OP_BOOLAND:
case OpcodeType.OP_BOOLOR:
case OpcodeType.OP_NUMEQUAL:
case OpcodeType.OP_NUMEQUALVERIFY:
case OpcodeType.OP_NUMNOTEQUAL:
case OpcodeType.OP_LESSTHAN:
case OpcodeType.OP_GREATERTHAN:
case OpcodeType.OP_LESSTHANOREQUAL:
case OpcodeType.OP_GREATERTHANOREQUAL:
case OpcodeType.OP_MIN:
case OpcodeType.OP_MAX:
{
// (x1 x2 -- out)
if (_Stack.Count < 2)
{
return(false);
}
var bn1 = CastToBigNum(top(_Stack, -2));
var bn2 = CastToBigNum(top(_Stack, -1));
BigInteger bn;
switch (opcode.Code)
{
case OpcodeType.OP_ADD:
bn = bn1 + bn2;
break;
case OpcodeType.OP_SUB:
bn = bn1 - bn2;
break;
case OpcodeType.OP_BOOLAND:
bn = CastToBigNum(bn1 != BigInteger.Zero && bn2 != BigInteger.Zero);
break;
case OpcodeType.OP_BOOLOR:
bn = CastToBigNum(bn1 != BigInteger.Zero || bn2 != BigInteger.Zero);
break;
case OpcodeType.OP_NUMEQUAL:
bn = CastToBigNum(bn1 == bn2);
break;
case OpcodeType.OP_NUMEQUALVERIFY:
bn = CastToBigNum(bn1 == bn2);
break;
case OpcodeType.OP_NUMNOTEQUAL:
bn = CastToBigNum(bn1 != bn2);
break;
case OpcodeType.OP_LESSTHAN:
bn = CastToBigNum(bn1 < bn2);
break;
case OpcodeType.OP_GREATERTHAN:
bn = CastToBigNum(bn1 > bn2);
break;
case OpcodeType.OP_LESSTHANOREQUAL:
bn = CastToBigNum(bn1 <= bn2);
break;
case OpcodeType.OP_GREATERTHANOREQUAL:
bn = CastToBigNum(bn1 >= bn2);
break;
case OpcodeType.OP_MIN:
bn = (bn1 < bn2 ? bn1 : bn2);
break;
case OpcodeType.OP_MAX:
bn = (bn1 > bn2 ? bn1 : bn2);
break;
default:
throw new NotSupportedException("invalid opcode");
}
_Stack.Pop();
_Stack.Pop();
_Stack.Push(Utils.BigIntegerToBytes(bn));
if (opcode.Code == OpcodeType.OP_NUMEQUALVERIFY)
{
if (CastToBool(top(_Stack, -1)))
{
_Stack.Pop();
}
else
{
return(false);
}
}
}
break;
case OpcodeType.OP_WITHIN:
{
// (x min max -- out)
if (_Stack.Count < 3)
{
return(false);
}
var bn1 = CastToBigNum(top(_Stack, -3));
var bn2 = CastToBigNum(top(_Stack, -2));
var bn3 = CastToBigNum(top(_Stack, -1));
bool fValue = (bn2 <= bn1 && bn1 < bn3);
_Stack.Pop();
_Stack.Pop();
_Stack.Pop();
_Stack.Push(fValue ? vchTrue : vchFalse);
}
break;
//
// Crypto
//
case OpcodeType.OP_RIPEMD160:
case OpcodeType.OP_SHA1:
case OpcodeType.OP_SHA256:
case OpcodeType.OP_HASH160:
case OpcodeType.OP_HASH256:
{
// (in -- hash)
if (_Stack.Count < 1)
{
return(false);
}
var vch = top(_Stack, -1);
byte[] vchHash = null; //((opcode == OpcodeType.OP_RIPEMD160 || opcode == OpcodeType.OP_SHA1 || opcode == OpcodeType.OP_HASH160) ? 20 : 32);
if (opcode.Code == OpcodeType.OP_RIPEMD160)
{
vchHash = Hashes.RIPEMD160(vch, vch.Length);
}
else if (opcode.Code == OpcodeType.OP_SHA1)
{
vchHash = Hashes.SHA1(vch, vch.Length);
}
else if (opcode.Code == OpcodeType.OP_SHA256)
{
vchHash = Hashes.SHA256(vch, vch.Length);
}
else if (opcode.Code == OpcodeType.OP_HASH160)
{
vchHash = Hashes.Hash160(vch, vch.Length).ToBytes();
}
else if (opcode.Code == OpcodeType.OP_HASH256)
{
vchHash = Hashes.Hash256(vch, vch.Length).ToBytes();
}
_Stack.Pop();
_Stack.Push(vchHash);
}
break;
case OpcodeType.OP_CODESEPARATOR:
{
// Hash starts after the code separator
pbegincodehash = (int)script.Inner.Position;
}
break;
case OpcodeType.OP_CHECKSIG:
case OpcodeType.OP_CHECKSIGVERIFY:
{
// (sig pubkey -- bool)
if (_Stack.Count < 2)
{
return(false);
}
var vchSig = top(_Stack, -2);
var vchPubKey = top(_Stack, -1);
////// debug print
//PrintHex(vchSig.begin(), vchSig.end(), "sig: %s\n");
//PrintHex(vchPubKey.begin(), vchPubKey.end(), "pubkey: %s\n");
// Subset of script starting at the most recent codeseparator
var scriptCode = new Script(s._Script.Skip(pbegincodehash).ToArray());
// Drop the signature, since there's no way for a signature to sign itself
scriptCode.FindAndDelete(vchSig);
bool fSuccess = IsCanonicalSignature(vchSig) && IsCanonicalPubKey(vchPubKey) &&
CheckSig(vchSig, vchPubKey, scriptCode, txTo, nIn);
_Stack.Pop();
_Stack.Pop();
_Stack.Push(fSuccess ? vchTrue : vchFalse);
if (opcode.Code == OpcodeType.OP_CHECKSIGVERIFY)
{
if (fSuccess)
{
_Stack.Pop();
}
else
{
return(false);
}
}
}
break;
case OpcodeType.OP_CHECKMULTISIG:
case OpcodeType.OP_CHECKMULTISIGVERIFY:
{
// ([sig ...] num_of_signatures [pubkey ...] num_of_pubkeys -- bool)
int i = 1;
if ((int)_Stack.Count < i)
{
return(false);
}
int nKeysCount = (int)CastToBigNum(top(_Stack, -i));
if (nKeysCount < 0 || nKeysCount > 20)
{
return(false);
}
nOpCount += nKeysCount;
if (nOpCount > 201)
{
return(false);
}
int ikey = ++i;
i += nKeysCount;
if ((int)_Stack.Count < i)
{
return(false);
}
int nSigsCount = (int)CastToBigNum(top(_Stack, -i));
if (nSigsCount < 0 || nSigsCount > nKeysCount)
{
return(false);
}
int isig = ++i;
i += nSigsCount;
if ((int)_Stack.Count < i)
{
return(false);
}
// Subset of script starting at the most recent codeseparator
Script scriptCode = new Script(s._Script.Skip(pbegincodehash).ToArray());
// Drop the signatures, since there's no way for a signature to sign itself
for (int k = 0; k < nSigsCount; k++)
{
var vchSig = top(_Stack, -isig - k);
scriptCode.FindAndDelete(vchSig);
}
bool fSuccess = true;
while (fSuccess && nSigsCount > 0)
{
var vchSig = top(_Stack, -isig);
var vchPubKey = top(_Stack, -ikey);
// Check signature
bool fOk = IsCanonicalSignature(vchSig) && IsCanonicalPubKey(vchPubKey) &&
CheckSig(vchSig, vchPubKey, scriptCode, txTo, nIn);
if (fOk)
{
isig++;
nSigsCount--;
}
ikey++;
nKeysCount--;
// If there are more signatures left than keys left,
// then too many signatures have failed
if (nSigsCount > nKeysCount)
{
fSuccess = false;
}
}
while (i-- > 1)
{
_Stack.Pop();
}
// A bug causes CHECKMULTISIG to consume one extra argument
// whose contents were not checked in any way.
//
// Unfortunately this is a potential source of mutability,
// so optionally verify it is exactly equal to zero prior
// to removing it from the stack.
if (_Stack.Count < 1)
{
return(false);
}
if (((ScriptVerify & ScriptVerify.NullDummy) != 0) && top(_Stack, -1).Length != 0)
{
return(Utils.error("CHECKMULTISIG dummy argument not null"));
}
_Stack.Pop();
_Stack.Push(fSuccess ? vchTrue : vchFalse);
if (opcode.Code == OpcodeType.OP_CHECKMULTISIGVERIFY)
{
if (fSuccess)
{
_Stack.Pop();
}
else
{
return(false);
}
}
}
break;
default:
return(false);
}
}
// Size limits
if (_Stack.Count + altstack.Count > 1000)
{
return(false);
}
}
}
catch (Exception ex)
{
Utils.error("Error in EvalScript " + ex.Message + " on opcode " + opcode);
return(false);
}
if (vfExec.Count != 0)
{
return(false);
}
return(true);
}
public static Op GetPushOp(BigInteger data)
{
return(GetPushOp(Utils.BigIntegerToBytes(data)));
}
