LBRYCommunity/lbcd
1
0
Fork 0
Code Issues 17 Pull requests 4 Packages Projects Releases 28 Wiki Activity
lbcd/txscript/internal_test.go
David Hill 761381066d txscript: Add new verification flags. 
This commit adds two new verification flags to txscript named
ScriptVerifyStrictEncoding and ScriptVerifyDerSignatures.

The ScriptVerifyStrictEncoding flag enforces signature scripts
and public keys to follow the strict encoding requirements.

The ScriptVerifyDerSignatures flag enforces signature scripts
to follow the strict encoding requirements.

These flags mimic Bitcoin Core's SCRIPT_VERIFY_STRICTENC and
SCRIPT_VERIFY_DERSIG flags and brings the Bitcoin Core test scripts up
to date.
2015-02-12 12:27:44 -05:00

4602 lines
95 KiB
Go
Raw Blame History

// Copyright (c) 2013-2015 Conformal Systems LLC.
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package txscript
import (
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"io/ioutil"
"strconv"
"strings"
"testing"
"github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcutil"
)
// TstMaxScriptSize makes the internal maxScriptSize constant available to the
// test package.
const TstMaxScriptSize = maxScriptSize
// this file is present to export some internal interfaces so that we can
// test them reliably.
func TestCheckPubKeyEncoding(t *testing.T) {
t.Parallel()
tests := []struct {
name string
key []byte
isValid bool
}{
{
name: "uncompressed ok",
key: []byte{0x04, 0x11, 0xdb, 0x93, 0xe1, 0xdc, 0xdb, 0x8a,
0x01, 0x6b, 0x49, 0x84, 0x0f, 0x8c, 0x53, 0xbc, 0x1e,
0xb6, 0x8a, 0x38, 0x2e, 0x97, 0xb1, 0x48, 0x2e, 0xca,
0xd7, 0xb1, 0x48, 0xa6, 0x90, 0x9a, 0x5c, 0xb2, 0xe0,
0xea, 0xdd, 0xfb, 0x84, 0xcc, 0xf9, 0x74, 0x44, 0x64,
0xf8, 0x2e, 0x16, 0x0b, 0xfa, 0x9b, 0x8b, 0x64, 0xf9,
0xd4, 0xc0, 0x3f, 0x99, 0x9b, 0x86, 0x43, 0xf6, 0x56,
0xb4, 0x12, 0xa3,
},
isValid: true,
},
{
name: "compressed ok",
key: []byte{0x02, 0xce, 0x0b, 0x14, 0xfb, 0x84, 0x2b, 0x1b,
0xa5, 0x49, 0xfd, 0xd6, 0x75, 0xc9, 0x80, 0x75, 0xf1,
0x2e, 0x9c, 0x51, 0x0f, 0x8e, 0xf5, 0x2b, 0xd0, 0x21,
0xa9, 0xa1, 0xf4, 0x80, 0x9d, 0x3b, 0x4d,
},
isValid: true,
},
{
name: "compressed ok",
key: []byte{0x03, 0x26, 0x89, 0xc7, 0xc2, 0xda, 0xb1, 0x33,
0x09, 0xfb, 0x14, 0x3e, 0x0e, 0x8f, 0xe3, 0x96, 0x34,
0x25, 0x21, 0x88, 0x7e, 0x97, 0x66, 0x90, 0xb6, 0xb4,
0x7f, 0x5b, 0x2a, 0x4b, 0x7d, 0x44, 0x8e,
},
isValid: true,
},
{
name: "hybrid",
key: []byte{0x06, 0x79, 0xbe, 0x66, 0x7e, 0xf9, 0xdc, 0xbb,
0xac, 0x55, 0xa0, 0x62, 0x95, 0xce, 0x87, 0x0b, 0x07,
0x02, 0x9b, 0xfc, 0xdb, 0x2d, 0xce, 0x28, 0xd9, 0x59,
0xf2, 0x81, 0x5b, 0x16, 0xf8, 0x17, 0x98, 0x48, 0x3a,
0xda, 0x77, 0x26, 0xa3, 0xc4, 0x65, 0x5d, 0xa4, 0xfb,
0xfc, 0x0e, 0x11, 0x08, 0xa8, 0xfd, 0x17, 0xb4, 0x48,
0xa6, 0x85, 0x54, 0x19, 0x9c, 0x47, 0xd0, 0x8f, 0xfb,
0x10, 0xd4, 0xb8,
},
isValid: false,
},
{
name: "empty.",
key: []byte{},
isValid: false,
},
}
s := Script{
verifyStrictEncoding: true,
}
for _, test := range tests {
err := s.checkPubKeyEncoding(test.key)
if err != nil && test.isValid {
t.Errorf("checkSignatureEncoding test '%s' failed "+
"when it should have succeeded: %v", test.name,
err)
} else if err == nil && !test.isValid {
t.Errorf("checkSignatureEncooding test '%s' succeeded "+
"when it should have failed", test.name)
}
}
}
func TestCheckSignatureEncoding(t *testing.T) {
t.Parallel()
tests := []struct {
name string
sig []byte
isValid bool
}{
{
name: "valid signature.",
sig: []byte{0x30, 0x44, 0x02, 0x20, 0x4e, 0x45, 0xe1, 0x69,
0x32, 0xb8, 0xaf, 0x51, 0x49, 0x61, 0xa1, 0xd3, 0xa1,
0xa2, 0x5f, 0xdf, 0x3f, 0x4f, 0x77, 0x32, 0xe9, 0xd6,
0x24, 0xc6, 0xc6, 0x15, 0x48, 0xab, 0x5f, 0xb8, 0xcd,
0x41, 0x02, 0x20, 0x18, 0x15, 0x22, 0xec, 0x8e, 0xca,
0x07, 0xde, 0x48, 0x60, 0xa4, 0xac, 0xdd, 0x12, 0x90,
0x9d, 0x83, 0x1c, 0xc5, 0x6c, 0xbb, 0xac, 0x46, 0x22,
0x08, 0x22, 0x21, 0xa8, 0x76, 0x8d, 0x1d, 0x09,
},
isValid: true,
},
{
name: "empty.",
sig: []byte{},
isValid: false,
},
{
name: "bad magic.",
sig: []byte{0x31, 0x44, 0x02, 0x20, 0x4e, 0x45, 0xe1, 0x69,
0x32, 0xb8, 0xaf, 0x51, 0x49, 0x61, 0xa1, 0xd3, 0xa1,
0xa2, 0x5f, 0xdf, 0x3f, 0x4f, 0x77, 0x32, 0xe9, 0xd6,
0x24, 0xc6, 0xc6, 0x15, 0x48, 0xab, 0x5f, 0xb8, 0xcd,
0x41, 0x02, 0x20, 0x18, 0x15, 0x22, 0xec, 0x8e, 0xca,
0x07, 0xde, 0x48, 0x60, 0xa4, 0xac, 0xdd, 0x12, 0x90,
0x9d, 0x83, 0x1c, 0xc5, 0x6c, 0xbb, 0xac, 0x46, 0x22,
0x08, 0x22, 0x21, 0xa8, 0x76, 0x8d, 0x1d, 0x09,
},
isValid: false,
},
{
name: "bad 1st int marker magic.",
sig: []byte{0x30, 0x44, 0x03, 0x20, 0x4e, 0x45, 0xe1, 0x69,
0x32, 0xb8, 0xaf, 0x51, 0x49, 0x61, 0xa1, 0xd3, 0xa1,
0xa2, 0x5f, 0xdf, 0x3f, 0x4f, 0x77, 0x32, 0xe9, 0xd6,
0x24, 0xc6, 0xc6, 0x15, 0x48, 0xab, 0x5f, 0xb8, 0xcd,
0x41, 0x02, 0x20, 0x18, 0x15, 0x22, 0xec, 0x8e, 0xca,
0x07, 0xde, 0x48, 0x60, 0xa4, 0xac, 0xdd, 0x12, 0x90,
0x9d, 0x83, 0x1c, 0xc5, 0x6c, 0xbb, 0xac, 0x46, 0x22,
0x08, 0x22, 0x21, 0xa8, 0x76, 0x8d, 0x1d, 0x09,
},
isValid: false,
},
{
name: "bad 2nd int marker.",
sig: []byte{0x30, 0x44, 0x02, 0x20, 0x4e, 0x45, 0xe1, 0x69,
0x32, 0xb8, 0xaf, 0x51, 0x49, 0x61, 0xa1, 0xd3, 0xa1,
0xa2, 0x5f, 0xdf, 0x3f, 0x4f, 0x77, 0x32, 0xe9, 0xd6,
0x24, 0xc6, 0xc6, 0x15, 0x48, 0xab, 0x5f, 0xb8, 0xcd,
0x41, 0x03, 0x20, 0x18, 0x15, 0x22, 0xec, 0x8e, 0xca,
0x07, 0xde, 0x48, 0x60, 0xa4, 0xac, 0xdd, 0x12, 0x90,
0x9d, 0x83, 0x1c, 0xc5, 0x6c, 0xbb, 0xac, 0x46, 0x22,
0x08, 0x22, 0x21, 0xa8, 0x76, 0x8d, 0x1d, 0x09,
},
isValid: false,
},
{
name: "short len",
sig: []byte{0x30, 0x43, 0x02, 0x20, 0x4e, 0x45, 0xe1, 0x69,
0x32, 0xb8, 0xaf, 0x51, 0x49, 0x61, 0xa1, 0xd3, 0xa1,
0xa2, 0x5f, 0xdf, 0x3f, 0x4f, 0x77, 0x32, 0xe9, 0xd6,
0x24, 0xc6, 0xc6, 0x15, 0x48, 0xab, 0x5f, 0xb8, 0xcd,
0x41, 0x02, 0x20, 0x18, 0x15, 0x22, 0xec, 0x8e, 0xca,
0x07, 0xde, 0x48, 0x60, 0xa4, 0xac, 0xdd, 0x12, 0x90,
0x9d, 0x83, 0x1c, 0xc5, 0x6c, 0xbb, 0xac, 0x46, 0x22,
0x08, 0x22, 0x21, 0xa8, 0x76, 0x8d, 0x1d, 0x09,
},
isValid: false,
},
{
name: "long len",
sig: []byte{0x30, 0x45, 0x02, 0x20, 0x4e, 0x45, 0xe1, 0x69,
0x32, 0xb8, 0xaf, 0x51, 0x49, 0x61, 0xa1, 0xd3, 0xa1,
0xa2, 0x5f, 0xdf, 0x3f, 0x4f, 0x77, 0x32, 0xe9, 0xd6,
0x24, 0xc6, 0xc6, 0x15, 0x48, 0xab, 0x5f, 0xb8, 0xcd,
0x41, 0x02, 0x20, 0x18, 0x15, 0x22, 0xec, 0x8e, 0xca,
0x07, 0xde, 0x48, 0x60, 0xa4, 0xac, 0xdd, 0x12, 0x90,
0x9d, 0x83, 0x1c, 0xc5, 0x6c, 0xbb, 0xac, 0x46, 0x22,
0x08, 0x22, 0x21, 0xa8, 0x76, 0x8d, 0x1d, 0x09,
},
isValid: false,
},
{
name: "long X",
sig: []byte{0x30, 0x44, 0x02, 0x42, 0x4e, 0x45, 0xe1, 0x69,
0x32, 0xb8, 0xaf, 0x51, 0x49, 0x61, 0xa1, 0xd3, 0xa1,
0xa2, 0x5f, 0xdf, 0x3f, 0x4f, 0x77, 0x32, 0xe9, 0xd6,
0x24, 0xc6, 0xc6, 0x15, 0x48, 0xab, 0x5f, 0xb8, 0xcd,
0x41, 0x02, 0x20, 0x18, 0x15, 0x22, 0xec, 0x8e, 0xca,
0x07, 0xde, 0x48, 0x60, 0xa4, 0xac, 0xdd, 0x12, 0x90,
0x9d, 0x83, 0x1c, 0xc5, 0x6c, 0xbb, 0xac, 0x46, 0x22,
0x08, 0x22, 0x21, 0xa8, 0x76, 0x8d, 0x1d, 0x09,
},
isValid: false,
},
{
name: "long Y",
sig: []byte{0x30, 0x44, 0x02, 0x20, 0x4e, 0x45, 0xe1, 0x69,
0x32, 0xb8, 0xaf, 0x51, 0x49, 0x61, 0xa1, 0xd3, 0xa1,
0xa2, 0x5f, 0xdf, 0x3f, 0x4f, 0x77, 0x32, 0xe9, 0xd6,
0x24, 0xc6, 0xc6, 0x15, 0x48, 0xab, 0x5f, 0xb8, 0xcd,
0x41, 0x02, 0x21, 0x18, 0x15, 0x22, 0xec, 0x8e, 0xca,
0x07, 0xde, 0x48, 0x60, 0xa4, 0xac, 0xdd, 0x12, 0x90,
0x9d, 0x83, 0x1c, 0xc5, 0x6c, 0xbb, 0xac, 0x46, 0x22,
0x08, 0x22, 0x21, 0xa8, 0x76, 0x8d, 0x1d, 0x09,
},
isValid: false,
},
{
name: "short Y",
sig: []byte{0x30, 0x44, 0x02, 0x20, 0x4e, 0x45, 0xe1, 0x69,
0x32, 0xb8, 0xaf, 0x51, 0x49, 0x61, 0xa1, 0xd3, 0xa1,
0xa2, 0x5f, 0xdf, 0x3f, 0x4f, 0x77, 0x32, 0xe9, 0xd6,
0x24, 0xc6, 0xc6, 0x15, 0x48, 0xab, 0x5f, 0xb8, 0xcd,
0x41, 0x02, 0x19, 0x18, 0x15, 0x22, 0xec, 0x8e, 0xca,
0x07, 0xde, 0x48, 0x60, 0xa4, 0xac, 0xdd, 0x12, 0x90,
0x9d, 0x83, 0x1c, 0xc5, 0x6c, 0xbb, 0xac, 0x46, 0x22,
0x08, 0x22, 0x21, 0xa8, 0x76, 0x8d, 0x1d, 0x09,
},
isValid: false,
},
{
name: "trailing crap.",
sig: []byte{0x30, 0x44, 0x02, 0x20, 0x4e, 0x45, 0xe1, 0x69,
0x32, 0xb8, 0xaf, 0x51, 0x49, 0x61, 0xa1, 0xd3, 0xa1,
0xa2, 0x5f, 0xdf, 0x3f, 0x4f, 0x77, 0x32, 0xe9, 0xd6,
0x24, 0xc6, 0xc6, 0x15, 0x48, 0xab, 0x5f, 0xb8, 0xcd,
0x41, 0x02, 0x20, 0x18, 0x15, 0x22, 0xec, 0x8e, 0xca,
0x07, 0xde, 0x48, 0x60, 0xa4, 0xac, 0xdd, 0x12, 0x90,
0x9d, 0x83, 0x1c, 0xc5, 0x6c, 0xbb, 0xac, 0x46, 0x22,
0x08, 0x22, 0x21, 0xa8, 0x76, 0x8d, 0x1d, 0x09, 0x01,
},
isValid: false,
},
{
name: "X == N ",
sig: []byte{0x30, 0x44, 0x02, 0x20, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFE, 0xBA, 0xAE, 0xDC, 0xE6, 0xAF, 0x48,
0xA0, 0x3B, 0xBF, 0xD2, 0x5E, 0x8C, 0xD0, 0x36, 0x41,
0x41, 0x02, 0x20, 0x18, 0x15, 0x22, 0xec, 0x8e, 0xca,
0x07, 0xde, 0x48, 0x60, 0xa4, 0xac, 0xdd, 0x12, 0x90,
0x9d, 0x83, 0x1c, 0xc5, 0x6c, 0xbb, 0xac, 0x46, 0x22,
0x08, 0x22, 0x21, 0xa8, 0x76, 0x8d, 0x1d, 0x09,
},
isValid: false,
},
{
name: "X == N ",
sig: []byte{0x30, 0x44, 0x02, 0x20, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFE, 0xBA, 0xAE, 0xDC, 0xE6, 0xAF, 0x48,
0xA0, 0x3B, 0xBF, 0xD2, 0x5E, 0x8C, 0xD0, 0x36, 0x41,
0x42, 0x02, 0x20, 0x18, 0x15, 0x22, 0xec, 0x8e, 0xca,
0x07, 0xde, 0x48, 0x60, 0xa4, 0xac, 0xdd, 0x12, 0x90,
0x9d, 0x83, 0x1c, 0xc5, 0x6c, 0xbb, 0xac, 0x46, 0x22,
0x08, 0x22, 0x21, 0xa8, 0x76, 0x8d, 0x1d, 0x09,
},
isValid: false,
},
{
name: "Y == N",
sig: []byte{0x30, 0x44, 0x02, 0x20, 0x4e, 0x45, 0xe1, 0x69,
0x32, 0xb8, 0xaf, 0x51, 0x49, 0x61, 0xa1, 0xd3, 0xa1,
0xa2, 0x5f, 0xdf, 0x3f, 0x4f, 0x77, 0x32, 0xe9, 0xd6,
0x24, 0xc6, 0xc6, 0x15, 0x48, 0xab, 0x5f, 0xb8, 0xcd,
0x41, 0x02, 0x20, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFE, 0xBA, 0xAE, 0xDC, 0xE6, 0xAF, 0x48, 0xA0, 0x3B,
0xBF, 0xD2, 0x5E, 0x8C, 0xD0, 0x36, 0x41, 0x41,
},
isValid: false,
},
{
name: "Y > N",
sig: []byte{0x30, 0x44, 0x02, 0x20, 0x4e, 0x45, 0xe1, 0x69,
0x32, 0xb8, 0xaf, 0x51, 0x49, 0x61, 0xa1, 0xd3, 0xa1,
0xa2, 0x5f, 0xdf, 0x3f, 0x4f, 0x77, 0x32, 0xe9, 0xd6,
0x24, 0xc6, 0xc6, 0x15, 0x48, 0xab, 0x5f, 0xb8, 0xcd,
0x41, 0x02, 0x20, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFE, 0xBA, 0xAE, 0xDC, 0xE6, 0xAF, 0x48, 0xA0, 0x3B,
0xBF, 0xD2, 0x5E, 0x8C, 0xD0, 0x36, 0x41, 0x42,
},
isValid: false,
},
{
name: "0 len X.",
sig: []byte{0x30, 0x24, 0x02, 0x00, 0x02, 0x20, 0x18, 0x15,
0x22, 0xec, 0x8e, 0xca, 0x07, 0xde, 0x48, 0x60, 0xa4,
0xac, 0xdd, 0x12, 0x90, 0x9d, 0x83, 0x1c, 0xc5, 0x6c,
0xbb, 0xac, 0x46, 0x22, 0x08, 0x22, 0x21, 0xa8, 0x76,
0x8d, 0x1d, 0x09,
},
isValid: false,
},
{
name: "0 len Y.",
sig: []byte{0x30, 0x24, 0x02, 0x20, 0x4e, 0x45, 0xe1, 0x69,
0x32, 0xb8, 0xaf, 0x51, 0x49, 0x61, 0xa1, 0xd3, 0xa1,
0xa2, 0x5f, 0xdf, 0x3f, 0x4f, 0x77, 0x32, 0xe9, 0xd6,
0x24, 0xc6, 0xc6, 0x15, 0x48, 0xab, 0x5f, 0xb8, 0xcd,
0x41, 0x02, 0x00,
},
isValid: false,
},
{
name: "extra R padding.",
sig: []byte{0x30, 0x45, 0x02, 0x21, 0x00, 0x4e, 0x45, 0xe1, 0x69,
0x32, 0xb8, 0xaf, 0x51, 0x49, 0x61, 0xa1, 0xd3, 0xa1,
0xa2, 0x5f, 0xdf, 0x3f, 0x4f, 0x77, 0x32, 0xe9, 0xd6,
0x24, 0xc6, 0xc6, 0x15, 0x48, 0xab, 0x5f, 0xb8, 0xcd,
0x41, 0x02, 0x20, 0x18, 0x15, 0x22, 0xec, 0x8e, 0xca,
0x07, 0xde, 0x48, 0x60, 0xa4, 0xac, 0xdd, 0x12, 0x90,
0x9d, 0x83, 0x1c, 0xc5, 0x6c, 0xbb, 0xac, 0x46, 0x22,
0x08, 0x22, 0x21, 0xa8, 0x76, 0x8d, 0x1d, 0x09,
},
isValid: false,
},
{
name: "extra S padding.",
sig: []byte{0x30, 0x45, 0x02, 0x20, 0x4e, 0x45, 0xe1, 0x69,
0x32, 0xb8, 0xaf, 0x51, 0x49, 0x61, 0xa1, 0xd3, 0xa1,
0xa2, 0x5f, 0xdf, 0x3f, 0x4f, 0x77, 0x32, 0xe9, 0xd6,
0x24, 0xc6, 0xc6, 0x15, 0x48, 0xab, 0x5f, 0xb8, 0xcd,
0x41, 0x02, 0x21, 0x00, 0x18, 0x15, 0x22, 0xec, 0x8e, 0xca,
0x07, 0xde, 0x48, 0x60, 0xa4, 0xac, 0xdd, 0x12, 0x90,
0x9d, 0x83, 0x1c, 0xc5, 0x6c, 0xbb, 0xac, 0x46, 0x22,
0x08, 0x22, 0x21, 0xa8, 0x76, 0x8d, 0x1d, 0x09,
},
isValid: false,
},
}
s := Script{
verifyStrictEncoding: true,
}
for _, test := range tests {
err := s.checkSignatureEncoding(test.sig)
if err != nil && test.isValid {
t.Errorf("checkSignatureEncoding test '%s' failed "+
"when it should have succeeded: %v", test.name,
err)
} else if err == nil && !test.isValid {
t.Errorf("checkSignatureEncooding test '%s' succeeded "+
"when it should have failed", test.name)
}
}
}
func TstRemoveOpcode(pkscript []byte, opcode byte) ([]byte, error) {
pops, err := parseScript(pkscript)
if err != nil {
return nil, err
}
pops = removeOpcode(pops, opcode)
return unparseScript(pops)
}
func TstRemoveOpcodeByData(pkscript []byte, data []byte) ([]byte, error) {
pops, err := parseScript(pkscript)
if err != nil {
return nil, err
}
pops = removeOpcodeByData(pops, data)
return unparseScript(pops)
}
// TestSetPC allows the test modules to set the program counter to whatever they
// want.
func (s *Script) TstSetPC(script, off int) {
s.scriptidx = script
s.scriptoff = off
}
// Internal tests for opcodde parsing with bad data templates.
func TestParseOpcode(t *testing.T) {
fakemap := make(map[byte]*opcode)
// deep copy
for k, v := range opcodemap {
fakemap[k] = v
}
// wrong length -8.
fakemap[OP_PUSHDATA4] = &opcode{value: OP_PUSHDATA4,
name: "OP_PUSHDATA4", length: -8, opfunc: opcodePushData}
// this script would be fine if -8 was a valid length.
_, err := parseScriptTemplate([]byte{OP_PUSHDATA4, 0x1, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00}, fakemap)
if err == nil {
t.Errorf("no error with dodgy opcode map!")
}
// Missing entry.
fakemap = make(map[byte]*opcode)
for k, v := range opcodemap {
fakemap[k] = v
}
delete(fakemap, OP_PUSHDATA4)
// this script would be fine if -8 was a valid length.
_, err = parseScriptTemplate([]byte{OP_PUSHDATA4, 0x1, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00}, fakemap)
if err == nil {
t.Errorf("no error with dodgy opcode map (missing entry)!")
}
}
type popTest struct {
name string
pop *parsedOpcode
expectedErr error
}
var popTests = []popTest{
{
name: "OP_FALSE",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_FALSE],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_FALSE long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_FALSE],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_1 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_1],
data: nil,
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_1",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_1],
data: make([]byte, 1),
},
expectedErr: nil,
},
{
name: "OP_DATA_1 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_1],
data: make([]byte, 2),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_2 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_2],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_2",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_2],
data: make([]byte, 2),
},
expectedErr: nil,
},
{
name: "OP_DATA_2 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_2],
data: make([]byte, 3),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_3 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_3],
data: make([]byte, 2),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_3",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_3],
data: make([]byte, 3),
},
expectedErr: nil,
},
{
name: "OP_DATA_3 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_3],
data: make([]byte, 4),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_4 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_4],
data: make([]byte, 3),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_4",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_4],
data: make([]byte, 4),
},
expectedErr: nil,
},
{
name: "OP_DATA_4 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_4],
data: make([]byte, 5),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_5 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_5],
data: make([]byte, 4),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_5",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_5],
data: make([]byte, 5),
},
expectedErr: nil,
},
{
name: "OP_DATA_5 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_5],
data: make([]byte, 6),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_6 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_6],
data: make([]byte, 5),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_6",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_6],
data: make([]byte, 6),
},
expectedErr: nil,
},
{
name: "OP_DATA_6 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_6],
data: make([]byte, 7),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_7 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_7],
data: make([]byte, 6),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_7",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_7],
data: make([]byte, 7),
},
expectedErr: nil,
},
{
name: "OP_DATA_7 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_7],
data: make([]byte, 8),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_8 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_8],
data: make([]byte, 7),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_8",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_8],
data: make([]byte, 8),
},
expectedErr: nil,
},
{
name: "OP_DATA_8 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_8],
data: make([]byte, 9),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_9 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_9],
data: make([]byte, 8),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_9",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_9],
data: make([]byte, 9),
},
expectedErr: nil,
},
{
name: "OP_DATA_9 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_9],
data: make([]byte, 10),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_10 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_10],
data: make([]byte, 9),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_10",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_10],
data: make([]byte, 10),
},
expectedErr: nil,
},
{
name: "OP_DATA_10 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_10],
data: make([]byte, 11),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_11 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_11],
data: make([]byte, 10),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_11",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_11],
data: make([]byte, 11),
},
expectedErr: nil,
},
{
name: "OP_DATA_11 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_11],
data: make([]byte, 12),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_12 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_12],
data: make([]byte, 11),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_12",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_12],
data: make([]byte, 12),
},
expectedErr: nil,
},
{
name: "OP_DATA_12 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_12],
data: make([]byte, 13),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_13 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_13],
data: make([]byte, 12),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_13",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_13],
data: make([]byte, 13),
},
expectedErr: nil,
},
{
name: "OP_DATA_13 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_13],
data: make([]byte, 14),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_14 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_14],
data: make([]byte, 13),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_14",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_14],
data: make([]byte, 14),
},
expectedErr: nil,
},
{
name: "OP_DATA_14 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_14],
data: make([]byte, 15),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_15 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_15],
data: make([]byte, 14),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_15",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_15],
data: make([]byte, 15),
},
expectedErr: nil,
},
{
name: "OP_DATA_15 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_15],
data: make([]byte, 16),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_16 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_16],
data: make([]byte, 15),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_16",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_16],
data: make([]byte, 16),
},
expectedErr: nil,
},
{
name: "OP_DATA_16 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_16],
data: make([]byte, 17),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_17 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_17],
data: make([]byte, 16),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_17",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_17],
data: make([]byte, 17),
},
expectedErr: nil,
},
{
name: "OP_DATA_17 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_17],
data: make([]byte, 18),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_18 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_18],
data: make([]byte, 17),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_18",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_18],
data: make([]byte, 18),
},
expectedErr: nil,
},
{
name: "OP_DATA_18 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_18],
data: make([]byte, 19),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_19 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_19],
data: make([]byte, 18),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_19",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_19],
data: make([]byte, 19),
},
expectedErr: nil,
},
{
name: "OP_DATA_19 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_19],
data: make([]byte, 20),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_20 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_20],
data: make([]byte, 19),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_20",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_20],
data: make([]byte, 20),
},
expectedErr: nil,
},
{
name: "OP_DATA_20 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_20],
data: make([]byte, 21),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_21 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_21],
data: make([]byte, 20),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_21",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_21],
data: make([]byte, 21),
},
expectedErr: nil,
},
{
name: "OP_DATA_21 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_21],
data: make([]byte, 22),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_22 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_22],
data: make([]byte, 21),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_22",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_22],
data: make([]byte, 22),
},
expectedErr: nil,
},
{
name: "OP_DATA_22 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_22],
data: make([]byte, 23),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_23 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_23],
data: make([]byte, 22),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_23",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_23],
data: make([]byte, 23),
},
expectedErr: nil,
},
{
name: "OP_DATA_23 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_23],
data: make([]byte, 24),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_24 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_24],
data: make([]byte, 23),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_24",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_24],
data: make([]byte, 24),
},
expectedErr: nil,
},
{
name: "OP_DATA_24 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_24],
data: make([]byte, 25),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_25 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_25],
data: make([]byte, 24),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_25",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_25],
data: make([]byte, 25),
},
expectedErr: nil,
},
{
name: "OP_DATA_25 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_25],
data: make([]byte, 26),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_26 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_26],
data: make([]byte, 25),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_26",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_26],
data: make([]byte, 26),
},
expectedErr: nil,
},
{
name: "OP_DATA_26 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_26],
data: make([]byte, 27),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_27 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_27],
data: make([]byte, 26),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_27",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_27],
data: make([]byte, 27),
},
expectedErr: nil,
},
{
name: "OP_DATA_27 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_27],
data: make([]byte, 28),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_28 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_28],
data: make([]byte, 27),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_28",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_28],
data: make([]byte, 28),
},
expectedErr: nil,
},
{
name: "OP_DATA_28 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_28],
data: make([]byte, 29),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_29 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_29],
data: make([]byte, 28),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_29",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_29],
data: make([]byte, 29),
},
expectedErr: nil,
},
{
name: "OP_DATA_29 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_29],
data: make([]byte, 30),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_30 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_30],
data: make([]byte, 29),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_30",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_30],
data: make([]byte, 30),
},
expectedErr: nil,
},
{
name: "OP_DATA_30 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_30],
data: make([]byte, 31),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_31 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_31],
data: make([]byte, 30),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_31",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_31],
data: make([]byte, 31),
},
expectedErr: nil,
},
{
name: "OP_DATA_31 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_31],
data: make([]byte, 32),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_32 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_32],
data: make([]byte, 31),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_32",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_32],
data: make([]byte, 32),
},
expectedErr: nil,
},
{
name: "OP_DATA_32 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_32],
data: make([]byte, 33),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_33 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_33],
data: make([]byte, 32),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_33",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_33],
data: make([]byte, 33),
},
expectedErr: nil,
},
{
name: "OP_DATA_33 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_33],
data: make([]byte, 34),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_34 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_34],
data: make([]byte, 33),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_34",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_34],
data: make([]byte, 34),
},
expectedErr: nil,
},
{
name: "OP_DATA_34 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_34],
data: make([]byte, 35),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_35 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_35],
data: make([]byte, 34),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_35",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_35],
data: make([]byte, 35),
},
expectedErr: nil,
},
{
name: "OP_DATA_35 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_35],
data: make([]byte, 36),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_36 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_36],
data: make([]byte, 35),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_36",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_36],
data: make([]byte, 36),
},
expectedErr: nil,
},
{
name: "OP_DATA_36 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_36],
data: make([]byte, 37),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_37 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_37],
data: make([]byte, 36),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_37",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_37],
data: make([]byte, 37),
},
expectedErr: nil,
},
{
name: "OP_DATA_37 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_37],
data: make([]byte, 38),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_38 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_38],
data: make([]byte, 37),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_38",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_38],
data: make([]byte, 38),
},
expectedErr: nil,
},
{
name: "OP_DATA_38 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_38],
data: make([]byte, 39),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_39 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_39],
data: make([]byte, 38),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_39",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_39],
data: make([]byte, 39),
},
expectedErr: nil,
},
{
name: "OP_DATA_39 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_39],
data: make([]byte, 40),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_40 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_40],
data: make([]byte, 39),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_40",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_40],
data: make([]byte, 40),
},
expectedErr: nil,
},
{
name: "OP_DATA_40 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_40],
data: make([]byte, 41),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_41 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_41],
data: make([]byte, 40),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_41",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_41],
data: make([]byte, 41),
},
expectedErr: nil,
},
{
name: "OP_DATA_41 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_41],
data: make([]byte, 42),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_42 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_42],
data: make([]byte, 41),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_42",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_42],
data: make([]byte, 42),
},
expectedErr: nil,
},
{
name: "OP_DATA_42 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_42],
data: make([]byte, 43),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_43 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_43],
data: make([]byte, 42),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_43",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_43],
data: make([]byte, 43),
},
expectedErr: nil,
},
{
name: "OP_DATA_43 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_43],
data: make([]byte, 44),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_44 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_44],
data: make([]byte, 43),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_44",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_44],
data: make([]byte, 44),
},
expectedErr: nil,
},
{
name: "OP_DATA_44 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_44],
data: make([]byte, 45),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_45 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_45],
data: make([]byte, 44),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_45",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_45],
data: make([]byte, 45),
},
expectedErr: nil,
},
{
name: "OP_DATA_45 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_45],
data: make([]byte, 46),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_46 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_46],
data: make([]byte, 45),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_46",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_46],
data: make([]byte, 46),
},
expectedErr: nil,
},
{
name: "OP_DATA_46 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_46],
data: make([]byte, 47),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_47 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_47],
data: make([]byte, 46),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_47",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_47],
data: make([]byte, 47),
},
expectedErr: nil,
},
{
name: "OP_DATA_47 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_47],
data: make([]byte, 48),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_48 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_48],
data: make([]byte, 47),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_48",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_48],
data: make([]byte, 48),
},
expectedErr: nil,
},
{
name: "OP_DATA_48 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_48],
data: make([]byte, 49),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_49 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_49],
data: make([]byte, 48),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_49",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_49],
data: make([]byte, 49),
},
expectedErr: nil,
},
{
name: "OP_DATA_49 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_49],
data: make([]byte, 50),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_50 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_50],
data: make([]byte, 49),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_50",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_50],
data: make([]byte, 50),
},
expectedErr: nil,
},
{
name: "OP_DATA_50 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_50],
data: make([]byte, 51),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_51 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_51],
data: make([]byte, 50),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_51",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_51],
data: make([]byte, 51),
},
expectedErr: nil,
},
{
name: "OP_DATA_51 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_51],
data: make([]byte, 52),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_52 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_52],
data: make([]byte, 51),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_52",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_52],
data: make([]byte, 52),
},
expectedErr: nil,
},
{
name: "OP_DATA_52 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_52],
data: make([]byte, 53),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_53 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_53],
data: make([]byte, 52),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_53",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_53],
data: make([]byte, 53),
},
expectedErr: nil,
},
{
name: "OP_DATA_53 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_53],
data: make([]byte, 54),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_54 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_54],
data: make([]byte, 53),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_54",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_54],
data: make([]byte, 54),
},
expectedErr: nil,
},
{
name: "OP_DATA_54 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_54],
data: make([]byte, 55),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_55 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_55],
data: make([]byte, 54),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_55",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_55],
data: make([]byte, 55),
},
expectedErr: nil,
},
{
name: "OP_DATA_55 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_55],
data: make([]byte, 56),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_56 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_56],
data: make([]byte, 55),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_56",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_56],
data: make([]byte, 56),
},
expectedErr: nil,
},
{
name: "OP_DATA_56 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_56],
data: make([]byte, 57),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_57 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_57],
data: make([]byte, 56),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_57",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_57],
data: make([]byte, 57),
},
expectedErr: nil,
},
{
name: "OP_DATA_57 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_57],
data: make([]byte, 58),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_58 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_58],
data: make([]byte, 57),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_58",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_58],
data: make([]byte, 58),
},
expectedErr: nil,
},
{
name: "OP_DATA_58 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_58],
data: make([]byte, 59),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_59 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_59],
data: make([]byte, 58),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_59",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_59],
data: make([]byte, 59),
},
expectedErr: nil,
},
{
name: "OP_DATA_59 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_59],
data: make([]byte, 60),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_60 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_60],
data: make([]byte, 59),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_60",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_60],
data: make([]byte, 60),
},
expectedErr: nil,
},
{
name: "OP_DATA_60 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_60],
data: make([]byte, 61),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_61 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_61],
data: make([]byte, 60),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_61",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_61],
data: make([]byte, 61),
},
expectedErr: nil,
},
{
name: "OP_DATA_61 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_61],
data: make([]byte, 62),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_62 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_62],
data: make([]byte, 61),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_62",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_62],
data: make([]byte, 62),
},
expectedErr: nil,
},
{
name: "OP_DATA_62 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_62],
data: make([]byte, 63),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_63 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_63],
data: make([]byte, 62),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_63",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_63],
data: make([]byte, 63),
},
expectedErr: nil,
},
{
name: "OP_DATA_63 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_63],
data: make([]byte, 64),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_64 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_64],
data: make([]byte, 63),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_64",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_64],
data: make([]byte, 64),
},
expectedErr: nil,
},
{
name: "OP_DATA_64 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_64],
data: make([]byte, 65),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_65 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_65],
data: make([]byte, 64),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_65",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_65],
data: make([]byte, 65),
},
expectedErr: nil,
},
{
name: "OP_DATA_65 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_65],
data: make([]byte, 66),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_66 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_66],
data: make([]byte, 65),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_66",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_66],
data: make([]byte, 66),
},
expectedErr: nil,
},
{
name: "OP_DATA_66 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_66],
data: make([]byte, 67),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_67 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_67],
data: make([]byte, 66),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_67",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_67],
data: make([]byte, 67),
},
expectedErr: nil,
},
{
name: "OP_DATA_67 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_67],
data: make([]byte, 68),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_68 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_68],
data: make([]byte, 67),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_68",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_68],
data: make([]byte, 68),
},
expectedErr: nil,
},
{
name: "OP_DATA_68 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_68],
data: make([]byte, 69),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_69 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_69],
data: make([]byte, 68),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_69",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_69],
data: make([]byte, 69),
},
expectedErr: nil,
},
{
name: "OP_DATA_69 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_69],
data: make([]byte, 70),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_70 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_70],
data: make([]byte, 69),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_70",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_70],
data: make([]byte, 70),
},
expectedErr: nil,
},
{
name: "OP_DATA_70 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_70],
data: make([]byte, 71),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_71 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_71],
data: make([]byte, 70),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_71",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_71],
data: make([]byte, 71),
},
expectedErr: nil,
},
{
name: "OP_DATA_71 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_71],
data: make([]byte, 72),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_72 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_72],
data: make([]byte, 71),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_72",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_72],
data: make([]byte, 72),
},
expectedErr: nil,
},
{
name: "OP_DATA_72 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_72],
data: make([]byte, 73),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_73 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_73],
data: make([]byte, 72),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_73",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_73],
data: make([]byte, 73),
},
expectedErr: nil,
},
{
name: "OP_DATA_73 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_73],
data: make([]byte, 74),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_74 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_74],
data: make([]byte, 73),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_74",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_74],
data: make([]byte, 74),
},
expectedErr: nil,
},
{
name: "OP_DATA_74 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_74],
data: make([]byte, 75),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_75 short",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_75],
data: make([]byte, 74),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DATA_75",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_75],
data: make([]byte, 75),
},
expectedErr: nil,
},
{
name: "OP_DATA_75 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DATA_75],
data: make([]byte, 76),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_PUSHDATA1",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_PUSHDATA1],
data: []byte{0, 1, 2, 3, 4},
},
expectedErr: nil,
},
{
name: "OP_PUSHDATA2",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_PUSHDATA2],
data: []byte{0, 1, 2, 3, 4},
},
expectedErr: nil,
},
{
name: "OP_PUSHDATA4",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_PUSHDATA1],
data: []byte{0, 1, 2, 3, 4},
},
expectedErr: nil,
},
{
name: "OP_1NEGATE",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_1NEGATE],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_1NEGATE long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_1NEGATE],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_RESERVED",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_RESERVED],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_RESERVED long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_RESERVED],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_TRUE",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_TRUE],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_TRUE long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_TRUE],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_2",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_2],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_2 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_2],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_2",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_2],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_2 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_2],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_3",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_3],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_3 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_3],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_4",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_4],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_4 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_4],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_5",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_5],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_5 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_5],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_6",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_6],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_6 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_6],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_7",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_7],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_7 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_7],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_8",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_8],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_8 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_8],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_9",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_9],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_9 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_9],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_10",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_10],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_10 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_10],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_11",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_11],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_11 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_11],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_12",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_12],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_12 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_12],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_13",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_13],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_13 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_13],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_14",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_14],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_14 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_14],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_15",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_15],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_15 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_15],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_16",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_16],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_16 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_16],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_NOP",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOP],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_NOP long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOP],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_VER",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_VER],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_VER long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_VER],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_IF",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_IF],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_IF long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_IF],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_NOTIF",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOTIF],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_NOTIF long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOTIF],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_VERIF",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_VERIF],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_VERIF long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_VERIF],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_VERNOTIF",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_VERNOTIF],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_VERNOTIF long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_VERNOTIF],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_ELSE",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_ELSE],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_ELSE long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_ELSE],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_ENDIF",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_ENDIF],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_ENDIF long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_ENDIF],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_VERIFY",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_VERIFY],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_VERIFY long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_VERIFY],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_RETURN",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_RETURN],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_RETURN long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_RETURN],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_TOALTSTACK",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_TOALTSTACK],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_TOALTSTACK long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_TOALTSTACK],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_FROMALTSTACK",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_FROMALTSTACK],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_FROMALTSTACK long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_FROMALTSTACK],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_2DROP",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_2DROP],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_2DROP long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_2DROP],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_2DUP",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_2DUP],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_2DUP long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_2DUP],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_3DUP",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_3DUP],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_3DUP long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_3DUP],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_2OVER",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_2OVER],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_2OVER long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_2OVER],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_2ROT",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_2ROT],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_2ROT long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_2ROT],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_2SWAP",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_2SWAP],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_2SWAP long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_2SWAP],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_IFDUP",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_IFDUP],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_IFDUP long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_IFDUP],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DEPTH",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DEPTH],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_DEPTH long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DEPTH],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DROP",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DROP],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_DROP long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DROP],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DUP",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DUP],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_DUP long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DUP],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_NIP",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NIP],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_NIP long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NIP],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_OVER",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_OVER],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_OVER long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_OVER],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_PICK",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_PICK],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_PICK long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_PICK],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_ROLL",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_ROLL],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_ROLL long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_ROLL],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_ROT",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_ROT],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_ROT long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_ROT],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_SWAP",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_SWAP],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_SWAP long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_SWAP],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_TUCK",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_TUCK],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_TUCK long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_TUCK],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_CAT",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_CAT],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_CAT long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_CAT],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_SUBSTR",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_SUBSTR],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_SUBSTR long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_SUBSTR],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_LEFT",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_LEFT],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_LEFT long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_LEFT],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_LEFT",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_LEFT],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_LEFT long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_LEFT],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_RIGHT",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_RIGHT],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_RIGHT long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_RIGHT],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_SIZE",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_SIZE],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_SIZE long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_SIZE],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_INVERT",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_INVERT],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_INVERT long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_INVERT],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_AND",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_AND],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_AND long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_AND],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_OR",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_OR],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_OR long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_OR],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_XOR",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_XOR],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_XOR long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_XOR],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_EQUAL",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_EQUAL],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_EQUAL long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_EQUAL],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_EQUALVERIFY",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_EQUALVERIFY],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_EQUALVERIFY long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_EQUALVERIFY],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_RESERVED1",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_RESERVED1],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_RESERVED1 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_RESERVED1],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_RESERVED2",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_RESERVED2],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_RESERVED2 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_RESERVED2],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_1ADD",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_1ADD],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_1ADD long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_1ADD],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_1SUB",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_1SUB],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_1SUB long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_1SUB],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_2MUL",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_2MUL],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_2MUL long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_2MUL],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_2DIV",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_2DIV],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_2DIV long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_2DIV],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_NEGATE",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NEGATE],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_NEGATE long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NEGATE],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_ABS",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_ABS],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_ABS long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_ABS],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_NOT",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOT],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_NOT long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOT],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_0NOTEQUAL",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_0NOTEQUAL],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_0NOTEQUAL long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_0NOTEQUAL],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_ADD",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_ADD],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_ADD long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_ADD],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_SUB",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_SUB],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_SUB long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_SUB],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_MUL",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_MUL],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_MUL long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_MUL],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_DIV",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DIV],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_DIV long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_DIV],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_MOD",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_MOD],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_MOD long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_MOD],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_LSHIFT",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_LSHIFT],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_LSHIFT long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_LSHIFT],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_RSHIFT",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_RSHIFT],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_RSHIFT long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_RSHIFT],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_BOOLAND",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_BOOLAND],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_BOOLAND long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_BOOLAND],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_BOOLOR",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_BOOLOR],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_BOOLOR long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_BOOLOR],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_NUMEQUAL",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NUMEQUAL],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_NUMEQUAL long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NUMEQUAL],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_NUMEQUALVERIFY",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NUMEQUALVERIFY],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_NUMEQUALVERIFY long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NUMEQUALVERIFY],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_NUMNOTEQUAL",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NUMNOTEQUAL],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_NUMNOTEQUAL long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NUMNOTEQUAL],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_LESSTHAN",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_LESSTHAN],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_LESSTHAN long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_LESSTHAN],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_GREATERTHAN",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_GREATERTHAN],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_GREATERTHAN long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_GREATERTHAN],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_LESSTHANOREQUAL",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_LESSTHANOREQUAL],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_LESSTHANOREQUAL long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_LESSTHANOREQUAL],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_GREATERTHANOREQUAL",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_GREATERTHANOREQUAL],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_GREATERTHANOREQUAL long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_GREATERTHANOREQUAL],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_MIN",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_MIN],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_MIN long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_MIN],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_MAX",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_MAX],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_MAX long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_MAX],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_WITHIN",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_WITHIN],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_WITHIN long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_WITHIN],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_RIPEMD160",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_RIPEMD160],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_RIPEMD160 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_RIPEMD160],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_SHA1",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_SHA1],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_SHA1 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_SHA1],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_SHA256",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_SHA256],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_SHA256 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_SHA256],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_HASH160",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_HASH160],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_HASH160 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_HASH160],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_HASH256",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_HASH256],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_HASH256 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_HASH256],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_CODESAPERATOR",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_CODESEPARATOR],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_CODESEPARATOR long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_CODESEPARATOR],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_CHECKSIG",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_CHECKSIG],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_CHECKSIG long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_CHECKSIG],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_CHECKSIGVERIFY",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_CHECKSIGVERIFY],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_CHECKSIGVERIFY long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_CHECKSIGVERIFY],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_CHECKMULTISIG",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_CHECKMULTISIG],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_CHECKMULTISIG long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_CHECKMULTISIG],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_CHECKMULTISIGVERIFY",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_CHECKMULTISIGVERIFY],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_CHECKMULTISIGVERIFY long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_CHECKMULTISIGVERIFY],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_NOP1",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOP1],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_NOP1 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOP1],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_NOP2",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOP2],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_NOP2 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOP2],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_NOP3",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOP3],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_NOP3 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOP3],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_NOP4",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOP4],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_NOP4 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOP4],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_NOP5",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOP5],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_NOP5 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOP5],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_NOP6",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOP6],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_NOP6 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOP6],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_NOP7",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOP7],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_NOP7 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOP7],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_NOP8",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOP8],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_NOP8 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOP8],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_NOP9",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOP9],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_NOP9 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOP9],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_NOP10",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOP10],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_NOP10 long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_NOP10],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_PUBKEYHASH",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_PUBKEYHASH],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_PUBKEYHASH long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_PUBKEYHASH],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_PUBKEY",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_PUBKEY],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_PUBKEY long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_PUBKEY],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
{
name: "OP_INVALIDOPCODE",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_INVALIDOPCODE],
data: nil,
},
expectedErr: nil,
},
{
name: "OP_INVALIDOPCODE long",
pop: &parsedOpcode{
opcode: opcodemapPreinit[OP_INVALIDOPCODE],
data: make([]byte, 1),
},
expectedErr: ErrStackInvalidOpcode,
},
}
func TestUnparsingInvalidOpcodes(t *testing.T) {
for _, test := range popTests {
_, err := test.pop.bytes()
if err != test.expectedErr {
t.Errorf("Parsed Opcode test '%s' failed", test.name)
t.Error(err, test.expectedErr)
}
}
}
// parse hex string into a []byte.
func parseHex(tok string) ([]byte, error) {
if !strings.HasPrefix(tok, "0x") {
return nil, errors.New("not a hex number")
}
return hex.DecodeString(tok[2:])
}
// ParseShortForm parses a string as as used in the bitcoind reference tests
// into the script it came from.
func ParseShortForm(script string) ([]byte, error) {
ops := make(map[string]*opcode)
// the format used for these tests is pretty simple if ad-hoc:
// - opcodes other than the push opcodes and unknown are present as
// either OP_NAME or just NAME
// - plain numbers are made into push operations
// - numbers beginning with 0x are inserted into the []byte as-is (so
// 0x14 is OP_DATA_20)
// - single quoted strings are pushed as data.
// - anything else is an error.
for _, op := range opcodemap {
if op.value < OP_NOP && op.value != OP_RESERVED {
continue
}
if strings.Contains(op.name, "OP_UNKNOWN") {
continue
}
ops[op.name] = op
ops[strings.TrimPrefix(op.name, "OP_")] = op
}
// do once, build map.
// Split only does one separator so convert all \n and tab into space.
script = strings.Replace(script, "\n", " ", -1)
script = strings.Replace(script, "\t", " ", -1)
tokens := strings.Split(script, " ")
builder := NewScriptBuilder()
for _, tok := range tokens {
if len(tok) == 0 {
continue
}
// if parses as a plain number
if num, err := strconv.ParseInt(tok, 10, 64); err == nil {
builder.AddInt64(num)
continue
} else if bts, err := parseHex(tok); err == nil {
// naughty...
builder.script = append(builder.script, bts...)
} else if len(tok) >= 2 &&
tok[0] == '\'' && tok[len(tok)-1] == '\'' {
builder.AddFullData([]byte(tok[1 : len(tok)-1]))
} else if opcode, ok := ops[tok]; ok {
builder.AddOp(opcode.value)
} else {
return nil, fmt.Errorf("bad token \"%s\"", tok)
}
}
return builder.Script()
}
// createSpendTx generates a basic spending transaction given the passed
// signature and public key scripts.
func createSpendingTx(sigScript, pkScript []byte) (*wire.MsgTx, error) {
coinbaseTx := wire.NewMsgTx()
outPoint := wire.NewOutPoint(&wire.ShaHash{}, ^uint32(0))
txIn := wire.NewTxIn(outPoint, []byte{OP_0, OP_0})
txOut := wire.NewTxOut(0, pkScript)
coinbaseTx.AddTxIn(txIn)
coinbaseTx.AddTxOut(txOut)
spendingTx := wire.NewMsgTx()
coinbaseTxSha, err := coinbaseTx.TxSha()
if err != nil {
return nil, err
}
outPoint = wire.NewOutPoint(&coinbaseTxSha, 0)
txIn = wire.NewTxIn(outPoint, sigScript)
txOut = wire.NewTxOut(0, nil)
spendingTx.AddTxIn(txIn)
spendingTx.AddTxOut(txOut)
return spendingTx, nil
}
func TestBitcoindInvalidTests(t *testing.T) {
file, err := ioutil.ReadFile("data/script_invalid.json")
if err != nil {
t.Errorf("TestBitcoindInvalidTests: %v\n", err)
return
}
var tests [][]string
err = json.Unmarshal(file, &tests)
if err != nil {
t.Errorf("TestBitcoindInvalidTests couldn't Unmarshal: %v",
err)
return
}
for x, test := range tests {
// Skip comments
if len(test) == 1 {
continue
}
name, err := testName(test)
if err != nil {
t.Errorf("TestBitcoindInvalidTests: invalid test #%d",
x)
continue
}
scriptSig, err := ParseShortForm(test[0])
if err != nil {
t.Errorf("%s: can't parse scriptSig; %v", name, err)
continue
}
scriptPubKey, err := ParseShortForm(test[1])
if err != nil {
t.Errorf("%s: can't parse scriptPubkey; %v", name, err)
continue
}
flags, err := parseScriptFlags(test[2])
if err != nil {
t.Errorf("%s: %v", name, err)
continue
}
tx, err := createSpendingTx(scriptSig, scriptPubKey)
if err != nil {
t.Errorf("createSpendingTx failed on test %s: %v", name, err)
continue
}
s, err := NewScript(scriptSig, scriptPubKey, 0, tx, flags)
if err == nil {
if err := s.Execute(); err == nil {
t.Errorf("%s test succeeded when it "+
"should have failed\n", name)
}
continue
}
}
}
func TestBitcoindValidTests(t *testing.T) {
file, err := ioutil.ReadFile("data/script_valid.json")
if err != nil {
t.Errorf("TestBitcoinValidTests: %v\n", err)
return
}
var tests [][]string
err = json.Unmarshal(file, &tests)
if err != nil {
t.Errorf("TestBitcoindValidTests couldn't Unmarshal: %v",
err)
return
}
for x, test := range tests {
// Skip comments
if len(test) == 1 {
continue
}
name, err := testName(test)
if err != nil {
t.Errorf("TestBitcoindValidTests: invalid test #%d",
x)
continue
}
scriptSig, err := ParseShortForm(test[0])
if err != nil {
t.Errorf("%s: can't parse scriptSig; %v", name, err)
continue
}
scriptPubKey, err := ParseShortForm(test[1])
if err != nil {
t.Errorf("%s: can't parse scriptPubkey; %v", name, err)
continue
}
flags, err := parseScriptFlags(test[2])
if err != nil {
t.Errorf("%s: %v", name, err)
continue
}
tx, err := createSpendingTx(scriptSig, scriptPubKey)
if err != nil {
t.Errorf("createSpendingTx failed on test %s: %v", name, err)
continue
}
s, err := NewScript(scriptSig, scriptPubKey, 0, tx, flags)
if err != nil {
t.Errorf("%s failed to create script: %v", name, err)
continue
}
err = s.Execute()
if err != nil {
t.Errorf("%s failed to execute: %v", name, err)
continue
}
}
}
func TestBitcoindTxValidTests(t *testing.T) {
file, err := ioutil.ReadFile("data/tx_valid.json")
if err != nil {
t.Errorf("TestBitcoindInvalidTests: %v\n", err)
return
}
var tests [][]interface{}
err = json.Unmarshal(file, &tests)
if err != nil {
t.Errorf("TestBitcoindInvalidTests couldn't Unmarshal: %v\n",
err)
return
}
// form is either:
// ["this is a comment "]
// or:
// [[[previous hash, previous index, previous scriptPubKey]...,]
// serializedTransaction, verifyFlags]
testloop:
for i, test := range tests {
inputs, ok := test[0].([]interface{})
if !ok {
continue
}
if len(test) != 3 {
t.Errorf("bad test (bad length) %d: %v", i, test)
continue
}
serializedhex, ok := test[1].(string)
if !ok {
t.Errorf("bad test (arg 2 not string) %d: %v", i, test)
continue
}
serializedTx, err := hex.DecodeString(serializedhex)
if err != nil {
t.Errorf("bad test (arg 2 not hex %v) %d: %v", err, i,
test)
continue
}
tx, err := btcutil.NewTxFromBytes(serializedTx)
if err != nil {
t.Errorf("bad test (arg 2 not msgtx %v) %d: %v", err,
i, test)
continue
}
verifyFlags, ok := test[2].(string)
if !ok {
t.Errorf("bad test (arg 3 not string) %d: %v", i, test)
continue
}
flags, err := parseScriptFlags(verifyFlags)
if err != nil {
t.Errorf("bad test %d: %v", i, err)
continue
}
prevOuts := make(map[wire.OutPoint][]byte)
for j, iinput := range inputs {
input, ok := iinput.([]interface{})
if !ok {
t.Errorf("bad test (%dth input not array)"+
"%d: %v", j, i, test)
continue
}
if len(input) != 3 {
t.Errorf("bad test (%dth input wrong length)"+
"%d: %v", j, i, test)
continue
}
previoustx, ok := input[0].(string)
if !ok {
t.Errorf("bad test (%dth input sha not string)"+
"%d: %v", j, i, test)
continue
}
prevhash, err := wire.NewShaHashFromStr(previoustx)
if err != nil {
t.Errorf("bad test (%dth input sha not sha %v)"+
"%d: %v", j, err, i, test)
continue
}
idxf, ok := input[1].(float64)
if !ok {
t.Errorf("bad test (%dth input idx not number)"+
"%d: %v", j, i, test)
continue
}
idx := uint32(idxf) // (floor(idxf) == idxf?)
oscript, ok := input[2].(string)
if !ok {
t.Errorf("bad test (%dth input script not "+
"string) %d: %v", j, i, test)
continue
}
script, err := ParseShortForm(oscript)
if err != nil {
t.Errorf("bad test (%dth input script doesn't "+
"parse %v) %d: %v", j, err, i, test)
continue
}
prevOuts[*wire.NewOutPoint(prevhash, idx)] = script
}
for k, txin := range tx.MsgTx().TxIn {
pkScript, ok := prevOuts[txin.PreviousOutPoint]
if !ok {
t.Errorf("bad test (missing %dth input) %d:%v",
k, i, test)
continue testloop
}
s, err := NewScript(txin.SignatureScript, pkScript, k,
tx.MsgTx(), flags)
if err != nil {
t.Errorf("test (%d:%v:%d) failed to create "+
"script: %v", i, test, k, err)
continue
}
err = s.Execute()
if err != nil {
t.Errorf("test (%d:%v:%d) failed to execute: "+
"%v", i, test, k, err)
continue
}
}
}
}
func TestBitcoindTxInvalidTests(t *testing.T) {
file, err := ioutil.ReadFile("data/tx_invalid.json")
if err != nil {
t.Errorf("TestBitcoindInvalidTests: %v\n", err)
return
}
var tests [][]interface{}
err = json.Unmarshal(file, &tests)
if err != nil {
t.Errorf("TestBitcoindInvalidTests couldn't Unmarshal: %v\n",
err)
return
}
// form is either:
// ["this is a comment "]
// or:
// [[[previous hash, previous index, previous scriptPubKey]...,]
// serializedTransaction, verifyFlags]
testloop:
for i, test := range tests {
inputs, ok := test[0].([]interface{})
if !ok {
continue
}
if len(test) != 3 {
t.Errorf("bad test (bad lenggh) %d: %v", i, test)
continue
}
serializedhex, ok := test[1].(string)
if !ok {
t.Errorf("bad test (arg 2 not string) %d: %v", i, test)
continue
}
serializedTx, err := hex.DecodeString(serializedhex)
if err != nil {
t.Errorf("bad test (arg 2 not hex %v) %d: %v", err, i,
test)
continue
}
tx, err := btcutil.NewTxFromBytes(serializedTx)
if err != nil {
t.Errorf("bad test (arg 2 not msgtx %v) %d: %v", err,
i, test)
continue
}
verifyFlags, ok := test[2].(string)
if !ok {
t.Errorf("bad test (arg 3 not string) %d: %v", i, test)
continue
}
flags, err := parseScriptFlags(verifyFlags)
if err != nil {
t.Errorf("bad test %d: %v", i, err)
continue
}
prevOuts := make(map[wire.OutPoint][]byte)
for j, iinput := range inputs {
input, ok := iinput.([]interface{})
if !ok {
t.Errorf("bad test (%dth input not array)"+
"%d: %v", j, i, test)
continue testloop
}
if len(input) != 3 {
t.Errorf("bad test (%dth input wrong length)"+
"%d: %v", j, i, test)
continue testloop
}
previoustx, ok := input[0].(string)
if !ok {
t.Errorf("bad test (%dth input sha not string)"+
"%d: %v", j, i, test)
continue testloop
}
prevhash, err := wire.NewShaHashFromStr(previoustx)
if err != nil {
t.Errorf("bad test (%dth input sha not sha %v)"+
"%d: %v", j, err, i, test)
continue testloop
}
idxf, ok := input[1].(float64)
if !ok {
t.Errorf("bad test (%dth input idx not number)"+
"%d: %v", j, i, test)
continue testloop
}
idx := uint32(idxf) // (floor(idxf) == idxf?)
oscript, ok := input[2].(string)
if !ok {
t.Errorf("bad test (%dth input script not "+
"string) %d: %v", j, i, test)
continue testloop
}
script, err := ParseShortForm(oscript)
if err != nil {
t.Errorf("bad test (%dth input script doesn't "+
"parse %v) %d: %v", j, err, i, test)
continue testloop
}
prevOuts[*wire.NewOutPoint(prevhash, idx)] = script
}
for k, txin := range tx.MsgTx().TxIn {
pkScript, ok := prevOuts[txin.PreviousOutPoint]
if !ok {
t.Errorf("bad test (missing %dth input) %d:%v",
k, i, test)
continue testloop
}
// These are meant to fail, so as soon as the first
// input fails the transaction has failed. (some of the
// test txns have good inputs, too..
s, err := NewScript(txin.SignatureScript, pkScript, k,
tx.MsgTx(), flags)
if err != nil {
continue testloop
}
err = s.Execute()
if err != nil {
continue testloop
}
}
t.Errorf("test (%d:%v) succeeded when should fail",
i, test)
}
}
func parseScriptFlags(flagStr string) (ScriptFlags, error) {
var flags ScriptFlags
sFlags := strings.Split(flagStr, ",")
for _, flag := range sFlags {
switch flag {
case "DERSIG":
flags |= ScriptVerifyDERSignatures
case "DISCOURAGE_UPGRADABLE_NOPS":
flags |= ScriptDiscourageUpgradableNops
case "", "NONE":
// Nothing.
case "NULLDUMMY":
flags |= ScriptStrictMultiSig
case "P2SH":
flags |= ScriptBip16
case "SIGPUSHONLY":
flags |= ScriptVerifySigPushOnly
case "STRICTENC":
flags |= ScriptVerifyStrictEncoding
default:
return flags, fmt.Errorf("invalid flag: %s", flag)
}
}
return flags, nil
}
func testName(test []string) (string, error) {
var name string
if len(test) < 3 || len(test) > 4 {
return name, fmt.Errorf("invalid test length %d", len(test))
}
if len(test) == 4 {
name = fmt.Sprintf("test (%s)", test[3])
} else {
name = fmt.Sprintf("test ([%s, %s, %s])", test[0], test[1],
test[2])
}
return name, nil
}
Reference in a new issue View git blame Copy permalink