vendor/github.com/btcsuite/btcd/txscript/script_test.go

   1 // Copyright (c) 2013-2017 The btcsuite developers
   2 // Use of this source code is governed by an ISC
   3 // license that can be found in the LICENSE file.
   4
   5 package txscript
   6
   7 import (
   8         "bytes"
   9         "reflect"
  10         "testing"
  11
  12         "github.com/btcsuite/btcd/wire"
  13 )
  14
  15 // TestParseOpcode tests for opcode parsing with bad data templates.
  16 func TestParseOpcode(t *testing.T) {
  17         // Deep copy the array and make one of the opcodes invalid by setting it
  18         // to the wrong length.
  19         fakeArray := opcodeArray
  20         fakeArray[OP_PUSHDATA4] = opcode{value: OP_PUSHDATA4,
  21                 name: "OP_PUSHDATA4", length: -8, opfunc: opcodePushData}
  22
  23         // This script would be fine if -8 was a valid length.
  24         _, err := parseScriptTemplate([]byte{OP_PUSHDATA4, 0x1, 0x00, 0x00,
  25                 0x00, 0x00, 0x00, 0x00, 0x00}, &fakeArray)
  26         if err == nil {
  27                 t.Errorf("no error with dodgy opcode array!")
  28         }
  29 }
  30
  31 // TestUnparsingInvalidOpcodes tests for errors when unparsing invalid parsed
  32 // opcodes.
  33 func TestUnparsingInvalidOpcodes(t *testing.T) {
  34         tests := []struct {
  35                 name        string
  36                 pop         *parsedOpcode
  37                 expectedErr error
  38         }{
  39                 {
  40                         name: "OP_FALSE",
  41                         pop: &parsedOpcode{
  42                                 opcode: &opcodeArray[OP_FALSE],
  43                                 data:   nil,
  44                         },
  45                         expectedErr: nil,
  46                 },
  47                 {
  48                         name: "OP_FALSE long",
  49                         pop: &parsedOpcode{
  50                                 opcode: &opcodeArray[OP_FALSE],
  51                                 data:   make([]byte, 1),
  52                         },
  53                         expectedErr: scriptError(ErrInternal, ""),
  54                 },
  55                 {
  56                         name: "OP_DATA_1 short",
  57                         pop: &parsedOpcode{
  58                                 opcode: &opcodeArray[OP_DATA_1],
  59                                 data:   nil,
  60                         },
  61                         expectedErr: scriptError(ErrInternal, ""),
  62                 },
  63                 {
  64                         name: "OP_DATA_1",
  65                         pop: &parsedOpcode{
  66                                 opcode: &opcodeArray[OP_DATA_1],
  67                                 data:   make([]byte, 1),
  68                         },
  69                         expectedErr: nil,
  70                 },
  71                 {
  72                         name: "OP_DATA_1 long",
  73                         pop: &parsedOpcode{
  74                                 opcode: &opcodeArray[OP_DATA_1],
  75                                 data:   make([]byte, 2),
  76                         },
  77                         expectedErr: scriptError(ErrInternal, ""),
  78                 },
  79                 {
  80                         name: "OP_DATA_2 short",
  81                         pop: &parsedOpcode{
  82                                 opcode: &opcodeArray[OP_DATA_2],
  83                                 data:   make([]byte, 1),
  84                         },
  85                         expectedErr: scriptError(ErrInternal, ""),
  86                 },
  87                 {
  88                         name: "OP_DATA_2",
  89                         pop: &parsedOpcode{
  90                                 opcode: &opcodeArray[OP_DATA_2],
  91                                 data:   make([]byte, 2),
  92                         },
  93                         expectedErr: nil,
  94                 },
  95                 {
  96                         name: "OP_DATA_2 long",
  97                         pop: &parsedOpcode{
  98                                 opcode: &opcodeArray[OP_DATA_2],
  99                                 data:   make([]byte, 3),
 100                         },
 101                         expectedErr: scriptError(ErrInternal, ""),
 102                 },
 103                 {
 104                         name: "OP_DATA_3 short",
 105                         pop: &parsedOpcode{
 106                                 opcode: &opcodeArray[OP_DATA_3],
 107                                 data:   make([]byte, 2),
 108                         },
 109                         expectedErr: scriptError(ErrInternal, ""),
 110                 },
 111                 {
 112                         name: "OP_DATA_3",
 113                         pop: &parsedOpcode{
 114                                 opcode: &opcodeArray[OP_DATA_3],
 115                                 data:   make([]byte, 3),
 116                         },
 117                         expectedErr: nil,
 118                 },
 119                 {
 120                         name: "OP_DATA_3 long",
 121                         pop: &parsedOpcode{
 122                                 opcode: &opcodeArray[OP_DATA_3],
 123                                 data:   make([]byte, 4),
 124                         },
 125                         expectedErr: scriptError(ErrInternal, ""),
 126                 },
 127                 {
 128                         name: "OP_DATA_4 short",
 129                         pop: &parsedOpcode{
 130                                 opcode: &opcodeArray[OP_DATA_4],
 131                                 data:   make([]byte, 3),
 132                         },
 133                         expectedErr: scriptError(ErrInternal, ""),
 134                 },
 135                 {
 136                         name: "OP_DATA_4",
 137                         pop: &parsedOpcode{
 138                                 opcode: &opcodeArray[OP_DATA_4],
 139                                 data:   make([]byte, 4),
 140                         },
 141                         expectedErr: nil,
 142                 },
 143                 {
 144                         name: "OP_DATA_4 long",
 145                         pop: &parsedOpcode{
 146                                 opcode: &opcodeArray[OP_DATA_4],
 147                                 data:   make([]byte, 5),
 148                         },
 149                         expectedErr: scriptError(ErrInternal, ""),
 150                 },
 151                 {
 152                         name: "OP_DATA_5 short",
 153                         pop: &parsedOpcode{
 154                                 opcode: &opcodeArray[OP_DATA_5],
 155                                 data:   make([]byte, 4),
 156                         },
 157                         expectedErr: scriptError(ErrInternal, ""),
 158                 },
 159                 {
 160                         name: "OP_DATA_5",
 161                         pop: &parsedOpcode{
 162                                 opcode: &opcodeArray[OP_DATA_5],
 163                                 data:   make([]byte, 5),
 164                         },
 165                         expectedErr: nil,
 166                 },
 167                 {
 168                         name: "OP_DATA_5 long",
 169                         pop: &parsedOpcode{
 170                                 opcode: &opcodeArray[OP_DATA_5],
 171                                 data:   make([]byte, 6),
 172                         },
 173                         expectedErr: scriptError(ErrInternal, ""),
 174                 },
 175                 {
 176                         name: "OP_DATA_6 short",
 177                         pop: &parsedOpcode{
 178                                 opcode: &opcodeArray[OP_DATA_6],
 179                                 data:   make([]byte, 5),
 180                         },
 181                         expectedErr: scriptError(ErrInternal, ""),
 182                 },
 183                 {
 184                         name: "OP_DATA_6",
 185                         pop: &parsedOpcode{
 186                                 opcode: &opcodeArray[OP_DATA_6],
 187                                 data:   make([]byte, 6),
 188                         },
 189                         expectedErr: nil,
 190                 },
 191                 {
 192                         name: "OP_DATA_6 long",
 193                         pop: &parsedOpcode{
 194                                 opcode: &opcodeArray[OP_DATA_6],
 195                                 data:   make([]byte, 7),
 196                         },
 197                         expectedErr: scriptError(ErrInternal, ""),
 198                 },
 199                 {
 200                         name: "OP_DATA_7 short",
 201                         pop: &parsedOpcode{
 202                                 opcode: &opcodeArray[OP_DATA_7],
 203                                 data:   make([]byte, 6),
 204                         },
 205                         expectedErr: scriptError(ErrInternal, ""),
 206                 },
 207                 {
 208                         name: "OP_DATA_7",
 209                         pop: &parsedOpcode{
 210                                 opcode: &opcodeArray[OP_DATA_7],
 211                                 data:   make([]byte, 7),
 212                         },
 213                         expectedErr: nil,
 214                 },
 215                 {
 216                         name: "OP_DATA_7 long",
 217                         pop: &parsedOpcode{
 218                                 opcode: &opcodeArray[OP_DATA_7],
 219                                 data:   make([]byte, 8),
 220                         },
 221                         expectedErr: scriptError(ErrInternal, ""),
 222                 },
 223                 {
 224                         name: "OP_DATA_8 short",
 225                         pop: &parsedOpcode{
 226                                 opcode: &opcodeArray[OP_DATA_8],
 227                                 data:   make([]byte, 7),
 228                         },
 229                         expectedErr: scriptError(ErrInternal, ""),
 230                 },
 231                 {
 232                         name: "OP_DATA_8",
 233                         pop: &parsedOpcode{
 234                                 opcode: &opcodeArray[OP_DATA_8],
 235                                 data:   make([]byte, 8),
 236                         },
 237                         expectedErr: nil,
 238                 },
 239                 {
 240                         name: "OP_DATA_8 long",
 241                         pop: &parsedOpcode{
 242                                 opcode: &opcodeArray[OP_DATA_8],
 243                                 data:   make([]byte, 9),
 244                         },
 245                         expectedErr: scriptError(ErrInternal, ""),
 246                 },
 247                 {
 248                         name: "OP_DATA_9 short",
 249                         pop: &parsedOpcode{
 250                                 opcode: &opcodeArray[OP_DATA_9],
 251                                 data:   make([]byte, 8),
 252                         },
 253                         expectedErr: scriptError(ErrInternal, ""),
 254                 },
 255                 {
 256                         name: "OP_DATA_9",
 257                         pop: &parsedOpcode{
 258                                 opcode: &opcodeArray[OP_DATA_9],
 259                                 data:   make([]byte, 9),
 260                         },
 261                         expectedErr: nil,
 262                 },
 263                 {
 264                         name: "OP_DATA_9 long",
 265                         pop: &parsedOpcode{
 266                                 opcode: &opcodeArray[OP_DATA_9],
 267                                 data:   make([]byte, 10),
 268                         },
 269                         expectedErr: scriptError(ErrInternal, ""),
 270                 },
 271                 {
 272                         name: "OP_DATA_10 short",
 273                         pop: &parsedOpcode{
 274                                 opcode: &opcodeArray[OP_DATA_10],
 275                                 data:   make([]byte, 9),
 276                         },
 277                         expectedErr: scriptError(ErrInternal, ""),
 278                 },
 279                 {
 280                         name: "OP_DATA_10",
 281                         pop: &parsedOpcode{
 282                                 opcode: &opcodeArray[OP_DATA_10],
 283                                 data:   make([]byte, 10),
 284                         },
 285                         expectedErr: nil,
 286                 },
 287                 {
 288                         name: "OP_DATA_10 long",
 289                         pop: &parsedOpcode{
 290                                 opcode: &opcodeArray[OP_DATA_10],
 291                                 data:   make([]byte, 11),
 292                         },
 293                         expectedErr: scriptError(ErrInternal, ""),
 294                 },
 295                 {
 296                         name: "OP_DATA_11 short",
 297                         pop: &parsedOpcode{
 298                                 opcode: &opcodeArray[OP_DATA_11],
 299                                 data:   make([]byte, 10),
 300                         },
 301                         expectedErr: scriptError(ErrInternal, ""),
 302                 },
 303                 {
 304                         name: "OP_DATA_11",
 305                         pop: &parsedOpcode{
 306                                 opcode: &opcodeArray[OP_DATA_11],
 307                                 data:   make([]byte, 11),
 308                         },
 309                         expectedErr: nil,
 310                 },
 311                 {
 312                         name: "OP_DATA_11 long",
 313                         pop: &parsedOpcode{
 314                                 opcode: &opcodeArray[OP_DATA_11],
 315                                 data:   make([]byte, 12),
 316                         },
 317                         expectedErr: scriptError(ErrInternal, ""),
 318                 },
 319                 {
 320                         name: "OP_DATA_12 short",
 321                         pop: &parsedOpcode{
 322                                 opcode: &opcodeArray[OP_DATA_12],
 323                                 data:   make([]byte, 11),
 324                         },
 325                         expectedErr: scriptError(ErrInternal, ""),
 326                 },
 327                 {
 328                         name: "OP_DATA_12",
 329                         pop: &parsedOpcode{
 330                                 opcode: &opcodeArray[OP_DATA_12],
 331                                 data:   make([]byte, 12),
 332                         },
 333                         expectedErr: nil,
 334                 },
 335                 {
 336                         name: "OP_DATA_12 long",
 337                         pop: &parsedOpcode{
 338                                 opcode: &opcodeArray[OP_DATA_12],
 339                                 data:   make([]byte, 13),
 340                         },
 341                         expectedErr: scriptError(ErrInternal, ""),
 342                 },
 343                 {
 344                         name: "OP_DATA_13 short",
 345                         pop: &parsedOpcode{
 346                                 opcode: &opcodeArray[OP_DATA_13],
 347                                 data:   make([]byte, 12),
 348                         },
 349                         expectedErr: scriptError(ErrInternal, ""),
 350                 },
 351                 {
 352                         name: "OP_DATA_13",
 353                         pop: &parsedOpcode{
 354                                 opcode: &opcodeArray[OP_DATA_13],
 355                                 data:   make([]byte, 13),
 356                         },
 357                         expectedErr: nil,
 358                 },
 359                 {
 360                         name: "OP_DATA_13 long",
 361                         pop: &parsedOpcode{
 362                                 opcode: &opcodeArray[OP_DATA_13],
 363                                 data:   make([]byte, 14),
 364                         },
 365                         expectedErr: scriptError(ErrInternal, ""),
 366                 },
 367                 {
 368                         name: "OP_DATA_14 short",
 369                         pop: &parsedOpcode{
 370                                 opcode: &opcodeArray[OP_DATA_14],
 371                                 data:   make([]byte, 13),
 372                         },
 373                         expectedErr: scriptError(ErrInternal, ""),
 374                 },
 375                 {
 376                         name: "OP_DATA_14",
 377                         pop: &parsedOpcode{
 378                                 opcode: &opcodeArray[OP_DATA_14],
 379                                 data:   make([]byte, 14),
 380                         },
 381                         expectedErr: nil,
 382                 },
 383                 {
 384                         name: "OP_DATA_14 long",
 385                         pop: &parsedOpcode{
 386                                 opcode: &opcodeArray[OP_DATA_14],
 387                                 data:   make([]byte, 15),
 388                         },
 389                         expectedErr: scriptError(ErrInternal, ""),
 390                 },
 391                 {
 392                         name: "OP_DATA_15 short",
 393                         pop: &parsedOpcode{
 394                                 opcode: &opcodeArray[OP_DATA_15],
 395                                 data:   make([]byte, 14),
 396                         },
 397                         expectedErr: scriptError(ErrInternal, ""),
 398                 },
 399                 {
 400                         name: "OP_DATA_15",
 401                         pop: &parsedOpcode{
 402                                 opcode: &opcodeArray[OP_DATA_15],
 403                                 data:   make([]byte, 15),
 404                         },
 405                         expectedErr: nil,
 406                 },
 407                 {
 408                         name: "OP_DATA_15 long",
 409                         pop: &parsedOpcode{
 410                                 opcode: &opcodeArray[OP_DATA_15],
 411                                 data:   make([]byte, 16),
 412                         },
 413                         expectedErr: scriptError(ErrInternal, ""),
 414                 },
 415                 {
 416                         name: "OP_DATA_16 short",
 417                         pop: &parsedOpcode{
 418                                 opcode: &opcodeArray[OP_DATA_16],
 419                                 data:   make([]byte, 15),
 420                         },
 421                         expectedErr: scriptError(ErrInternal, ""),
 422                 },
 423                 {
 424                         name: "OP_DATA_16",
 425                         pop: &parsedOpcode{
 426                                 opcode: &opcodeArray[OP_DATA_16],
 427                                 data:   make([]byte, 16),
 428                         },
 429                         expectedErr: nil,
 430                 },
 431                 {
 432                         name: "OP_DATA_16 long",
 433                         pop: &parsedOpcode{
 434                                 opcode: &opcodeArray[OP_DATA_16],
 435                                 data:   make([]byte, 17),
 436                         },
 437                         expectedErr: scriptError(ErrInternal, ""),
 438                 },
 439                 {
 440                         name: "OP_DATA_17 short",
 441                         pop: &parsedOpcode{
 442                                 opcode: &opcodeArray[OP_DATA_17],
 443                                 data:   make([]byte, 16),
 444                         },
 445                         expectedErr: scriptError(ErrInternal, ""),
 446                 },
 447                 {
 448                         name: "OP_DATA_17",
 449                         pop: &parsedOpcode{
 450                                 opcode: &opcodeArray[OP_DATA_17],
 451                                 data:   make([]byte, 17),
 452                         },
 453                         expectedErr: nil,
 454                 },
 455                 {
 456                         name: "OP_DATA_17 long",
 457                         pop: &parsedOpcode{
 458                                 opcode: &opcodeArray[OP_DATA_17],
 459                                 data:   make([]byte, 18),
 460                         },
 461                         expectedErr: scriptError(ErrInternal, ""),
 462                 },
 463                 {
 464                         name: "OP_DATA_18 short",
 465                         pop: &parsedOpcode{
 466                                 opcode: &opcodeArray[OP_DATA_18],
 467                                 data:   make([]byte, 17),
 468                         },
 469                         expectedErr: scriptError(ErrInternal, ""),
 470                 },
 471                 {
 472                         name: "OP_DATA_18",
 473                         pop: &parsedOpcode{
 474                                 opcode: &opcodeArray[OP_DATA_18],
 475                                 data:   make([]byte, 18),
 476                         },
 477                         expectedErr: nil,
 478                 },
 479                 {
 480                         name: "OP_DATA_18 long",
 481                         pop: &parsedOpcode{
 482                                 opcode: &opcodeArray[OP_DATA_18],
 483                                 data:   make([]byte, 19),
 484                         },
 485                         expectedErr: scriptError(ErrInternal, ""),
 486                 },
 487                 {
 488                         name: "OP_DATA_19 short",
 489                         pop: &parsedOpcode{
 490                                 opcode: &opcodeArray[OP_DATA_19],
 491                                 data:   make([]byte, 18),
 492                         },
 493                         expectedErr: scriptError(ErrInternal, ""),
 494                 },
 495                 {
 496                         name: "OP_DATA_19",
 497                         pop: &parsedOpcode{
 498                                 opcode: &opcodeArray[OP_DATA_19],
 499                                 data:   make([]byte, 19),
 500                         },
 501                         expectedErr: nil,
 502                 },
 503                 {
 504                         name: "OP_DATA_19 long",
 505                         pop: &parsedOpcode{
 506                                 opcode: &opcodeArray[OP_DATA_19],
 507                                 data:   make([]byte, 20),
 508                         },
 509                         expectedErr: scriptError(ErrInternal, ""),
 510                 },
 511                 {
 512                         name: "OP_DATA_20 short",
 513                         pop: &parsedOpcode{
 514                                 opcode: &opcodeArray[OP_DATA_20],
 515                                 data:   make([]byte, 19),
 516                         },
 517                         expectedErr: scriptError(ErrInternal, ""),
 518                 },
 519                 {
 520                         name: "OP_DATA_20",
 521                         pop: &parsedOpcode{
 522                                 opcode: &opcodeArray[OP_DATA_20],
 523                                 data:   make([]byte, 20),
 524                         },
 525                         expectedErr: nil,
 526                 },
 527                 {
 528                         name: "OP_DATA_20 long",
 529                         pop: &parsedOpcode{
 530                                 opcode: &opcodeArray[OP_DATA_20],
 531                                 data:   make([]byte, 21),
 532                         },
 533                         expectedErr: scriptError(ErrInternal, ""),
 534                 },
 535                 {
 536                         name: "OP_DATA_21 short",
 537                         pop: &parsedOpcode{
 538                                 opcode: &opcodeArray[OP_DATA_21],
 539                                 data:   make([]byte, 20),
 540                         },
 541                         expectedErr: scriptError(ErrInternal, ""),
 542                 },
 543                 {
 544                         name: "OP_DATA_21",
 545                         pop: &parsedOpcode{
 546                                 opcode: &opcodeArray[OP_DATA_21],
 547                                 data:   make([]byte, 21),
 548                         },
 549                         expectedErr: nil,
 550                 },
 551                 {
 552                         name: "OP_DATA_21 long",
 553                         pop: &parsedOpcode{
 554                                 opcode: &opcodeArray[OP_DATA_21],
 555                                 data:   make([]byte, 22),
 556                         },
 557                         expectedErr: scriptError(ErrInternal, ""),
 558                 },
 559                 {
 560                         name: "OP_DATA_22 short",
 561                         pop: &parsedOpcode{
 562                                 opcode: &opcodeArray[OP_DATA_22],
 563                                 data:   make([]byte, 21),
 564                         },
 565                         expectedErr: scriptError(ErrInternal, ""),
 566                 },
 567                 {
 568                         name: "OP_DATA_22",
 569                         pop: &parsedOpcode{
 570                                 opcode: &opcodeArray[OP_DATA_22],
 571                                 data:   make([]byte, 22),
 572                         },
 573                         expectedErr: nil,
 574                 },
 575                 {
 576                         name: "OP_DATA_22 long",
 577                         pop: &parsedOpcode{
 578                                 opcode: &opcodeArray[OP_DATA_22],
 579                                 data:   make([]byte, 23),
 580                         },
 581                         expectedErr: scriptError(ErrInternal, ""),
 582                 },
 583                 {
 584                         name: "OP_DATA_23 short",
 585                         pop: &parsedOpcode{
 586                                 opcode: &opcodeArray[OP_DATA_23],
 587                                 data:   make([]byte, 22),
 588                         },
 589                         expectedErr: scriptError(ErrInternal, ""),
 590                 },
 591                 {
 592                         name: "OP_DATA_23",
 593                         pop: &parsedOpcode{
 594                                 opcode: &opcodeArray[OP_DATA_23],
 595                                 data:   make([]byte, 23),
 596                         },
 597                         expectedErr: nil,
 598                 },
 599                 {
 600                         name: "OP_DATA_23 long",
 601                         pop: &parsedOpcode{
 602                                 opcode: &opcodeArray[OP_DATA_23],
 603                                 data:   make([]byte, 24),
 604                         },
 605                         expectedErr: scriptError(ErrInternal, ""),
 606                 },
 607                 {
 608                         name: "OP_DATA_24 short",
 609                         pop: &parsedOpcode{
 610                                 opcode: &opcodeArray[OP_DATA_24],
 611                                 data:   make([]byte, 23),
 612                         },
 613                         expectedErr: scriptError(ErrInternal, ""),
 614                 },
 615                 {
 616                         name: "OP_DATA_24",
 617                         pop: &parsedOpcode{
 618                                 opcode: &opcodeArray[OP_DATA_24],
 619                                 data:   make([]byte, 24),
 620                         },
 621                         expectedErr: nil,
 622                 },
 623                 {
 624                         name: "OP_DATA_24 long",
 625                         pop: &parsedOpcode{
 626                                 opcode: &opcodeArray[OP_DATA_24],
 627                                 data:   make([]byte, 25),
 628                         },
 629                         expectedErr: scriptError(ErrInternal, ""),
 630                 },
 631                 {
 632                         name: "OP_DATA_25 short",
 633                         pop: &parsedOpcode{
 634                                 opcode: &opcodeArray[OP_DATA_25],
 635                                 data:   make([]byte, 24),
 636                         },
 637                         expectedErr: scriptError(ErrInternal, ""),
 638                 },
 639                 {
 640                         name: "OP_DATA_25",
 641                         pop: &parsedOpcode{
 642                                 opcode: &opcodeArray[OP_DATA_25],
 643                                 data:   make([]byte, 25),
 644                         },
 645                         expectedErr: nil,
 646                 },
 647                 {
 648                         name: "OP_DATA_25 long",
 649                         pop: &parsedOpcode{
 650                                 opcode: &opcodeArray[OP_DATA_25],
 651                                 data:   make([]byte, 26),
 652                         },
 653                         expectedErr: scriptError(ErrInternal, ""),
 654                 },
 655                 {
 656                         name: "OP_DATA_26 short",
 657                         pop: &parsedOpcode{
 658                                 opcode: &opcodeArray[OP_DATA_26],
 659                                 data:   make([]byte, 25),
 660                         },
 661                         expectedErr: scriptError(ErrInternal, ""),
 662                 },
 663                 {
 664                         name: "OP_DATA_26",
 665                         pop: &parsedOpcode{
 666                                 opcode: &opcodeArray[OP_DATA_26],
 667                                 data:   make([]byte, 26),
 668                         },
 669                         expectedErr: nil,
 670                 },
 671                 {
 672                         name: "OP_DATA_26 long",
 673                         pop: &parsedOpcode{
 674                                 opcode: &opcodeArray[OP_DATA_26],
 675                                 data:   make([]byte, 27),
 676                         },
 677                         expectedErr: scriptError(ErrInternal, ""),
 678                 },
 679                 {
 680                         name: "OP_DATA_27 short",
 681                         pop: &parsedOpcode{
 682                                 opcode: &opcodeArray[OP_DATA_27],
 683                                 data:   make([]byte, 26),
 684                         },
 685                         expectedErr: scriptError(ErrInternal, ""),
 686                 },
 687                 {
 688                         name: "OP_DATA_27",
 689                         pop: &parsedOpcode{
 690                                 opcode: &opcodeArray[OP_DATA_27],
 691                                 data:   make([]byte, 27),
 692                         },
 693                         expectedErr: nil,
 694                 },
 695                 {
 696                         name: "OP_DATA_27 long",
 697                         pop: &parsedOpcode{
 698                                 opcode: &opcodeArray[OP_DATA_27],
 699                                 data:   make([]byte, 28),
 700                         },
 701                         expectedErr: scriptError(ErrInternal, ""),
 702                 },
 703                 {
 704                         name: "OP_DATA_28 short",
 705                         pop: &parsedOpcode{
 706                                 opcode: &opcodeArray[OP_DATA_28],
 707                                 data:   make([]byte, 27),
 708                         },
 709                         expectedErr: scriptError(ErrInternal, ""),
 710                 },
 711                 {
 712                         name: "OP_DATA_28",
 713                         pop: &parsedOpcode{
 714                                 opcode: &opcodeArray[OP_DATA_28],
 715                                 data:   make([]byte, 28),
 716                         },
 717                         expectedErr: nil,
 718                 },
 719                 {
 720                         name: "OP_DATA_28 long",
 721                         pop: &parsedOpcode{
 722                                 opcode: &opcodeArray[OP_DATA_28],
 723                                 data:   make([]byte, 29),
 724                         },
 725                         expectedErr: scriptError(ErrInternal, ""),
 726                 },
 727                 {
 728                         name: "OP_DATA_29 short",
 729                         pop: &parsedOpcode{
 730                                 opcode: &opcodeArray[OP_DATA_29],
 731                                 data:   make([]byte, 28),
 732                         },
 733                         expectedErr: scriptError(ErrInternal, ""),
 734                 },
 735                 {
 736                         name: "OP_DATA_29",
 737                         pop: &parsedOpcode{
 738                                 opcode: &opcodeArray[OP_DATA_29],
 739                                 data:   make([]byte, 29),
 740                         },
 741                         expectedErr: nil,
 742                 },
 743                 {
 744                         name: "OP_DATA_29 long",
 745                         pop: &parsedOpcode{
 746                                 opcode: &opcodeArray[OP_DATA_29],
 747                                 data:   make([]byte, 30),
 748                         },
 749                         expectedErr: scriptError(ErrInternal, ""),
 750                 },
 751                 {
 752                         name: "OP_DATA_30 short",
 753                         pop: &parsedOpcode{
 754                                 opcode: &opcodeArray[OP_DATA_30],
 755                                 data:   make([]byte, 29),
 756                         },
 757                         expectedErr: scriptError(ErrInternal, ""),
 758                 },
 759                 {
 760                         name: "OP_DATA_30",
 761                         pop: &parsedOpcode{
 762                                 opcode: &opcodeArray[OP_DATA_30],
 763                                 data:   make([]byte, 30),
 764                         },
 765                         expectedErr: nil,
 766                 },
 767                 {
 768                         name: "OP_DATA_30 long",
 769                         pop: &parsedOpcode{
 770                                 opcode: &opcodeArray[OP_DATA_30],
 771                                 data:   make([]byte, 31),
 772                         },
 773                         expectedErr: scriptError(ErrInternal, ""),
 774                 },
 775                 {
 776                         name: "OP_DATA_31 short",
 777                         pop: &parsedOpcode{
 778                                 opcode: &opcodeArray[OP_DATA_31],
 779                                 data:   make([]byte, 30),
 780                         },
 781                         expectedErr: scriptError(ErrInternal, ""),
 782                 },
 783                 {
 784                         name: "OP_DATA_31",
 785                         pop: &parsedOpcode{
 786                                 opcode: &opcodeArray[OP_DATA_31],
 787                                 data:   make([]byte, 31),
 788                         },
 789                         expectedErr: nil,
 790                 },
 791                 {
 792                         name: "OP_DATA_31 long",
 793                         pop: &parsedOpcode{
 794                                 opcode: &opcodeArray[OP_DATA_31],
 795                                 data:   make([]byte, 32),
 796                         },
 797                         expectedErr: scriptError(ErrInternal, ""),
 798                 },
 799                 {
 800                         name: "OP_DATA_32 short",
 801                         pop: &parsedOpcode{
 802                                 opcode: &opcodeArray[OP_DATA_32],
 803                                 data:   make([]byte, 31),
 804                         },
 805                         expectedErr: scriptError(ErrInternal, ""),
 806                 },
 807                 {
 808                         name: "OP_DATA_32",
 809                         pop: &parsedOpcode{
 810                                 opcode: &opcodeArray[OP_DATA_32],
 811                                 data:   make([]byte, 32),
 812                         },
 813                         expectedErr: nil,
 814                 },
 815                 {
 816                         name: "OP_DATA_32 long",
 817                         pop: &parsedOpcode{
 818                                 opcode: &opcodeArray[OP_DATA_32],
 819                                 data:   make([]byte, 33),
 820                         },
 821                         expectedErr: scriptError(ErrInternal, ""),
 822                 },
 823                 {
 824                         name: "OP_DATA_33 short",
 825                         pop: &parsedOpcode{
 826                                 opcode: &opcodeArray[OP_DATA_33],
 827                                 data:   make([]byte, 32),
 828                         },
 829                         expectedErr: scriptError(ErrInternal, ""),
 830                 },
 831                 {
 832                         name: "OP_DATA_33",
 833                         pop: &parsedOpcode{
 834                                 opcode: &opcodeArray[OP_DATA_33],
 835                                 data:   make([]byte, 33),
 836                         },
 837                         expectedErr: nil,
 838                 },
 839                 {
 840                         name: "OP_DATA_33 long",
 841                         pop: &parsedOpcode{
 842                                 opcode: &opcodeArray[OP_DATA_33],
 843                                 data:   make([]byte, 34),
 844                         },
 845                         expectedErr: scriptError(ErrInternal, ""),
 846                 },
 847                 {
 848                         name: "OP_DATA_34 short",
 849                         pop: &parsedOpcode{
 850                                 opcode: &opcodeArray[OP_DATA_34],
 851                                 data:   make([]byte, 33),
 852                         },
 853                         expectedErr: scriptError(ErrInternal, ""),
 854                 },
 855                 {
 856                         name: "OP_DATA_34",
 857                         pop: &parsedOpcode{
 858                                 opcode: &opcodeArray[OP_DATA_34],
 859                                 data:   make([]byte, 34),
 860                         },
 861                         expectedErr: nil,
 862                 },
 863                 {
 864                         name: "OP_DATA_34 long",
 865                         pop: &parsedOpcode{
 866                                 opcode: &opcodeArray[OP_DATA_34],
 867                                 data:   make([]byte, 35),
 868                         },
 869                         expectedErr: scriptError(ErrInternal, ""),
 870                 },
 871                 {
 872                         name: "OP_DATA_35 short",
 873                         pop: &parsedOpcode{
 874                                 opcode: &opcodeArray[OP_DATA_35],
 875                                 data:   make([]byte, 34),
 876                         },
 877                         expectedErr: scriptError(ErrInternal, ""),
 878                 },
 879                 {
 880                         name: "OP_DATA_35",
 881                         pop: &parsedOpcode{
 882                                 opcode: &opcodeArray[OP_DATA_35],
 883                                 data:   make([]byte, 35),
 884                         },
 885                         expectedErr: nil,
 886                 },
 887                 {
 888                         name: "OP_DATA_35 long",
 889                         pop: &parsedOpcode{
 890                                 opcode: &opcodeArray[OP_DATA_35],
 891                                 data:   make([]byte, 36),
 892                         },
 893                         expectedErr: scriptError(ErrInternal, ""),
 894                 },
 895                 {
 896                         name: "OP_DATA_36 short",
 897                         pop: &parsedOpcode{
 898                                 opcode: &opcodeArray[OP_DATA_36],
 899                                 data:   make([]byte, 35),
 900                         },
 901                         expectedErr: scriptError(ErrInternal, ""),
 902                 },
 903                 {
 904                         name: "OP_DATA_36",
 905                         pop: &parsedOpcode{
 906                                 opcode: &opcodeArray[OP_DATA_36],
 907                                 data:   make([]byte, 36),
 908                         },
 909                         expectedErr: nil,
 910                 },
 911                 {
 912                         name: "OP_DATA_36 long",
 913                         pop: &parsedOpcode{
 914                                 opcode: &opcodeArray[OP_DATA_36],
 915                                 data:   make([]byte, 37),
 916                         },
 917                         expectedErr: scriptError(ErrInternal, ""),
 918                 },
 919                 {
 920                         name: "OP_DATA_37 short",
 921                         pop: &parsedOpcode{
 922                                 opcode: &opcodeArray[OP_DATA_37],
 923                                 data:   make([]byte, 36),
 924                         },
 925                         expectedErr: scriptError(ErrInternal, ""),
 926                 },
 927                 {
 928                         name: "OP_DATA_37",
 929                         pop: &parsedOpcode{
 930                                 opcode: &opcodeArray[OP_DATA_37],
 931                                 data:   make([]byte, 37),
 932                         },
 933                         expectedErr: nil,
 934                 },
 935                 {
 936                         name: "OP_DATA_37 long",
 937                         pop: &parsedOpcode{
 938                                 opcode: &opcodeArray[OP_DATA_37],
 939                                 data:   make([]byte, 38),
 940                         },
 941                         expectedErr: scriptError(ErrInternal, ""),
 942                 },
 943                 {
 944                         name: "OP_DATA_38 short",
 945                         pop: &parsedOpcode{
 946                                 opcode: &opcodeArray[OP_DATA_38],
 947                                 data:   make([]byte, 37),
 948                         },
 949                         expectedErr: scriptError(ErrInternal, ""),
 950                 },
 951                 {
 952                         name: "OP_DATA_38",
 953                         pop: &parsedOpcode{
 954                                 opcode: &opcodeArray[OP_DATA_38],
 955                                 data:   make([]byte, 38),
 956                         },
 957                         expectedErr: nil,
 958                 },
 959                 {
 960                         name: "OP_DATA_38 long",
 961                         pop: &parsedOpcode{
 962                                 opcode: &opcodeArray[OP_DATA_38],
 963                                 data:   make([]byte, 39),
 964                         },
 965                         expectedErr: scriptError(ErrInternal, ""),
 966                 },
 967                 {
 968                         name: "OP_DATA_39 short",
 969                         pop: &parsedOpcode{
 970                                 opcode: &opcodeArray[OP_DATA_39],
 971                                 data:   make([]byte, 38),
 972                         },
 973                         expectedErr: scriptError(ErrInternal, ""),
 974                 },
 975                 {
 976                         name: "OP_DATA_39",
 977                         pop: &parsedOpcode{
 978                                 opcode: &opcodeArray[OP_DATA_39],
 979                                 data:   make([]byte, 39),
 980                         },
 981                         expectedErr: nil,
 982                 },
 983                 {
 984                         name: "OP_DATA_39 long",
 985                         pop: &parsedOpcode{
 986                                 opcode: &opcodeArray[OP_DATA_39],
 987                                 data:   make([]byte, 40),
 988                         },
 989                         expectedErr: scriptError(ErrInternal, ""),
 990                 },
 991                 {
 992                         name: "OP_DATA_40 short",
 993                         pop: &parsedOpcode{
 994                                 opcode: &opcodeArray[OP_DATA_40],
 995                                 data:   make([]byte, 39),
 996                         },
 997                         expectedErr: scriptError(ErrInternal, ""),
 998                 },
 999                 {
1000                         name: "OP_DATA_40",
1001                         pop: &parsedOpcode{
1002                                 opcode: &opcodeArray[OP_DATA_40],
1003                                 data:   make([]byte, 40),
1004                         },
1005                         expectedErr: nil,
1006                 },
1007                 {
1008                         name: "OP_DATA_40 long",
1009                         pop: &parsedOpcode{
1010                                 opcode: &opcodeArray[OP_DATA_40],
1011                                 data:   make([]byte, 41),
1012                         },
1013                         expectedErr: scriptError(ErrInternal, ""),
1014                 },
1015                 {
1016                         name: "OP_DATA_41 short",
1017                         pop: &parsedOpcode{
1018                                 opcode: &opcodeArray[OP_DATA_41],
1019                                 data:   make([]byte, 40),
1020                         },
1021                         expectedErr: scriptError(ErrInternal, ""),
1022                 },
1023                 {
1024                         name: "OP_DATA_41",
1025                         pop: &parsedOpcode{
1026                                 opcode: &opcodeArray[OP_DATA_41],
1027                                 data:   make([]byte, 41),
1028                         },
1029                         expectedErr: nil,
1030                 },
1031                 {
1032                         name: "OP_DATA_41 long",
1033                         pop: &parsedOpcode{
1034                                 opcode: &opcodeArray[OP_DATA_41],
1035                                 data:   make([]byte, 42),
1036                         },
1037                         expectedErr: scriptError(ErrInternal, ""),
1038                 },
1039                 {
1040                         name: "OP_DATA_42 short",
1041                         pop: &parsedOpcode{
1042                                 opcode: &opcodeArray[OP_DATA_42],
1043                                 data:   make([]byte, 41),
1044                         },
1045                         expectedErr: scriptError(ErrInternal, ""),
1046                 },
1047                 {
1048                         name: "OP_DATA_42",
1049                         pop: &parsedOpcode{
1050                                 opcode: &opcodeArray[OP_DATA_42],
1051                                 data:   make([]byte, 42),
1052                         },
1053                         expectedErr: nil,
1054                 },
1055                 {
1056                         name: "OP_DATA_42 long",
1057                         pop: &parsedOpcode{
1058                                 opcode: &opcodeArray[OP_DATA_42],
1059                                 data:   make([]byte, 43),
1060                         },
1061                         expectedErr: scriptError(ErrInternal, ""),
1062                 },
1063                 {
1064                         name: "OP_DATA_43 short",
1065                         pop: &parsedOpcode{
1066                                 opcode: &opcodeArray[OP_DATA_43],
1067                                 data:   make([]byte, 42),
1068                         },
1069                         expectedErr: scriptError(ErrInternal, ""),
1070                 },
1071                 {
1072                         name: "OP_DATA_43",
1073                         pop: &parsedOpcode{
1074                                 opcode: &opcodeArray[OP_DATA_43],
1075                                 data:   make([]byte, 43),
1076                         },
1077                         expectedErr: nil,
1078                 },
1079                 {
1080                         name: "OP_DATA_43 long",
1081                         pop: &parsedOpcode{
1082                                 opcode: &opcodeArray[OP_DATA_43],
1083                                 data:   make([]byte, 44),
1084                         },
1085                         expectedErr: scriptError(ErrInternal, ""),
1086                 },
1087                 {
1088                         name: "OP_DATA_44 short",
1089                         pop: &parsedOpcode{
1090                                 opcode: &opcodeArray[OP_DATA_44],
1091                                 data:   make([]byte, 43),
1092                         },
1093                         expectedErr: scriptError(ErrInternal, ""),
1094                 },
1095                 {
1096                         name: "OP_DATA_44",
1097                         pop: &parsedOpcode{
1098                                 opcode: &opcodeArray[OP_DATA_44],
1099                                 data:   make([]byte, 44),
1100                         },
1101                         expectedErr: nil,
1102                 },
1103                 {
1104                         name: "OP_DATA_44 long",
1105                         pop: &parsedOpcode{
1106                                 opcode: &opcodeArray[OP_DATA_44],
1107                                 data:   make([]byte, 45),
1108                         },
1109                         expectedErr: scriptError(ErrInternal, ""),
1110                 },
1111                 {
1112                         name: "OP_DATA_45 short",
1113                         pop: &parsedOpcode{
1114                                 opcode: &opcodeArray[OP_DATA_45],
1115                                 data:   make([]byte, 44),
1116                         },
1117                         expectedErr: scriptError(ErrInternal, ""),
1118                 },
1119                 {
1120                         name: "OP_DATA_45",
1121                         pop: &parsedOpcode{
1122                                 opcode: &opcodeArray[OP_DATA_45],
1123                                 data:   make([]byte, 45),
1124                         },
1125                         expectedErr: nil,
1126                 },
1127                 {
1128                         name: "OP_DATA_45 long",
1129                         pop: &parsedOpcode{
1130                                 opcode: &opcodeArray[OP_DATA_45],
1131                                 data:   make([]byte, 46),
1132                         },
1133                         expectedErr: scriptError(ErrInternal, ""),
1134                 },
1135                 {
1136                         name: "OP_DATA_46 short",
1137                         pop: &parsedOpcode{
1138                                 opcode: &opcodeArray[OP_DATA_46],
1139                                 data:   make([]byte, 45),
1140                         },
1141                         expectedErr: scriptError(ErrInternal, ""),
1142                 },
1143                 {
1144                         name: "OP_DATA_46",
1145                         pop: &parsedOpcode{
1146                                 opcode: &opcodeArray[OP_DATA_46],
1147                                 data:   make([]byte, 46),
1148                         },
1149                         expectedErr: nil,
1150                 },
1151                 {
1152                         name: "OP_DATA_46 long",
1153                         pop: &parsedOpcode{
1154                                 opcode: &opcodeArray[OP_DATA_46],
1155                                 data:   make([]byte, 47),
1156                         },
1157                         expectedErr: scriptError(ErrInternal, ""),
1158                 },
1159                 {
1160                         name: "OP_DATA_47 short",
1161                         pop: &parsedOpcode{
1162                                 opcode: &opcodeArray[OP_DATA_47],
1163                                 data:   make([]byte, 46),
1164                         },
1165                         expectedErr: scriptError(ErrInternal, ""),
1166                 },
1167                 {
1168                         name: "OP_DATA_47",
1169                         pop: &parsedOpcode{
1170                                 opcode: &opcodeArray[OP_DATA_47],
1171                                 data:   make([]byte, 47),
1172                         },
1173                         expectedErr: nil,
1174                 },
1175                 {
1176                         name: "OP_DATA_47 long",
1177                         pop: &parsedOpcode{
1178                                 opcode: &opcodeArray[OP_DATA_47],
1179                                 data:   make([]byte, 48),
1180                         },
1181                         expectedErr: scriptError(ErrInternal, ""),
1182                 },
1183                 {
1184                         name: "OP_DATA_48 short",
1185                         pop: &parsedOpcode{
1186                                 opcode: &opcodeArray[OP_DATA_48],
1187                                 data:   make([]byte, 47),
1188                         },
1189                         expectedErr: scriptError(ErrInternal, ""),
1190                 },
1191                 {
1192                         name: "OP_DATA_48",
1193                         pop: &parsedOpcode{
1194                                 opcode: &opcodeArray[OP_DATA_48],
1195                                 data:   make([]byte, 48),
1196                         },
1197                         expectedErr: nil,
1198                 },
1199                 {
1200                         name: "OP_DATA_48 long",
1201                         pop: &parsedOpcode{
1202                                 opcode: &opcodeArray[OP_DATA_48],
1203                                 data:   make([]byte, 49),
1204                         },
1205                         expectedErr: scriptError(ErrInternal, ""),
1206                 },
1207                 {
1208                         name: "OP_DATA_49 short",
1209                         pop: &parsedOpcode{
1210                                 opcode: &opcodeArray[OP_DATA_49],
1211                                 data:   make([]byte, 48),
1212                         },
1213                         expectedErr: scriptError(ErrInternal, ""),
1214                 },
1215                 {
1216                         name: "OP_DATA_49",
1217                         pop: &parsedOpcode{
1218                                 opcode: &opcodeArray[OP_DATA_49],
1219                                 data:   make([]byte, 49),
1220                         },
1221                         expectedErr: nil,
1222                 },
1223                 {
1224                         name: "OP_DATA_49 long",
1225                         pop: &parsedOpcode{
1226                                 opcode: &opcodeArray[OP_DATA_49],
1227                                 data:   make([]byte, 50),
1228                         },
1229                         expectedErr: scriptError(ErrInternal, ""),
1230                 },
1231                 {
1232                         name: "OP_DATA_50 short",
1233                         pop: &parsedOpcode{
1234                                 opcode: &opcodeArray[OP_DATA_50],
1235                                 data:   make([]byte, 49),
1236                         },
1237                         expectedErr: scriptError(ErrInternal, ""),
1238                 },
1239                 {
1240                         name: "OP_DATA_50",
1241                         pop: &parsedOpcode{
1242                                 opcode: &opcodeArray[OP_DATA_50],
1243                                 data:   make([]byte, 50),
1244                         },
1245                         expectedErr: nil,
1246                 },
1247                 {
1248                         name: "OP_DATA_50 long",
1249                         pop: &parsedOpcode{
1250                                 opcode: &opcodeArray[OP_DATA_50],
1251                                 data:   make([]byte, 51),
1252                         },
1253                         expectedErr: scriptError(ErrInternal, ""),
1254                 },
1255                 {
1256                         name: "OP_DATA_51 short",
1257                         pop: &parsedOpcode{
1258                                 opcode: &opcodeArray[OP_DATA_51],
1259                                 data:   make([]byte, 50),
1260                         },
1261                         expectedErr: scriptError(ErrInternal, ""),
1262                 },
1263                 {
1264                         name: "OP_DATA_51",
1265                         pop: &parsedOpcode{
1266                                 opcode: &opcodeArray[OP_DATA_51],
1267                                 data:   make([]byte, 51),
1268                         },
1269                         expectedErr: nil,
1270                 },
1271                 {
1272                         name: "OP_DATA_51 long",
1273                         pop: &parsedOpcode{
1274                                 opcode: &opcodeArray[OP_DATA_51],
1275                                 data:   make([]byte, 52),
1276                         },
1277                         expectedErr: scriptError(ErrInternal, ""),
1278                 },
1279                 {
1280                         name: "OP_DATA_52 short",
1281                         pop: &parsedOpcode{
1282                                 opcode: &opcodeArray[OP_DATA_52],
1283                                 data:   make([]byte, 51),
1284                         },
1285                         expectedErr: scriptError(ErrInternal, ""),
1286                 },
1287                 {
1288                         name: "OP_DATA_52",
1289                         pop: &parsedOpcode{
1290                                 opcode: &opcodeArray[OP_DATA_52],
1291                                 data:   make([]byte, 52),
1292                         },
1293                         expectedErr: nil,
1294                 },
1295                 {
1296                         name: "OP_DATA_52 long",
1297                         pop: &parsedOpcode{
1298                                 opcode: &opcodeArray[OP_DATA_52],
1299                                 data:   make([]byte, 53),
1300                         },
1301                         expectedErr: scriptError(ErrInternal, ""),
1302                 },
1303                 {
1304                         name: "OP_DATA_53 short",
1305                         pop: &parsedOpcode{
1306                                 opcode: &opcodeArray[OP_DATA_53],
1307                                 data:   make([]byte, 52),
1308                         },
1309                         expectedErr: scriptError(ErrInternal, ""),
1310                 },
1311                 {
1312                         name: "OP_DATA_53",
1313                         pop: &parsedOpcode{
1314                                 opcode: &opcodeArray[OP_DATA_53],
1315                                 data:   make([]byte, 53),
1316                         },
1317                         expectedErr: nil,
1318                 },
1319                 {
1320                         name: "OP_DATA_53 long",
1321                         pop: &parsedOpcode{
1322                                 opcode: &opcodeArray[OP_DATA_53],
1323                                 data:   make([]byte, 54),
1324                         },
1325                         expectedErr: scriptError(ErrInternal, ""),
1326                 },
1327                 {
1328                         name: "OP_DATA_54 short",
1329                         pop: &parsedOpcode{
1330                                 opcode: &opcodeArray[OP_DATA_54],
1331                                 data:   make([]byte, 53),
1332                         },
1333                         expectedErr: scriptError(ErrInternal, ""),
1334                 },
1335                 {
1336                         name: "OP_DATA_54",
1337                         pop: &parsedOpcode{
1338                                 opcode: &opcodeArray[OP_DATA_54],
1339                                 data:   make([]byte, 54),
1340                         },
1341                         expectedErr: nil,
1342                 },
1343                 {
1344                         name: "OP_DATA_54 long",
1345                         pop: &parsedOpcode{
1346                                 opcode: &opcodeArray[OP_DATA_54],
1347                                 data:   make([]byte, 55),
1348                         },
1349                         expectedErr: scriptError(ErrInternal, ""),
1350                 },
1351                 {
1352                         name: "OP_DATA_55 short",
1353                         pop: &parsedOpcode{
1354                                 opcode: &opcodeArray[OP_DATA_55],
1355                                 data:   make([]byte, 54),
1356                         },
1357                         expectedErr: scriptError(ErrInternal, ""),
1358                 },
1359                 {
1360                         name: "OP_DATA_55",
1361                         pop: &parsedOpcode{
1362                                 opcode: &opcodeArray[OP_DATA_55],
1363                                 data:   make([]byte, 55),
1364                         },
1365                         expectedErr: nil,
1366                 },
1367                 {
1368                         name: "OP_DATA_55 long",
1369                         pop: &parsedOpcode{
1370                                 opcode: &opcodeArray[OP_DATA_55],
1371                                 data:   make([]byte, 56),
1372                         },
1373                         expectedErr: scriptError(ErrInternal, ""),
1374                 },
1375                 {
1376                         name: "OP_DATA_56 short",
1377                         pop: &parsedOpcode{
1378                                 opcode: &opcodeArray[OP_DATA_56],
1379                                 data:   make([]byte, 55),
1380                         },
1381                         expectedErr: scriptError(ErrInternal, ""),
1382                 },
1383                 {
1384                         name: "OP_DATA_56",
1385                         pop: &parsedOpcode{
1386                                 opcode: &opcodeArray[OP_DATA_56],
1387                                 data:   make([]byte, 56),
1388                         },
1389                         expectedErr: nil,
1390                 },
1391                 {
1392                         name: "OP_DATA_56 long",
1393                         pop: &parsedOpcode{
1394                                 opcode: &opcodeArray[OP_DATA_56],
1395                                 data:   make([]byte, 57),
1396                         },
1397                         expectedErr: scriptError(ErrInternal, ""),
1398                 },
1399                 {
1400                         name: "OP_DATA_57 short",
1401                         pop: &parsedOpcode{
1402                                 opcode: &opcodeArray[OP_DATA_57],
1403                                 data:   make([]byte, 56),
1404                         },
1405                         expectedErr: scriptError(ErrInternal, ""),
1406                 },
1407                 {
1408                         name: "OP_DATA_57",
1409                         pop: &parsedOpcode{
1410                                 opcode: &opcodeArray[OP_DATA_57],
1411                                 data:   make([]byte, 57),
1412                         },
1413                         expectedErr: nil,
1414                 },
1415                 {
1416                         name: "OP_DATA_57 long",
1417                         pop: &parsedOpcode{
1418                                 opcode: &opcodeArray[OP_DATA_57],
1419                                 data:   make([]byte, 58),
1420                         },
1421                         expectedErr: scriptError(ErrInternal, ""),
1422                 },
1423                 {
1424                         name: "OP_DATA_58 short",
1425                         pop: &parsedOpcode{
1426                                 opcode: &opcodeArray[OP_DATA_58],
1427                                 data:   make([]byte, 57),
1428                         },
1429                         expectedErr: scriptError(ErrInternal, ""),
1430                 },
1431                 {
1432                         name: "OP_DATA_58",
1433                         pop: &parsedOpcode{
1434                                 opcode: &opcodeArray[OP_DATA_58],
1435                                 data:   make([]byte, 58),
1436                         },
1437                         expectedErr: nil,
1438                 },
1439                 {
1440                         name: "OP_DATA_58 long",
1441                         pop: &parsedOpcode{
1442                                 opcode: &opcodeArray[OP_DATA_58],
1443                                 data:   make([]byte, 59),
1444                         },
1445                         expectedErr: scriptError(ErrInternal, ""),
1446                 },
1447                 {
1448                         name: "OP_DATA_59 short",
1449                         pop: &parsedOpcode{
1450                                 opcode: &opcodeArray[OP_DATA_59],
1451                                 data:   make([]byte, 58),
1452                         },
1453                         expectedErr: scriptError(ErrInternal, ""),
1454                 },
1455                 {
1456                         name: "OP_DATA_59",
1457                         pop: &parsedOpcode{
1458                                 opcode: &opcodeArray[OP_DATA_59],
1459                                 data:   make([]byte, 59),
1460                         },
1461                         expectedErr: nil,
1462                 },
1463                 {
1464                         name: "OP_DATA_59 long",
1465                         pop: &parsedOpcode{
1466                                 opcode: &opcodeArray[OP_DATA_59],
1467                                 data:   make([]byte, 60),
1468                         },
1469                         expectedErr: scriptError(ErrInternal, ""),
1470                 },
1471                 {
1472                         name: "OP_DATA_60 short",
1473                         pop: &parsedOpcode{
1474                                 opcode: &opcodeArray[OP_DATA_60],
1475                                 data:   make([]byte, 59),
1476                         },
1477                         expectedErr: scriptError(ErrInternal, ""),
1478                 },
1479                 {
1480                         name: "OP_DATA_60",
1481                         pop: &parsedOpcode{
1482                                 opcode: &opcodeArray[OP_DATA_60],
1483                                 data:   make([]byte, 60),
1484                         },
1485                         expectedErr: nil,
1486                 },
1487                 {
1488                         name: "OP_DATA_60 long",
1489                         pop: &parsedOpcode{
1490                                 opcode: &opcodeArray[OP_DATA_60],
1491                                 data:   make([]byte, 61),
1492                         },
1493                         expectedErr: scriptError(ErrInternal, ""),
1494                 },
1495                 {
1496                         name: "OP_DATA_61 short",
1497                         pop: &parsedOpcode{
1498                                 opcode: &opcodeArray[OP_DATA_61],
1499                                 data:   make([]byte, 60),
1500                         },
1501                         expectedErr: scriptError(ErrInternal, ""),
1502                 },
1503                 {
1504                         name: "OP_DATA_61",
1505                         pop: &parsedOpcode{
1506                                 opcode: &opcodeArray[OP_DATA_61],
1507                                 data:   make([]byte, 61),
1508                         },
1509                         expectedErr: nil,
1510                 },
1511                 {
1512                         name: "OP_DATA_61 long",
1513                         pop: &parsedOpcode{
1514                                 opcode: &opcodeArray[OP_DATA_61],
1515                                 data:   make([]byte, 62),
1516                         },
1517                         expectedErr: scriptError(ErrInternal, ""),
1518                 },
1519                 {
1520                         name: "OP_DATA_62 short",
1521                         pop: &parsedOpcode{
1522                                 opcode: &opcodeArray[OP_DATA_62],
1523                                 data:   make([]byte, 61),
1524                         },
1525                         expectedErr: scriptError(ErrInternal, ""),
1526                 },
1527                 {
1528                         name: "OP_DATA_62",
1529                         pop: &parsedOpcode{
1530                                 opcode: &opcodeArray[OP_DATA_62],
1531                                 data:   make([]byte, 62),
1532                         },
1533                         expectedErr: nil,
1534                 },
1535                 {
1536                         name: "OP_DATA_62 long",
1537                         pop: &parsedOpcode{
1538                                 opcode: &opcodeArray[OP_DATA_62],
1539                                 data:   make([]byte, 63),
1540                         },
1541                         expectedErr: scriptError(ErrInternal, ""),
1542                 },
1543                 {
1544                         name: "OP_DATA_63 short",
1545                         pop: &parsedOpcode{
1546                                 opcode: &opcodeArray[OP_DATA_63],
1547                                 data:   make([]byte, 62),
1548                         },
1549                         expectedErr: scriptError(ErrInternal, ""),
1550                 },
1551                 {
1552                         name: "OP_DATA_63",
1553                         pop: &parsedOpcode{
1554                                 opcode: &opcodeArray[OP_DATA_63],
1555                                 data:   make([]byte, 63),
1556                         },
1557                         expectedErr: nil,
1558                 },
1559                 {
1560                         name: "OP_DATA_63 long",
1561                         pop: &parsedOpcode{
1562                                 opcode: &opcodeArray[OP_DATA_63],
1563                                 data:   make([]byte, 64),
1564                         },
1565                         expectedErr: scriptError(ErrInternal, ""),
1566                 },
1567                 {
1568                         name: "OP_DATA_64 short",
1569                         pop: &parsedOpcode{
1570                                 opcode: &opcodeArray[OP_DATA_64],
1571                                 data:   make([]byte, 63),
1572                         },
1573                         expectedErr: scriptError(ErrInternal, ""),
1574                 },
1575                 {
1576                         name: "OP_DATA_64",
1577                         pop: &parsedOpcode{
1578                                 opcode: &opcodeArray[OP_DATA_64],
1579                                 data:   make([]byte, 64),
1580                         },
1581                         expectedErr: nil,
1582                 },
1583                 {
1584                         name: "OP_DATA_64 long",
1585                         pop: &parsedOpcode{
1586                                 opcode: &opcodeArray[OP_DATA_64],
1587                                 data:   make([]byte, 65),
1588                         },
1589                         expectedErr: scriptError(ErrInternal, ""),
1590                 },
1591                 {
1592                         name: "OP_DATA_65 short",
1593                         pop: &parsedOpcode{
1594                                 opcode: &opcodeArray[OP_DATA_65],
1595                                 data:   make([]byte, 64),
1596                         },
1597                         expectedErr: scriptError(ErrInternal, ""),
1598                 },
1599                 {
1600                         name: "OP_DATA_65",
1601                         pop: &parsedOpcode{
1602                                 opcode: &opcodeArray[OP_DATA_65],
1603                                 data:   make([]byte, 65),
1604                         },
1605                         expectedErr: nil,
1606                 },
1607                 {
1608                         name: "OP_DATA_65 long",
1609                         pop: &parsedOpcode{
1610                                 opcode: &opcodeArray[OP_DATA_65],
1611                                 data:   make([]byte, 66),
1612                         },
1613                         expectedErr: scriptError(ErrInternal, ""),
1614                 },
1615                 {
1616                         name: "OP_DATA_66 short",
1617                         pop: &parsedOpcode{
1618                                 opcode: &opcodeArray[OP_DATA_66],
1619                                 data:   make([]byte, 65),
1620                         },
1621                         expectedErr: scriptError(ErrInternal, ""),
1622                 },
1623                 {
1624                         name: "OP_DATA_66",
1625                         pop: &parsedOpcode{
1626                                 opcode: &opcodeArray[OP_DATA_66],
1627                                 data:   make([]byte, 66),
1628                         },
1629                         expectedErr: nil,
1630                 },
1631                 {
1632                         name: "OP_DATA_66 long",
1633                         pop: &parsedOpcode{
1634                                 opcode: &opcodeArray[OP_DATA_66],
1635                                 data:   make([]byte, 67),
1636                         },
1637                         expectedErr: scriptError(ErrInternal, ""),
1638                 },
1639                 {
1640                         name: "OP_DATA_67 short",
1641                         pop: &parsedOpcode{
1642                                 opcode: &opcodeArray[OP_DATA_67],
1643                                 data:   make([]byte, 66),
1644                         },
1645                         expectedErr: scriptError(ErrInternal, ""),
1646                 },
1647                 {
1648                         name: "OP_DATA_67",
1649                         pop: &parsedOpcode{
1650                                 opcode: &opcodeArray[OP_DATA_67],
1651                                 data:   make([]byte, 67),
1652                         },
1653                         expectedErr: nil,
1654                 },
1655                 {
1656                         name: "OP_DATA_67 long",
1657                         pop: &parsedOpcode{
1658                                 opcode: &opcodeArray[OP_DATA_67],
1659                                 data:   make([]byte, 68),
1660                         },
1661                         expectedErr: scriptError(ErrInternal, ""),
1662                 },
1663                 {
1664                         name: "OP_DATA_68 short",
1665                         pop: &parsedOpcode{
1666                                 opcode: &opcodeArray[OP_DATA_68],
1667                                 data:   make([]byte, 67),
1668                         },
1669                         expectedErr: scriptError(ErrInternal, ""),
1670                 },
1671                 {
1672                         name: "OP_DATA_68",
1673                         pop: &parsedOpcode{
1674                                 opcode: &opcodeArray[OP_DATA_68],
1675                                 data:   make([]byte, 68),
1676                         },
1677                         expectedErr: nil,
1678                 },
1679                 {
1680                         name: "OP_DATA_68 long",
1681                         pop: &parsedOpcode{
1682                                 opcode: &opcodeArray[OP_DATA_68],
1683                                 data:   make([]byte, 69),
1684                         },
1685                         expectedErr: scriptError(ErrInternal, ""),
1686                 },
1687                 {
1688                         name: "OP_DATA_69 short",
1689                         pop: &parsedOpcode{
1690                                 opcode: &opcodeArray[OP_DATA_69],
1691                                 data:   make([]byte, 68),
1692                         },
1693                         expectedErr: scriptError(ErrInternal, ""),
1694                 },
1695                 {
1696                         name: "OP_DATA_69",
1697                         pop: &parsedOpcode{
1698                                 opcode: &opcodeArray[OP_DATA_69],
1699                                 data:   make([]byte, 69),
1700                         },
1701                         expectedErr: nil,
1702                 },
1703                 {
1704                         name: "OP_DATA_69 long",
1705                         pop: &parsedOpcode{
1706                                 opcode: &opcodeArray[OP_DATA_69],
1707                                 data:   make([]byte, 70),
1708                         },
1709                         expectedErr: scriptError(ErrInternal, ""),
1710                 },
1711                 {
1712                         name: "OP_DATA_70 short",
1713                         pop: &parsedOpcode{
1714                                 opcode: &opcodeArray[OP_DATA_70],
1715                                 data:   make([]byte, 69),
1716                         },
1717                         expectedErr: scriptError(ErrInternal, ""),
1718                 },
1719                 {
1720                         name: "OP_DATA_70",
1721                         pop: &parsedOpcode{
1722                                 opcode: &opcodeArray[OP_DATA_70],
1723                                 data:   make([]byte, 70),
1724                         },
1725                         expectedErr: nil,
1726                 },
1727                 {
1728                         name: "OP_DATA_70 long",
1729                         pop: &parsedOpcode{
1730                                 opcode: &opcodeArray[OP_DATA_70],
1731                                 data:   make([]byte, 71),
1732                         },
1733                         expectedErr: scriptError(ErrInternal, ""),
1734                 },
1735                 {
1736                         name: "OP_DATA_71 short",
1737                         pop: &parsedOpcode{
1738                                 opcode: &opcodeArray[OP_DATA_71],
1739                                 data:   make([]byte, 70),
1740                         },
1741                         expectedErr: scriptError(ErrInternal, ""),
1742                 },
1743                 {
1744                         name: "OP_DATA_71",
1745                         pop: &parsedOpcode{
1746                                 opcode: &opcodeArray[OP_DATA_71],
1747                                 data:   make([]byte, 71),
1748                         },
1749                         expectedErr: nil,
1750                 },
1751                 {
1752                         name: "OP_DATA_71 long",
1753                         pop: &parsedOpcode{
1754                                 opcode: &opcodeArray[OP_DATA_71],
1755                                 data:   make([]byte, 72),
1756                         },
1757                         expectedErr: scriptError(ErrInternal, ""),
1758                 },
1759                 {
1760                         name: "OP_DATA_72 short",
1761                         pop: &parsedOpcode{
1762                                 opcode: &opcodeArray[OP_DATA_72],
1763                                 data:   make([]byte, 71),
1764                         },
1765                         expectedErr: scriptError(ErrInternal, ""),
1766                 },
1767                 {
1768                         name: "OP_DATA_72",
1769                         pop: &parsedOpcode{
1770                                 opcode: &opcodeArray[OP_DATA_72],
1771                                 data:   make([]byte, 72),
1772                         },
1773                         expectedErr: nil,
1774                 },
1775                 {
1776                         name: "OP_DATA_72 long",
1777                         pop: &parsedOpcode{
1778                                 opcode: &opcodeArray[OP_DATA_72],
1779                                 data:   make([]byte, 73),
1780                         },
1781                         expectedErr: scriptError(ErrInternal, ""),
1782                 },
1783                 {
1784                         name: "OP_DATA_73 short",
1785                         pop: &parsedOpcode{
1786                                 opcode: &opcodeArray[OP_DATA_73],
1787                                 data:   make([]byte, 72),
1788                         },
1789                         expectedErr: scriptError(ErrInternal, ""),
1790                 },
1791                 {
1792                         name: "OP_DATA_73",
1793                         pop: &parsedOpcode{
1794                                 opcode: &opcodeArray[OP_DATA_73],
1795                                 data:   make([]byte, 73),
1796                         },
1797                         expectedErr: nil,
1798                 },
1799                 {
1800                         name: "OP_DATA_73 long",
1801                         pop: &parsedOpcode{
1802                                 opcode: &opcodeArray[OP_DATA_73],
1803                                 data:   make([]byte, 74),
1804                         },
1805                         expectedErr: scriptError(ErrInternal, ""),
1806                 },
1807                 {
1808                         name: "OP_DATA_74 short",
1809                         pop: &parsedOpcode{
1810                                 opcode: &opcodeArray[OP_DATA_74],
1811                                 data:   make([]byte, 73),
1812                         },
1813                         expectedErr: scriptError(ErrInternal, ""),
1814                 },
1815                 {
1816                         name: "OP_DATA_74",
1817                         pop: &parsedOpcode{
1818                                 opcode: &opcodeArray[OP_DATA_74],
1819                                 data:   make([]byte, 74),
1820                         },
1821                         expectedErr: nil,
1822                 },
1823                 {
1824                         name: "OP_DATA_74 long",
1825                         pop: &parsedOpcode{
1826                                 opcode: &opcodeArray[OP_DATA_74],
1827                                 data:   make([]byte, 75),
1828                         },
1829                         expectedErr: scriptError(ErrInternal, ""),
1830                 },
1831                 {
1832                         name: "OP_DATA_75 short",
1833                         pop: &parsedOpcode{
1834                                 opcode: &opcodeArray[OP_DATA_75],
1835                                 data:   make([]byte, 74),
1836                         },
1837                         expectedErr: scriptError(ErrInternal, ""),
1838                 },
1839                 {
1840                         name: "OP_DATA_75",
1841                         pop: &parsedOpcode{
1842                                 opcode: &opcodeArray[OP_DATA_75],
1843                                 data:   make([]byte, 75),
1844                         },
1845                         expectedErr: nil,
1846                 },
1847                 {
1848                         name: "OP_DATA_75 long",
1849                         pop: &parsedOpcode{
1850                                 opcode: &opcodeArray[OP_DATA_75],
1851                                 data:   make([]byte, 76),
1852                         },
1853                         expectedErr: scriptError(ErrInternal, ""),
1854                 },
1855                 {
1856                         name: "OP_PUSHDATA1",
1857                         pop: &parsedOpcode{
1858                                 opcode: &opcodeArray[OP_PUSHDATA1],
1859                                 data:   []byte{0, 1, 2, 3, 4},
1860                         },
1861                         expectedErr: nil,
1862                 },
1863                 {
1864                         name: "OP_PUSHDATA2",
1865                         pop: &parsedOpcode{
1866                                 opcode: &opcodeArray[OP_PUSHDATA2],
1867                                 data:   []byte{0, 1, 2, 3, 4},
1868                         },
1869                         expectedErr: nil,
1870                 },
1871                 {
1872                         name: "OP_PUSHDATA4",
1873                         pop: &parsedOpcode{
1874                                 opcode: &opcodeArray[OP_PUSHDATA1],
1875                                 data:   []byte{0, 1, 2, 3, 4},
1876                         },
1877                         expectedErr: nil,
1878                 },
1879                 {
1880                         name: "OP_1NEGATE",
1881                         pop: &parsedOpcode{
1882                                 opcode: &opcodeArray[OP_1NEGATE],
1883                                 data:   nil,
1884                         },
1885                         expectedErr: nil,
1886                 },
1887                 {
1888                         name: "OP_1NEGATE long",
1889                         pop: &parsedOpcode{
1890                                 opcode: &opcodeArray[OP_1NEGATE],
1891                                 data:   make([]byte, 1),
1892                         },
1893                         expectedErr: scriptError(ErrInternal, ""),
1894                 },
1895                 {
1896                         name: "OP_RESERVED",
1897                         pop: &parsedOpcode{
1898                                 opcode: &opcodeArray[OP_RESERVED],
1899                                 data:   nil,
1900                         },
1901                         expectedErr: nil,
1902                 },
1903                 {
1904                         name: "OP_RESERVED long",
1905                         pop: &parsedOpcode{
1906                                 opcode: &opcodeArray[OP_RESERVED],
1907                                 data:   make([]byte, 1),
1908                         },
1909                         expectedErr: scriptError(ErrInternal, ""),
1910                 },
1911                 {
1912                         name: "OP_TRUE",
1913                         pop: &parsedOpcode{
1914                                 opcode: &opcodeArray[OP_TRUE],
1915                                 data:   nil,
1916                         },
1917                         expectedErr: nil,
1918                 },
1919                 {
1920                         name: "OP_TRUE long",
1921                         pop: &parsedOpcode{
1922                                 opcode: &opcodeArray[OP_TRUE],
1923                                 data:   make([]byte, 1),
1924                         },
1925                         expectedErr: scriptError(ErrInternal, ""),
1926                 },
1927                 {
1928                         name: "OP_2",
1929                         pop: &parsedOpcode{
1930                                 opcode: &opcodeArray[OP_2],
1931                                 data:   nil,
1932                         },
1933                         expectedErr: nil,
1934                 },
1935                 {
1936                         name: "OP_2 long",
1937                         pop: &parsedOpcode{
1938                                 opcode: &opcodeArray[OP_2],
1939                                 data:   make([]byte, 1),
1940                         },
1941                         expectedErr: scriptError(ErrInternal, ""),
1942                 },
1943                 {
1944                         name: "OP_2",
1945                         pop: &parsedOpcode{
1946                                 opcode: &opcodeArray[OP_2],
1947                                 data:   nil,
1948                         },
1949                         expectedErr: nil,
1950                 },
1951                 {
1952                         name: "OP_2 long",
1953                         pop: &parsedOpcode{
1954                                 opcode: &opcodeArray[OP_2],
1955                                 data:   make([]byte, 1),
1956                         },
1957                         expectedErr: scriptError(ErrInternal, ""),
1958                 },
1959                 {
1960                         name: "OP_3",
1961                         pop: &parsedOpcode{
1962                                 opcode: &opcodeArray[OP_3],
1963                                 data:   nil,
1964                         },
1965                         expectedErr: nil,
1966                 },
1967                 {
1968                         name: "OP_3 long",
1969                         pop: &parsedOpcode{
1970                                 opcode: &opcodeArray[OP_3],
1971                                 data:   make([]byte, 1),
1972                         },
1973                         expectedErr: scriptError(ErrInternal, ""),
1974                 },
1975                 {
1976                         name: "OP_4",
1977                         pop: &parsedOpcode{
1978                                 opcode: &opcodeArray[OP_4],
1979                                 data:   nil,
1980                         },
1981                         expectedErr: nil,
1982                 },
1983                 {
1984                         name: "OP_4 long",
1985                         pop: &parsedOpcode{
1986                                 opcode: &opcodeArray[OP_4],
1987                                 data:   make([]byte, 1),
1988                         },
1989                         expectedErr: scriptError(ErrInternal, ""),
1990                 },
1991                 {
1992                         name: "OP_5",
1993                         pop: &parsedOpcode{
1994                                 opcode: &opcodeArray[OP_5],
1995                                 data:   nil,
1996                         },
1997                         expectedErr: nil,
1998                 },
1999                 {
2000                         name: "OP_5 long",
2001                         pop: &parsedOpcode{
2002                                 opcode: &opcodeArray[OP_5],
2003                                 data:   make([]byte, 1),
2004                         },
2005                         expectedErr: scriptError(ErrInternal, ""),
2006                 },
2007                 {
2008                         name: "OP_6",
2009                         pop: &parsedOpcode{
2010                                 opcode: &opcodeArray[OP_6],
2011                                 data:   nil,
2012                         },
2013                         expectedErr: nil,
2014                 },
2015                 {
2016                         name: "OP_6 long",
2017                         pop: &parsedOpcode{
2018                                 opcode: &opcodeArray[OP_6],
2019                                 data:   make([]byte, 1),
2020                         },
2021                         expectedErr: scriptError(ErrInternal, ""),
2022                 },
2023                 {
2024                         name: "OP_7",
2025                         pop: &parsedOpcode{
2026                                 opcode: &opcodeArray[OP_7],
2027                                 data:   nil,
2028                         },
2029                         expectedErr: nil,
2030                 },
2031                 {
2032                         name: "OP_7 long",
2033                         pop: &parsedOpcode{
2034                                 opcode: &opcodeArray[OP_7],
2035                                 data:   make([]byte, 1),
2036                         },
2037                         expectedErr: scriptError(ErrInternal, ""),
2038                 },
2039                 {
2040                         name: "OP_8",
2041                         pop: &parsedOpcode{
2042                                 opcode: &opcodeArray[OP_8],
2043                                 data:   nil,
2044                         },
2045                         expectedErr: nil,
2046                 },
2047                 {
2048                         name: "OP_8 long",
2049                         pop: &parsedOpcode{
2050                                 opcode: &opcodeArray[OP_8],
2051                                 data:   make([]byte, 1),
2052                         },
2053                         expectedErr: scriptError(ErrInternal, ""),
2054                 },
2055                 {
2056                         name: "OP_9",
2057                         pop: &parsedOpcode{
2058                                 opcode: &opcodeArray[OP_9],
2059                                 data:   nil,
2060                         },
2061                         expectedErr: nil,
2062                 },
2063                 {
2064                         name: "OP_9 long",
2065                         pop: &parsedOpcode{
2066                                 opcode: &opcodeArray[OP_9],
2067                                 data:   make([]byte, 1),
2068                         },
2069                         expectedErr: scriptError(ErrInternal, ""),
2070                 },
2071                 {
2072                         name: "OP_10",
2073                         pop: &parsedOpcode{
2074                                 opcode: &opcodeArray[OP_10],
2075                                 data:   nil,
2076                         },
2077                         expectedErr: nil,
2078                 },
2079                 {
2080                         name: "OP_10 long",
2081                         pop: &parsedOpcode{
2082                                 opcode: &opcodeArray[OP_10],
2083                                 data:   make([]byte, 1),
2084                         },
2085                         expectedErr: scriptError(ErrInternal, ""),
2086                 },
2087                 {
2088                         name: "OP_11",
2089                         pop: &parsedOpcode{
2090                                 opcode: &opcodeArray[OP_11],
2091                                 data:   nil,
2092                         },
2093                         expectedErr: nil,
2094                 },
2095                 {
2096                         name: "OP_11 long",
2097                         pop: &parsedOpcode{
2098                                 opcode: &opcodeArray[OP_11],
2099                                 data:   make([]byte, 1),
2100                         },
2101                         expectedErr: scriptError(ErrInternal, ""),
2102                 },
2103                 {
2104                         name: "OP_12",
2105                         pop: &parsedOpcode{
2106                                 opcode: &opcodeArray[OP_12],
2107                                 data:   nil,
2108                         },
2109                         expectedErr: nil,
2110                 },
2111                 {
2112                         name: "OP_12 long",
2113                         pop: &parsedOpcode{
2114                                 opcode: &opcodeArray[OP_12],
2115                                 data:   make([]byte, 1),
2116                         },
2117                         expectedErr: scriptError(ErrInternal, ""),
2118                 },
2119                 {
2120                         name: "OP_13",
2121                         pop: &parsedOpcode{
2122                                 opcode: &opcodeArray[OP_13],
2123                                 data:   nil,
2124                         },
2125                         expectedErr: nil,
2126                 },
2127                 {
2128                         name: "OP_13 long",
2129                         pop: &parsedOpcode{
2130                                 opcode: &opcodeArray[OP_13],
2131                                 data:   make([]byte, 1),
2132                         },
2133                         expectedErr: scriptError(ErrInternal, ""),
2134                 },
2135                 {
2136                         name: "OP_14",
2137                         pop: &parsedOpcode{
2138                                 opcode: &opcodeArray[OP_14],
2139                                 data:   nil,
2140                         },
2141                         expectedErr: nil,
2142                 },
2143                 {
2144                         name: "OP_14 long",
2145                         pop: &parsedOpcode{
2146                                 opcode: &opcodeArray[OP_14],
2147                                 data:   make([]byte, 1),
2148                         },
2149                         expectedErr: scriptError(ErrInternal, ""),
2150                 },
2151                 {
2152                         name: "OP_15",
2153                         pop: &parsedOpcode{
2154                                 opcode: &opcodeArray[OP_15],
2155                                 data:   nil,
2156                         },
2157                         expectedErr: nil,
2158                 },
2159                 {
2160                         name: "OP_15 long",
2161                         pop: &parsedOpcode{
2162                                 opcode: &opcodeArray[OP_15],
2163                                 data:   make([]byte, 1),
2164                         },
2165                         expectedErr: scriptError(ErrInternal, ""),
2166                 },
2167                 {
2168                         name: "OP_16",
2169                         pop: &parsedOpcode{
2170                                 opcode: &opcodeArray[OP_16],
2171                                 data:   nil,
2172                         },
2173                         expectedErr: nil,
2174                 },
2175                 {
2176                         name: "OP_16 long",
2177                         pop: &parsedOpcode{
2178                                 opcode: &opcodeArray[OP_16],
2179                                 data:   make([]byte, 1),
2180                         },
2181                         expectedErr: scriptError(ErrInternal, ""),
2182                 },
2183                 {
2184                         name: "OP_NOP",
2185                         pop: &parsedOpcode{
2186                                 opcode: &opcodeArray[OP_NOP],
2187                                 data:   nil,
2188                         },
2189                         expectedErr: nil,
2190                 },
2191                 {
2192                         name: "OP_NOP long",
2193                         pop: &parsedOpcode{
2194                                 opcode: &opcodeArray[OP_NOP],
2195                                 data:   make([]byte, 1),
2196                         },
2197                         expectedErr: scriptError(ErrInternal, ""),
2198                 },
2199                 {
2200                         name: "OP_VER",
2201                         pop: &parsedOpcode{
2202                                 opcode: &opcodeArray[OP_VER],
2203                                 data:   nil,
2204                         },
2205                         expectedErr: nil,
2206                 },
2207                 {
2208                         name: "OP_VER long",
2209                         pop: &parsedOpcode{
2210                                 opcode: &opcodeArray[OP_VER],
2211                                 data:   make([]byte, 1),
2212                         },
2213                         expectedErr: scriptError(ErrInternal, ""),
2214                 },
2215                 {
2216                         name: "OP_IF",
2217                         pop: &parsedOpcode{
2218                                 opcode: &opcodeArray[OP_IF],
2219                                 data:   nil,
2220                         },
2221                         expectedErr: nil,
2222                 },
2223                 {
2224                         name: "OP_IF long",
2225                         pop: &parsedOpcode{
2226                                 opcode: &opcodeArray[OP_IF],
2227                                 data:   make([]byte, 1),
2228                         },
2229                         expectedErr: scriptError(ErrInternal, ""),
2230                 },
2231                 {
2232                         name: "OP_NOTIF",
2233                         pop: &parsedOpcode{
2234                                 opcode: &opcodeArray[OP_NOTIF],
2235                                 data:   nil,
2236                         },
2237                         expectedErr: nil,
2238                 },
2239                 {
2240                         name: "OP_NOTIF long",
2241                         pop: &parsedOpcode{
2242                                 opcode: &opcodeArray[OP_NOTIF],
2243                                 data:   make([]byte, 1),
2244                         },
2245                         expectedErr: scriptError(ErrInternal, ""),
2246                 },
2247                 {
2248                         name: "OP_VERIF",
2249                         pop: &parsedOpcode{
2250                                 opcode: &opcodeArray[OP_VERIF],
2251                                 data:   nil,
2252                         },
2253                         expectedErr: nil,
2254                 },
2255                 {
2256                         name: "OP_VERIF long",
2257                         pop: &parsedOpcode{
2258                                 opcode: &opcodeArray[OP_VERIF],
2259                                 data:   make([]byte, 1),
2260                         },
2261                         expectedErr: scriptError(ErrInternal, ""),
2262                 },
2263                 {
2264                         name: "OP_VERNOTIF",
2265                         pop: &parsedOpcode{
2266                                 opcode: &opcodeArray[OP_VERNOTIF],
2267                                 data:   nil,
2268                         },
2269                         expectedErr: nil,
2270                 },
2271                 {
2272                         name: "OP_VERNOTIF long",
2273                         pop: &parsedOpcode{
2274                                 opcode: &opcodeArray[OP_VERNOTIF],
2275                                 data:   make([]byte, 1),
2276                         },
2277                         expectedErr: scriptError(ErrInternal, ""),
2278                 },
2279                 {
2280                         name: "OP_ELSE",
2281                         pop: &parsedOpcode{
2282                                 opcode: &opcodeArray[OP_ELSE],
2283                                 data:   nil,
2284                         },
2285                         expectedErr: nil,
2286                 },
2287                 {
2288                         name: "OP_ELSE long",
2289                         pop: &parsedOpcode{
2290                                 opcode: &opcodeArray[OP_ELSE],
2291                                 data:   make([]byte, 1),
2292                         },
2293                         expectedErr: scriptError(ErrInternal, ""),
2294                 },
2295                 {
2296                         name: "OP_ENDIF",
2297                         pop: &parsedOpcode{
2298                                 opcode: &opcodeArray[OP_ENDIF],
2299                                 data:   nil,
2300                         },
2301                         expectedErr: nil,
2302                 },
2303                 {
2304                         name: "OP_ENDIF long",
2305                         pop: &parsedOpcode{
2306                                 opcode: &opcodeArray[OP_ENDIF],
2307                                 data:   make([]byte, 1),
2308                         },
2309                         expectedErr: scriptError(ErrInternal, ""),
2310                 },
2311                 {
2312                         name: "OP_VERIFY",
2313                         pop: &parsedOpcode{
2314                                 opcode: &opcodeArray[OP_VERIFY],
2315                                 data:   nil,
2316                         },
2317                         expectedErr: nil,
2318                 },
2319                 {
2320                         name: "OP_VERIFY long",
2321                         pop: &parsedOpcode{
2322                                 opcode: &opcodeArray[OP_VERIFY],
2323                                 data:   make([]byte, 1),
2324                         },
2325                         expectedErr: scriptError(ErrInternal, ""),
2326                 },
2327                 {
2328                         name: "OP_RETURN",
2329                         pop: &parsedOpcode{
2330                                 opcode: &opcodeArray[OP_RETURN],
2331                                 data:   nil,
2332                         },
2333                         expectedErr: nil,
2334                 },
2335                 {
2336                         name: "OP_RETURN long",
2337                         pop: &parsedOpcode{
2338                                 opcode: &opcodeArray[OP_RETURN],
2339                                 data:   make([]byte, 1),
2340                         },
2341                         expectedErr: scriptError(ErrInternal, ""),
2342                 },
2343                 {
2344                         name: "OP_TOALTSTACK",
2345                         pop: &parsedOpcode{
2346                                 opcode: &opcodeArray[OP_TOALTSTACK],
2347                                 data:   nil,
2348                         },
2349                         expectedErr: nil,
2350                 },
2351                 {
2352                         name: "OP_TOALTSTACK long",
2353                         pop: &parsedOpcode{
2354                                 opcode: &opcodeArray[OP_TOALTSTACK],
2355                                 data:   make([]byte, 1),
2356                         },
2357                         expectedErr: scriptError(ErrInternal, ""),
2358                 },
2359                 {
2360                         name: "OP_FROMALTSTACK",
2361                         pop: &parsedOpcode{
2362                                 opcode: &opcodeArray[OP_FROMALTSTACK],
2363                                 data:   nil,
2364                         },
2365                         expectedErr: nil,
2366                 },
2367                 {
2368                         name: "OP_FROMALTSTACK long",
2369                         pop: &parsedOpcode{
2370                                 opcode: &opcodeArray[OP_FROMALTSTACK],
2371                                 data:   make([]byte, 1),
2372                         },
2373                         expectedErr: scriptError(ErrInternal, ""),
2374                 },
2375                 {
2376                         name: "OP_2DROP",
2377                         pop: &parsedOpcode{
2378                                 opcode: &opcodeArray[OP_2DROP],
2379                                 data:   nil,
2380                         },
2381                         expectedErr: nil,
2382                 },
2383                 {
2384                         name: "OP_2DROP long",
2385                         pop: &parsedOpcode{
2386                                 opcode: &opcodeArray[OP_2DROP],
2387                                 data:   make([]byte, 1),
2388                         },
2389                         expectedErr: scriptError(ErrInternal, ""),
2390                 },
2391                 {
2392                         name: "OP_2DUP",
2393                         pop: &parsedOpcode{
2394                                 opcode: &opcodeArray[OP_2DUP],
2395                                 data:   nil,
2396                         },
2397                         expectedErr: nil,
2398                 },
2399                 {
2400                         name: "OP_2DUP long",
2401                         pop: &parsedOpcode{
2402                                 opcode: &opcodeArray[OP_2DUP],
2403                                 data:   make([]byte, 1),
2404                         },
2405                         expectedErr: scriptError(ErrInternal, ""),
2406                 },
2407                 {
2408                         name: "OP_3DUP",
2409                         pop: &parsedOpcode{
2410                                 opcode: &opcodeArray[OP_3DUP],
2411                                 data:   nil,
2412                         },
2413                         expectedErr: nil,
2414                 },
2415                 {
2416                         name: "OP_3DUP long",
2417                         pop: &parsedOpcode{
2418                                 opcode: &opcodeArray[OP_3DUP],
2419                                 data:   make([]byte, 1),
2420                         },
2421                         expectedErr: scriptError(ErrInternal, ""),
2422                 },
2423                 {
2424                         name: "OP_2OVER",
2425                         pop: &parsedOpcode{
2426                                 opcode: &opcodeArray[OP_2OVER],
2427                                 data:   nil,
2428                         },
2429                         expectedErr: nil,
2430                 },
2431                 {
2432                         name: "OP_2OVER long",
2433                         pop: &parsedOpcode{
2434                                 opcode: &opcodeArray[OP_2OVER],
2435                                 data:   make([]byte, 1),
2436                         },
2437                         expectedErr: scriptError(ErrInternal, ""),
2438                 },
2439                 {
2440                         name: "OP_2ROT",
2441                         pop: &parsedOpcode{
2442                                 opcode: &opcodeArray[OP_2ROT],
2443                                 data:   nil,
2444                         },
2445                         expectedErr: nil,
2446                 },
2447                 {
2448                         name: "OP_2ROT long",
2449                         pop: &parsedOpcode{
2450                                 opcode: &opcodeArray[OP_2ROT],
2451                                 data:   make([]byte, 1),
2452                         },
2453                         expectedErr: scriptError(ErrInternal, ""),
2454                 },
2455                 {
2456                         name: "OP_2SWAP",
2457                         pop: &parsedOpcode{
2458                                 opcode: &opcodeArray[OP_2SWAP],
2459                                 data:   nil,
2460                         },
2461                         expectedErr: nil,
2462                 },
2463                 {
2464                         name: "OP_2SWAP long",
2465                         pop: &parsedOpcode{
2466                                 opcode: &opcodeArray[OP_2SWAP],
2467                                 data:   make([]byte, 1),
2468                         },
2469                         expectedErr: scriptError(ErrInternal, ""),
2470                 },
2471                 {
2472                         name: "OP_IFDUP",
2473                         pop: &parsedOpcode{
2474                                 opcode: &opcodeArray[OP_IFDUP],
2475                                 data:   nil,
2476                         },
2477                         expectedErr: nil,
2478                 },
2479                 {
2480                         name: "OP_IFDUP long",
2481                         pop: &parsedOpcode{
2482                                 opcode: &opcodeArray[OP_IFDUP],
2483                                 data:   make([]byte, 1),
2484                         },
2485                         expectedErr: scriptError(ErrInternal, ""),
2486                 },
2487                 {
2488                         name: "OP_DEPTH",
2489                         pop: &parsedOpcode{
2490                                 opcode: &opcodeArray[OP_DEPTH],
2491                                 data:   nil,
2492                         },
2493                         expectedErr: nil,
2494                 },
2495                 {
2496                         name: "OP_DEPTH long",
2497                         pop: &parsedOpcode{
2498                                 opcode: &opcodeArray[OP_DEPTH],
2499                                 data:   make([]byte, 1),
2500                         },
2501                         expectedErr: scriptError(ErrInternal, ""),
2502                 },
2503                 {
2504                         name: "OP_DROP",
2505                         pop: &parsedOpcode{
2506                                 opcode: &opcodeArray[OP_DROP],
2507                                 data:   nil,
2508                         },
2509                         expectedErr: nil,
2510                 },
2511                 {
2512                         name: "OP_DROP long",
2513                         pop: &parsedOpcode{
2514                                 opcode: &opcodeArray[OP_DROP],
2515                                 data:   make([]byte, 1),
2516                         },
2517                         expectedErr: scriptError(ErrInternal, ""),
2518                 },
2519                 {
2520                         name: "OP_DUP",
2521                         pop: &parsedOpcode{
2522                                 opcode: &opcodeArray[OP_DUP],
2523                                 data:   nil,
2524                         },
2525                         expectedErr: nil,
2526                 },
2527                 {
2528                         name: "OP_DUP long",
2529                         pop: &parsedOpcode{
2530                                 opcode: &opcodeArray[OP_DUP],
2531                                 data:   make([]byte, 1),
2532                         },
2533                         expectedErr: scriptError(ErrInternal, ""),
2534                 },
2535                 {
2536                         name: "OP_NIP",
2537                         pop: &parsedOpcode{
2538                                 opcode: &opcodeArray[OP_NIP],
2539                                 data:   nil,
2540                         },
2541                         expectedErr: nil,
2542                 },
2543                 {
2544                         name: "OP_NIP long",
2545                         pop: &parsedOpcode{
2546                                 opcode: &opcodeArray[OP_NIP],
2547                                 data:   make([]byte, 1),
2548                         },
2549                         expectedErr: scriptError(ErrInternal, ""),
2550                 },
2551                 {
2552                         name: "OP_OVER",
2553                         pop: &parsedOpcode{
2554                                 opcode: &opcodeArray[OP_OVER],
2555                                 data:   nil,
2556                         },
2557                         expectedErr: nil,
2558                 },
2559                 {
2560                         name: "OP_OVER long",
2561                         pop: &parsedOpcode{
2562                                 opcode: &opcodeArray[OP_OVER],
2563                                 data:   make([]byte, 1),
2564                         },
2565                         expectedErr: scriptError(ErrInternal, ""),
2566                 },
2567                 {
2568                         name: "OP_PICK",
2569                         pop: &parsedOpcode{
2570                                 opcode: &opcodeArray[OP_PICK],
2571                                 data:   nil,
2572                         },
2573                         expectedErr: nil,
2574                 },
2575                 {
2576                         name: "OP_PICK long",
2577                         pop: &parsedOpcode{
2578                                 opcode: &opcodeArray[OP_PICK],
2579                                 data:   make([]byte, 1),
2580                         },
2581                         expectedErr: scriptError(ErrInternal, ""),
2582                 },
2583                 {
2584                         name: "OP_ROLL",
2585                         pop: &parsedOpcode{
2586                                 opcode: &opcodeArray[OP_ROLL],
2587                                 data:   nil,
2588                         },
2589                         expectedErr: nil,
2590                 },
2591                 {
2592                         name: "OP_ROLL long",
2593                         pop: &parsedOpcode{
2594                                 opcode: &opcodeArray[OP_ROLL],
2595                                 data:   make([]byte, 1),
2596                         },
2597                         expectedErr: scriptError(ErrInternal, ""),
2598                 },
2599                 {
2600                         name: "OP_ROT",
2601                         pop: &parsedOpcode{
2602                                 opcode: &opcodeArray[OP_ROT],
2603                                 data:   nil,
2604                         },
2605                         expectedErr: nil,
2606                 },
2607                 {
2608                         name: "OP_ROT long",
2609                         pop: &parsedOpcode{
2610                                 opcode: &opcodeArray[OP_ROT],
2611                                 data:   make([]byte, 1),
2612                         },
2613                         expectedErr: scriptError(ErrInternal, ""),
2614                 },
2615                 {
2616                         name: "OP_SWAP",
2617                         pop: &parsedOpcode{
2618                                 opcode: &opcodeArray[OP_SWAP],
2619                                 data:   nil,
2620                         },
2621                         expectedErr: nil,
2622                 },
2623                 {
2624                         name: "OP_SWAP long",
2625                         pop: &parsedOpcode{
2626                                 opcode: &opcodeArray[OP_SWAP],
2627                                 data:   make([]byte, 1),
2628                         },
2629                         expectedErr: scriptError(ErrInternal, ""),
2630                 },
2631                 {
2632                         name: "OP_TUCK",
2633                         pop: &parsedOpcode{
2634                                 opcode: &opcodeArray[OP_TUCK],
2635                                 data:   nil,
2636                         },
2637                         expectedErr: nil,
2638                 },
2639                 {
2640                         name: "OP_TUCK long",
2641                         pop: &parsedOpcode{
2642                                 opcode: &opcodeArray[OP_TUCK],
2643                                 data:   make([]byte, 1),
2644                         },
2645                         expectedErr: scriptError(ErrInternal, ""),
2646                 },
2647                 {
2648                         name: "OP_CAT",
2649                         pop: &parsedOpcode{
2650                                 opcode: &opcodeArray[OP_CAT],
2651                                 data:   nil,
2652                         },
2653                         expectedErr: nil,
2654                 },
2655                 {
2656                         name: "OP_CAT long",
2657                         pop: &parsedOpcode{
2658                                 opcode: &opcodeArray[OP_CAT],
2659                                 data:   make([]byte, 1),
2660                         },
2661                         expectedErr: scriptError(ErrInternal, ""),
2662                 },
2663                 {
2664                         name: "OP_SUBSTR",
2665                         pop: &parsedOpcode{
2666                                 opcode: &opcodeArray[OP_SUBSTR],
2667                                 data:   nil,
2668                         },
2669                         expectedErr: nil,
2670                 },
2671                 {
2672                         name: "OP_SUBSTR long",
2673                         pop: &parsedOpcode{
2674                                 opcode: &opcodeArray[OP_SUBSTR],
2675                                 data:   make([]byte, 1),
2676                         },
2677                         expectedErr: scriptError(ErrInternal, ""),
2678                 },
2679                 {
2680                         name: "OP_LEFT",
2681                         pop: &parsedOpcode{
2682                                 opcode: &opcodeArray[OP_LEFT],
2683                                 data:   nil,
2684                         },
2685                         expectedErr: nil,
2686                 },
2687                 {
2688                         name: "OP_LEFT long",
2689                         pop: &parsedOpcode{
2690                                 opcode: &opcodeArray[OP_LEFT],
2691                                 data:   make([]byte, 1),
2692                         },
2693                         expectedErr: scriptError(ErrInternal, ""),
2694                 },
2695                 {
2696                         name: "OP_LEFT",
2697                         pop: &parsedOpcode{
2698                                 opcode: &opcodeArray[OP_LEFT],
2699                                 data:   nil,
2700                         },
2701                         expectedErr: nil,
2702                 },
2703                 {
2704                         name: "OP_LEFT long",
2705                         pop: &parsedOpcode{
2706                                 opcode: &opcodeArray[OP_LEFT],
2707                                 data:   make([]byte, 1),
2708                         },
2709                         expectedErr: scriptError(ErrInternal, ""),
2710                 },
2711                 {
2712                         name: "OP_RIGHT",
2713                         pop: &parsedOpcode{
2714                                 opcode: &opcodeArray[OP_RIGHT],
2715                                 data:   nil,
2716                         },
2717                         expectedErr: nil,
2718                 },
2719                 {
2720                         name: "OP_RIGHT long",
2721                         pop: &parsedOpcode{
2722                                 opcode: &opcodeArray[OP_RIGHT],
2723                                 data:   make([]byte, 1),
2724                         },
2725                         expectedErr: scriptError(ErrInternal, ""),
2726                 },
2727                 {
2728                         name: "OP_SIZE",
2729                         pop: &parsedOpcode{
2730                                 opcode: &opcodeArray[OP_SIZE],
2731                                 data:   nil,
2732                         },
2733                         expectedErr: nil,
2734                 },
2735                 {
2736                         name: "OP_SIZE long",
2737                         pop: &parsedOpcode{
2738                                 opcode: &opcodeArray[OP_SIZE],
2739                                 data:   make([]byte, 1),
2740                         },
2741                         expectedErr: scriptError(ErrInternal, ""),
2742                 },
2743                 {
2744                         name: "OP_INVERT",
2745                         pop: &parsedOpcode{
2746                                 opcode: &opcodeArray[OP_INVERT],
2747                                 data:   nil,
2748                         },
2749                         expectedErr: nil,
2750                 },
2751                 {
2752                         name: "OP_INVERT long",
2753                         pop: &parsedOpcode{
2754                                 opcode: &opcodeArray[OP_INVERT],
2755                                 data:   make([]byte, 1),
2756                         },
2757                         expectedErr: scriptError(ErrInternal, ""),
2758                 },
2759                 {
2760                         name: "OP_AND",
2761                         pop: &parsedOpcode{
2762                                 opcode: &opcodeArray[OP_AND],
2763                                 data:   nil,
2764                         },
2765                         expectedErr: nil,
2766                 },
2767                 {
2768                         name: "OP_AND long",
2769                         pop: &parsedOpcode{
2770                                 opcode: &opcodeArray[OP_AND],
2771                                 data:   make([]byte, 1),
2772                         },
2773                         expectedErr: scriptError(ErrInternal, ""),
2774                 },
2775                 {
2776                         name: "OP_OR",
2777                         pop: &parsedOpcode{
2778                                 opcode: &opcodeArray[OP_OR],
2779                                 data:   nil,
2780                         },
2781                         expectedErr: nil,
2782                 },
2783                 {
2784                         name: "OP_OR long",
2785                         pop: &parsedOpcode{
2786                                 opcode: &opcodeArray[OP_OR],
2787                                 data:   make([]byte, 1),
2788                         },
2789                         expectedErr: scriptError(ErrInternal, ""),
2790                 },
2791                 {
2792                         name: "OP_XOR",
2793                         pop: &parsedOpcode{
2794                                 opcode: &opcodeArray[OP_XOR],
2795                                 data:   nil,
2796                         },
2797                         expectedErr: nil,
2798                 },
2799                 {
2800                         name: "OP_XOR long",
2801                         pop: &parsedOpcode{
2802                                 opcode: &opcodeArray[OP_XOR],
2803                                 data:   make([]byte, 1),
2804                         },
2805                         expectedErr: scriptError(ErrInternal, ""),
2806                 },
2807                 {
2808                         name: "OP_EQUAL",
2809                         pop: &parsedOpcode{
2810                                 opcode: &opcodeArray[OP_EQUAL],
2811                                 data:   nil,
2812                         },
2813                         expectedErr: nil,
2814                 },
2815                 {
2816                         name: "OP_EQUAL long",
2817                         pop: &parsedOpcode{
2818                                 opcode: &opcodeArray[OP_EQUAL],
2819                                 data:   make([]byte, 1),
2820                         },
2821                         expectedErr: scriptError(ErrInternal, ""),
2822                 },
2823                 {
2824                         name: "OP_EQUALVERIFY",
2825                         pop: &parsedOpcode{
2826                                 opcode: &opcodeArray[OP_EQUALVERIFY],
2827                                 data:   nil,
2828                         },
2829                         expectedErr: nil,
2830                 },
2831                 {
2832                         name: "OP_EQUALVERIFY long",
2833                         pop: &parsedOpcode{
2834                                 opcode: &opcodeArray[OP_EQUALVERIFY],
2835                                 data:   make([]byte, 1),
2836                         },
2837                         expectedErr: scriptError(ErrInternal, ""),
2838                 },
2839                 {
2840                         name: "OP_RESERVED1",
2841                         pop: &parsedOpcode{
2842                                 opcode: &opcodeArray[OP_RESERVED1],
2843                                 data:   nil,
2844                         },
2845                         expectedErr: nil,
2846                 },
2847                 {
2848                         name: "OP_RESERVED1 long",
2849                         pop: &parsedOpcode{
2850                                 opcode: &opcodeArray[OP_RESERVED1],
2851                                 data:   make([]byte, 1),
2852                         },
2853                         expectedErr: scriptError(ErrInternal, ""),
2854                 },
2855                 {
2856                         name: "OP_RESERVED2",
2857                         pop: &parsedOpcode{
2858                                 opcode: &opcodeArray[OP_RESERVED2],
2859                                 data:   nil,
2860                         },
2861                         expectedErr: nil,
2862                 },
2863                 {
2864                         name: "OP_RESERVED2 long",
2865                         pop: &parsedOpcode{
2866                                 opcode: &opcodeArray[OP_RESERVED2],
2867                                 data:   make([]byte, 1),
2868                         },
2869                         expectedErr: scriptError(ErrInternal, ""),
2870                 },
2871                 {
2872                         name: "OP_1ADD",
2873                         pop: &parsedOpcode{
2874                                 opcode: &opcodeArray[OP_1ADD],
2875                                 data:   nil,
2876                         },
2877                         expectedErr: nil,
2878                 },
2879                 {
2880                         name: "OP_1ADD long",
2881                         pop: &parsedOpcode{
2882                                 opcode: &opcodeArray[OP_1ADD],
2883                                 data:   make([]byte, 1),
2884                         },
2885                         expectedErr: scriptError(ErrInternal, ""),
2886                 },
2887                 {
2888                         name: "OP_1SUB",
2889                         pop: &parsedOpcode{
2890                                 opcode: &opcodeArray[OP_1SUB],
2891                                 data:   nil,
2892                         },
2893                         expectedErr: nil,
2894                 },
2895                 {
2896                         name: "OP_1SUB long",
2897                         pop: &parsedOpcode{
2898                                 opcode: &opcodeArray[OP_1SUB],
2899                                 data:   make([]byte, 1),
2900                         },
2901                         expectedErr: scriptError(ErrInternal, ""),
2902                 },
2903                 {
2904                         name: "OP_2MUL",
2905                         pop: &parsedOpcode{
2906                                 opcode: &opcodeArray[OP_2MUL],
2907                                 data:   nil,
2908                         },
2909                         expectedErr: nil,
2910                 },
2911                 {
2912                         name: "OP_2MUL long",
2913                         pop: &parsedOpcode{
2914                                 opcode: &opcodeArray[OP_2MUL],
2915                                 data:   make([]byte, 1),
2916                         },
2917                         expectedErr: scriptError(ErrInternal, ""),
2918                 },
2919                 {
2920                         name: "OP_2DIV",
2921                         pop: &parsedOpcode{
2922                                 opcode: &opcodeArray[OP_2DIV],
2923                                 data:   nil,
2924                         },
2925                         expectedErr: nil,
2926                 },
2927                 {
2928                         name: "OP_2DIV long",
2929                         pop: &parsedOpcode{
2930                                 opcode: &opcodeArray[OP_2DIV],
2931                                 data:   make([]byte, 1),
2932                         },
2933                         expectedErr: scriptError(ErrInternal, ""),
2934                 },
2935                 {
2936                         name: "OP_NEGATE",
2937                         pop: &parsedOpcode{
2938                                 opcode: &opcodeArray[OP_NEGATE],
2939                                 data:   nil,
2940                         },
2941                         expectedErr: nil,
2942                 },
2943                 {
2944                         name: "OP_NEGATE long",
2945                         pop: &parsedOpcode{
2946                                 opcode: &opcodeArray[OP_NEGATE],
2947                                 data:   make([]byte, 1),
2948                         },
2949                         expectedErr: scriptError(ErrInternal, ""),
2950                 },
2951                 {
2952                         name: "OP_ABS",
2953                         pop: &parsedOpcode{
2954                                 opcode: &opcodeArray[OP_ABS],
2955                                 data:   nil,
2956                         },
2957                         expectedErr: nil,
2958                 },
2959                 {
2960                         name: "OP_ABS long",
2961                         pop: &parsedOpcode{
2962                                 opcode: &opcodeArray[OP_ABS],
2963                                 data:   make([]byte, 1),
2964                         },
2965                         expectedErr: scriptError(ErrInternal, ""),
2966                 },
2967                 {
2968                         name: "OP_NOT",
2969                         pop: &parsedOpcode{
2970                                 opcode: &opcodeArray[OP_NOT],
2971                                 data:   nil,
2972                         },
2973                         expectedErr: nil,
2974                 },
2975                 {
2976                         name: "OP_NOT long",
2977                         pop: &parsedOpcode{
2978                                 opcode: &opcodeArray[OP_NOT],
2979                                 data:   make([]byte, 1),
2980                         },
2981                         expectedErr: scriptError(ErrInternal, ""),
2982                 },
2983                 {
2984                         name: "OP_0NOTEQUAL",
2985                         pop: &parsedOpcode{
2986                                 opcode: &opcodeArray[OP_0NOTEQUAL],
2987                                 data:   nil,
2988                         },
2989                         expectedErr: nil,
2990                 },
2991                 {
2992                         name: "OP_0NOTEQUAL long",
2993                         pop: &parsedOpcode{
2994                                 opcode: &opcodeArray[OP_0NOTEQUAL],
2995                                 data:   make([]byte, 1),
2996                         },
2997                         expectedErr: scriptError(ErrInternal, ""),
2998                 },
2999                 {
3000                         name: "OP_ADD",
3001                         pop: &parsedOpcode{
3002                                 opcode: &opcodeArray[OP_ADD],
3003                                 data:   nil,
3004                         },
3005                         expectedErr: nil,
3006                 },
3007                 {
3008                         name: "OP_ADD long",
3009                         pop: &parsedOpcode{
3010                                 opcode: &opcodeArray[OP_ADD],
3011                                 data:   make([]byte, 1),
3012                         },
3013                         expectedErr: scriptError(ErrInternal, ""),
3014                 },
3015                 {
3016                         name: "OP_SUB",
3017                         pop: &parsedOpcode{
3018                                 opcode: &opcodeArray[OP_SUB],
3019                                 data:   nil,
3020                         },
3021                         expectedErr: nil,
3022                 },
3023                 {
3024                         name: "OP_SUB long",
3025                         pop: &parsedOpcode{
3026                                 opcode: &opcodeArray[OP_SUB],
3027                                 data:   make([]byte, 1),
3028                         },
3029                         expectedErr: scriptError(ErrInternal, ""),
3030                 },
3031                 {
3032                         name: "OP_MUL",
3033                         pop: &parsedOpcode{
3034                                 opcode: &opcodeArray[OP_MUL],
3035                                 data:   nil,
3036                         },
3037                         expectedErr: nil,
3038                 },
3039                 {
3040                         name: "OP_MUL long",
3041                         pop: &parsedOpcode{
3042                                 opcode: &opcodeArray[OP_MUL],
3043                                 data:   make([]byte, 1),
3044                         },
3045                         expectedErr: scriptError(ErrInternal, ""),
3046                 },
3047                 {
3048                         name: "OP_DIV",
3049                         pop: &parsedOpcode{
3050                                 opcode: &opcodeArray[OP_DIV],
3051                                 data:   nil,
3052                         },
3053                         expectedErr: nil,
3054                 },
3055                 {
3056                         name: "OP_DIV long",
3057                         pop: &parsedOpcode{
3058                                 opcode: &opcodeArray[OP_DIV],
3059                                 data:   make([]byte, 1),
3060                         },
3061                         expectedErr: scriptError(ErrInternal, ""),
3062                 },
3063                 {
3064                         name: "OP_MOD",
3065                         pop: &parsedOpcode{
3066                                 opcode: &opcodeArray[OP_MOD],
3067                                 data:   nil,
3068                         },
3069                         expectedErr: nil,
3070                 },
3071                 {
3072                         name: "OP_MOD long",
3073                         pop: &parsedOpcode{
3074                                 opcode: &opcodeArray[OP_MOD],
3075                                 data:   make([]byte, 1),
3076                         },
3077                         expectedErr: scriptError(ErrInternal, ""),
3078                 },
3079                 {
3080                         name: "OP_LSHIFT",
3081                         pop: &parsedOpcode{
3082                                 opcode: &opcodeArray[OP_LSHIFT],
3083                                 data:   nil,
3084                         },
3085                         expectedErr: nil,
3086                 },
3087                 {
3088                         name: "OP_LSHIFT long",
3089                         pop: &parsedOpcode{
3090                                 opcode: &opcodeArray[OP_LSHIFT],
3091                                 data:   make([]byte, 1),
3092                         },
3093                         expectedErr: scriptError(ErrInternal, ""),
3094                 },
3095                 {
3096                         name: "OP_RSHIFT",
3097                         pop: &parsedOpcode{
3098                                 opcode: &opcodeArray[OP_RSHIFT],
3099                                 data:   nil,
3100                         },
3101                         expectedErr: nil,
3102                 },
3103                 {
3104                         name: "OP_RSHIFT long",
3105                         pop: &parsedOpcode{
3106                                 opcode: &opcodeArray[OP_RSHIFT],
3107                                 data:   make([]byte, 1),
3108                         },
3109                         expectedErr: scriptError(ErrInternal, ""),
3110                 },
3111                 {
3112                         name: "OP_BOOLAND",
3113                         pop: &parsedOpcode{
3114                                 opcode: &opcodeArray[OP_BOOLAND],
3115                                 data:   nil,
3116                         },
3117                         expectedErr: nil,
3118                 },
3119                 {
3120                         name: "OP_BOOLAND long",
3121                         pop: &parsedOpcode{
3122                                 opcode: &opcodeArray[OP_BOOLAND],
3123                                 data:   make([]byte, 1),
3124                         },
3125                         expectedErr: scriptError(ErrInternal, ""),
3126                 },
3127                 {
3128                         name: "OP_BOOLOR",
3129                         pop: &parsedOpcode{
3130                                 opcode: &opcodeArray[OP_BOOLOR],
3131                                 data:   nil,
3132                         },
3133                         expectedErr: nil,
3134                 },
3135                 {
3136                         name: "OP_BOOLOR long",
3137                         pop: &parsedOpcode{
3138                                 opcode: &opcodeArray[OP_BOOLOR],
3139                                 data:   make([]byte, 1),
3140                         },
3141                         expectedErr: scriptError(ErrInternal, ""),
3142                 },
3143                 {
3144                         name: "OP_NUMEQUAL",
3145                         pop: &parsedOpcode{
3146                                 opcode: &opcodeArray[OP_NUMEQUAL],
3147                                 data:   nil,
3148                         },
3149                         expectedErr: nil,
3150                 },
3151                 {
3152                         name: "OP_NUMEQUAL long",
3153                         pop: &parsedOpcode{
3154                                 opcode: &opcodeArray[OP_NUMEQUAL],
3155                                 data:   make([]byte, 1),
3156                         },
3157                         expectedErr: scriptError(ErrInternal, ""),
3158                 },
3159                 {
3160                         name: "OP_NUMEQUALVERIFY",
3161                         pop: &parsedOpcode{
3162                                 opcode: &opcodeArray[OP_NUMEQUALVERIFY],
3163                                 data:   nil,
3164                         },
3165                         expectedErr: nil,
3166                 },
3167                 {
3168                         name: "OP_NUMEQUALVERIFY long",
3169                         pop: &parsedOpcode{
3170                                 opcode: &opcodeArray[OP_NUMEQUALVERIFY],
3171                                 data:   make([]byte, 1),
3172                         },
3173                         expectedErr: scriptError(ErrInternal, ""),
3174                 },
3175                 {
3176                         name: "OP_NUMNOTEQUAL",
3177                         pop: &parsedOpcode{
3178                                 opcode: &opcodeArray[OP_NUMNOTEQUAL],
3179                                 data:   nil,
3180                         },
3181                         expectedErr: nil,
3182                 },
3183                 {
3184                         name: "OP_NUMNOTEQUAL long",
3185                         pop: &parsedOpcode{
3186                                 opcode: &opcodeArray[OP_NUMNOTEQUAL],
3187                                 data:   make([]byte, 1),
3188                         },
3189                         expectedErr: scriptError(ErrInternal, ""),
3190                 },
3191                 {
3192                         name: "OP_LESSTHAN",
3193                         pop: &parsedOpcode{
3194                                 opcode: &opcodeArray[OP_LESSTHAN],
3195                                 data:   nil,
3196                         },
3197                         expectedErr: nil,
3198                 },
3199                 {
3200                         name: "OP_LESSTHAN long",
3201                         pop: &parsedOpcode{
3202                                 opcode: &opcodeArray[OP_LESSTHAN],
3203                                 data:   make([]byte, 1),
3204                         },
3205                         expectedErr: scriptError(ErrInternal, ""),
3206                 },
3207                 {
3208                         name: "OP_GREATERTHAN",
3209                         pop: &parsedOpcode{
3210                                 opcode: &opcodeArray[OP_GREATERTHAN],
3211                                 data:   nil,
3212                         },
3213                         expectedErr: nil,
3214                 },
3215                 {
3216                         name: "OP_GREATERTHAN long",
3217                         pop: &parsedOpcode{
3218                                 opcode: &opcodeArray[OP_GREATERTHAN],
3219                                 data:   make([]byte, 1),
3220                         },
3221                         expectedErr: scriptError(ErrInternal, ""),
3222                 },
3223                 {
3224                         name: "OP_LESSTHANOREQUAL",
3225                         pop: &parsedOpcode{
3226                                 opcode: &opcodeArray[OP_LESSTHANOREQUAL],
3227                                 data:   nil,
3228                         },
3229                         expectedErr: nil,
3230                 },
3231                 {
3232                         name: "OP_LESSTHANOREQUAL long",
3233                         pop: &parsedOpcode{
3234                                 opcode: &opcodeArray[OP_LESSTHANOREQUAL],
3235                                 data:   make([]byte, 1),
3236                         },
3237                         expectedErr: scriptError(ErrInternal, ""),
3238                 },
3239                 {
3240                         name: "OP_GREATERTHANOREQUAL",
3241                         pop: &parsedOpcode{
3242                                 opcode: &opcodeArray[OP_GREATERTHANOREQUAL],
3243                                 data:   nil,
3244                         },
3245                         expectedErr: nil,
3246                 },
3247                 {
3248                         name: "OP_GREATERTHANOREQUAL long",
3249                         pop: &parsedOpcode{
3250                                 opcode: &opcodeArray[OP_GREATERTHANOREQUAL],
3251                                 data:   make([]byte, 1),
3252                         },
3253                         expectedErr: scriptError(ErrInternal, ""),
3254                 },
3255                 {
3256                         name: "OP_MIN",
3257                         pop: &parsedOpcode{
3258                                 opcode: &opcodeArray[OP_MIN],
3259                                 data:   nil,
3260                         },
3261                         expectedErr: nil,
3262                 },
3263                 {
3264                         name: "OP_MIN long",
3265                         pop: &parsedOpcode{
3266                                 opcode: &opcodeArray[OP_MIN],
3267                                 data:   make([]byte, 1),
3268                         },
3269                         expectedErr: scriptError(ErrInternal, ""),
3270                 },
3271                 {
3272                         name: "OP_MAX",
3273                         pop: &parsedOpcode{
3274                                 opcode: &opcodeArray[OP_MAX],
3275                                 data:   nil,
3276                         },
3277                         expectedErr: nil,
3278                 },
3279                 {
3280                         name: "OP_MAX long",
3281                         pop: &parsedOpcode{
3282                                 opcode: &opcodeArray[OP_MAX],
3283                                 data:   make([]byte, 1),
3284                         },
3285                         expectedErr: scriptError(ErrInternal, ""),
3286                 },
3287                 {
3288                         name: "OP_WITHIN",
3289                         pop: &parsedOpcode{
3290                                 opcode: &opcodeArray[OP_WITHIN],
3291                                 data:   nil,
3292                         },
3293                         expectedErr: nil,
3294                 },
3295                 {
3296                         name: "OP_WITHIN long",
3297                         pop: &parsedOpcode{
3298                                 opcode: &opcodeArray[OP_WITHIN],
3299                                 data:   make([]byte, 1),
3300                         },
3301                         expectedErr: scriptError(ErrInternal, ""),
3302                 },
3303                 {
3304                         name: "OP_RIPEMD160",
3305                         pop: &parsedOpcode{
3306                                 opcode: &opcodeArray[OP_RIPEMD160],
3307                                 data:   nil,
3308                         },
3309                         expectedErr: nil,
3310                 },
3311                 {
3312                         name: "OP_RIPEMD160 long",
3313                         pop: &parsedOpcode{
3314                                 opcode: &opcodeArray[OP_RIPEMD160],
3315                                 data:   make([]byte, 1),
3316                         },
3317                         expectedErr: scriptError(ErrInternal, ""),
3318                 },
3319                 {
3320                         name: "OP_SHA1",
3321                         pop: &parsedOpcode{
3322                                 opcode: &opcodeArray[OP_SHA1],
3323                                 data:   nil,
3324                         },
3325                         expectedErr: nil,
3326                 },
3327                 {
3328                         name: "OP_SHA1 long",
3329                         pop: &parsedOpcode{
3330                                 opcode: &opcodeArray[OP_SHA1],
3331                                 data:   make([]byte, 1),
3332                         },
3333                         expectedErr: scriptError(ErrInternal, ""),
3334                 },
3335                 {
3336                         name: "OP_SHA256",
3337                         pop: &parsedOpcode{
3338                                 opcode: &opcodeArray[OP_SHA256],
3339                                 data:   nil,
3340                         },
3341                         expectedErr: nil,
3342                 },
3343                 {
3344                         name: "OP_SHA256 long",
3345                         pop: &parsedOpcode{
3346                                 opcode: &opcodeArray[OP_SHA256],
3347                                 data:   make([]byte, 1),
3348                         },
3349                         expectedErr: scriptError(ErrInternal, ""),
3350                 },
3351                 {
3352                         name: "OP_HASH160",
3353                         pop: &parsedOpcode{
3354                                 opcode: &opcodeArray[OP_HASH160],
3355                                 data:   nil,
3356                         },
3357                         expectedErr: nil,
3358                 },
3359                 {
3360                         name: "OP_HASH160 long",
3361                         pop: &parsedOpcode{
3362                                 opcode: &opcodeArray[OP_HASH160],
3363                                 data:   make([]byte, 1),
3364                         },
3365                         expectedErr: scriptError(ErrInternal, ""),
3366                 },
3367                 {
3368                         name: "OP_HASH256",
3369                         pop: &parsedOpcode{
3370                                 opcode: &opcodeArray[OP_HASH256],
3371                                 data:   nil,
3372                         },
3373                         expectedErr: nil,
3374                 },
3375                 {
3376                         name: "OP_HASH256 long",
3377                         pop: &parsedOpcode{
3378                                 opcode: &opcodeArray[OP_HASH256],
3379                                 data:   make([]byte, 1),
3380                         },
3381                         expectedErr: scriptError(ErrInternal, ""),
3382                 },
3383                 {
3384                         name: "OP_CODESAPERATOR",
3385                         pop: &parsedOpcode{
3386                                 opcode: &opcodeArray[OP_CODESEPARATOR],
3387                                 data:   nil,
3388                         },
3389                         expectedErr: nil,
3390                 },
3391                 {
3392                         name: "OP_CODESEPARATOR long",
3393                         pop: &parsedOpcode{
3394                                 opcode: &opcodeArray[OP_CODESEPARATOR],
3395                                 data:   make([]byte, 1),
3396                         },
3397                         expectedErr: scriptError(ErrInternal, ""),
3398                 },
3399                 {
3400                         name: "OP_CHECKSIG",
3401                         pop: &parsedOpcode{
3402                                 opcode: &opcodeArray[OP_CHECKSIG],
3403                                 data:   nil,
3404                         },
3405                         expectedErr: nil,
3406                 },
3407                 {
3408                         name: "OP_CHECKSIG long",
3409                         pop: &parsedOpcode{
3410                                 opcode: &opcodeArray[OP_CHECKSIG],
3411                                 data:   make([]byte, 1),
3412                         },
3413                         expectedErr: scriptError(ErrInternal, ""),
3414                 },
3415                 {
3416                         name: "OP_CHECKSIGVERIFY",
3417                         pop: &parsedOpcode{
3418                                 opcode: &opcodeArray[OP_CHECKSIGVERIFY],
3419                                 data:   nil,
3420                         },
3421                         expectedErr: nil,
3422                 },
3423                 {
3424                         name: "OP_CHECKSIGVERIFY long",
3425                         pop: &parsedOpcode{
3426                                 opcode: &opcodeArray[OP_CHECKSIGVERIFY],
3427                                 data:   make([]byte, 1),
3428                         },
3429                         expectedErr: scriptError(ErrInternal, ""),
3430                 },
3431                 {
3432                         name: "OP_CHECKMULTISIG",
3433                         pop: &parsedOpcode{
3434                                 opcode: &opcodeArray[OP_CHECKMULTISIG],
3435                                 data:   nil,
3436                         },
3437                         expectedErr: nil,
3438                 },
3439                 {
3440                         name: "OP_CHECKMULTISIG long",
3441                         pop: &parsedOpcode{
3442                                 opcode: &opcodeArray[OP_CHECKMULTISIG],
3443                                 data:   make([]byte, 1),
3444                         },
3445                         expectedErr: scriptError(ErrInternal, ""),
3446                 },
3447                 {
3448                         name: "OP_CHECKMULTISIGVERIFY",
3449                         pop: &parsedOpcode{
3450                                 opcode: &opcodeArray[OP_CHECKMULTISIGVERIFY],
3451                                 data:   nil,
3452                         },
3453                         expectedErr: nil,
3454                 },
3455                 {
3456                         name: "OP_CHECKMULTISIGVERIFY long",
3457                         pop: &parsedOpcode{
3458                                 opcode: &opcodeArray[OP_CHECKMULTISIGVERIFY],
3459                                 data:   make([]byte, 1),
3460                         },
3461                         expectedErr: scriptError(ErrInternal, ""),
3462                 },
3463                 {
3464                         name: "OP_NOP1",
3465                         pop: &parsedOpcode{
3466                                 opcode: &opcodeArray[OP_NOP1],
3467                                 data:   nil,
3468                         },
3469                         expectedErr: nil,
3470                 },
3471                 {
3472                         name: "OP_NOP1 long",
3473                         pop: &parsedOpcode{
3474                                 opcode: &opcodeArray[OP_NOP1],
3475                                 data:   make([]byte, 1),
3476                         },
3477                         expectedErr: scriptError(ErrInternal, ""),
3478                 },
3479                 {
3480                         name: "OP_NOP2",
3481                         pop: &parsedOpcode{
3482                                 opcode: &opcodeArray[OP_NOP2],
3483                                 data:   nil,
3484                         },
3485                         expectedErr: nil,
3486                 },
3487                 {
3488                         name: "OP_NOP2 long",
3489                         pop: &parsedOpcode{
3490                                 opcode: &opcodeArray[OP_NOP2],
3491                                 data:   make([]byte, 1),
3492                         },
3493                         expectedErr: scriptError(ErrInternal, ""),
3494                 },
3495                 {
3496                         name: "OP_NOP3",
3497                         pop: &parsedOpcode{
3498                                 opcode: &opcodeArray[OP_NOP3],
3499                                 data:   nil,
3500                         },
3501                         expectedErr: nil,
3502                 },
3503                 {
3504                         name: "OP_NOP3 long",
3505                         pop: &parsedOpcode{
3506                                 opcode: &opcodeArray[OP_NOP3],
3507                                 data:   make([]byte, 1),
3508                         },
3509                         expectedErr: scriptError(ErrInternal, ""),
3510                 },
3511                 {
3512                         name: "OP_NOP4",
3513                         pop: &parsedOpcode{
3514                                 opcode: &opcodeArray[OP_NOP4],
3515                                 data:   nil,
3516                         },
3517                         expectedErr: nil,
3518                 },
3519                 {
3520                         name: "OP_NOP4 long",
3521                         pop: &parsedOpcode{
3522                                 opcode: &opcodeArray[OP_NOP4],
3523                                 data:   make([]byte, 1),
3524                         },
3525                         expectedErr: scriptError(ErrInternal, ""),
3526                 },
3527                 {
3528                         name: "OP_NOP5",
3529                         pop: &parsedOpcode{
3530                                 opcode: &opcodeArray[OP_NOP5],
3531                                 data:   nil,
3532                         },
3533                         expectedErr: nil,
3534                 },
3535                 {
3536                         name: "OP_NOP5 long",
3537                         pop: &parsedOpcode{
3538                                 opcode: &opcodeArray[OP_NOP5],
3539                                 data:   make([]byte, 1),
3540                         },
3541                         expectedErr: scriptError(ErrInternal, ""),
3542                 },
3543                 {
3544                         name: "OP_NOP6",
3545                         pop: &parsedOpcode{
3546                                 opcode: &opcodeArray[OP_NOP6],
3547                                 data:   nil,
3548                         },
3549                         expectedErr: nil,
3550                 },
3551                 {
3552                         name: "OP_NOP6 long",
3553                         pop: &parsedOpcode{
3554                                 opcode: &opcodeArray[OP_NOP6],
3555                                 data:   make([]byte, 1),
3556                         },
3557                         expectedErr: scriptError(ErrInternal, ""),
3558                 },
3559                 {
3560                         name: "OP_NOP7",
3561                         pop: &parsedOpcode{
3562                                 opcode: &opcodeArray[OP_NOP7],
3563                                 data:   nil,
3564                         },
3565                         expectedErr: nil,
3566                 },
3567                 {
3568                         name: "OP_NOP7 long",
3569                         pop: &parsedOpcode{
3570                                 opcode: &opcodeArray[OP_NOP7],
3571                                 data:   make([]byte, 1),
3572                         },
3573                         expectedErr: scriptError(ErrInternal, ""),
3574                 },
3575                 {
3576                         name: "OP_NOP8",
3577                         pop: &parsedOpcode{
3578                                 opcode: &opcodeArray[OP_NOP8],
3579                                 data:   nil,
3580                         },
3581                         expectedErr: nil,
3582                 },
3583                 {
3584                         name: "OP_NOP8 long",
3585                         pop: &parsedOpcode{
3586                                 opcode: &opcodeArray[OP_NOP8],
3587                                 data:   make([]byte, 1),
3588                         },
3589                         expectedErr: scriptError(ErrInternal, ""),
3590                 },
3591                 {
3592                         name: "OP_NOP9",
3593                         pop: &parsedOpcode{
3594                                 opcode: &opcodeArray[OP_NOP9],
3595                                 data:   nil,
3596                         },
3597                         expectedErr: nil,
3598                 },
3599                 {
3600                         name: "OP_NOP9 long",
3601                         pop: &parsedOpcode{
3602                                 opcode: &opcodeArray[OP_NOP9],
3603                                 data:   make([]byte, 1),
3604                         },
3605                         expectedErr: scriptError(ErrInternal, ""),
3606                 },
3607                 {
3608                         name: "OP_NOP10",
3609                         pop: &parsedOpcode{
3610                                 opcode: &opcodeArray[OP_NOP10],
3611                                 data:   nil,
3612                         },
3613                         expectedErr: nil,
3614                 },
3615                 {
3616                         name: "OP_NOP10 long",
3617                         pop: &parsedOpcode{
3618                                 opcode: &opcodeArray[OP_NOP10],
3619                                 data:   make([]byte, 1),
3620                         },
3621                         expectedErr: scriptError(ErrInternal, ""),
3622                 },
3623                 {
3624                         name: "OP_PUBKEYHASH",
3625                         pop: &parsedOpcode{
3626                                 opcode: &opcodeArray[OP_PUBKEYHASH],
3627                                 data:   nil,
3628                         },
3629                         expectedErr: nil,
3630                 },
3631                 {
3632                         name: "OP_PUBKEYHASH long",
3633                         pop: &parsedOpcode{
3634                                 opcode: &opcodeArray[OP_PUBKEYHASH],
3635                                 data:   make([]byte, 1),
3636                         },
3637                         expectedErr: scriptError(ErrInternal, ""),
3638                 },
3639                 {
3640                         name: "OP_PUBKEY",
3641                         pop: &parsedOpcode{
3642                                 opcode: &opcodeArray[OP_PUBKEY],
3643                                 data:   nil,
3644                         },
3645                         expectedErr: nil,
3646                 },
3647                 {
3648                         name: "OP_PUBKEY long",
3649                         pop: &parsedOpcode{
3650                                 opcode: &opcodeArray[OP_PUBKEY],
3651                                 data:   make([]byte, 1),
3652                         },
3653                         expectedErr: scriptError(ErrInternal, ""),
3654                 },
3655                 {
3656                         name: "OP_INVALIDOPCODE",
3657                         pop: &parsedOpcode{
3658                                 opcode: &opcodeArray[OP_INVALIDOPCODE],
3659                                 data:   nil,
3660                         },
3661                         expectedErr: nil,
3662                 },
3663                 {
3664                         name: "OP_INVALIDOPCODE long",
3665                         pop: &parsedOpcode{
3666                                 opcode: &opcodeArray[OP_INVALIDOPCODE],
3667                                 data:   make([]byte, 1),
3668                         },
3669                         expectedErr: scriptError(ErrInternal, ""),
3670                 },
3671         }
3672
3673         for _, test := range tests {
3674                 _, err := test.pop.bytes()
3675                 if e := tstCheckScriptError(err, test.expectedErr); e != nil {
3676                         t.Errorf("Parsed opcode test '%s': %v", test.name, e)
3677                         continue
3678                 }
3679         }
3680 }
3681
3682 // TestPushedData ensured the PushedData function extracts the expected data out
3683 // of various scripts.
3684 func TestPushedData(t *testing.T) {
3685         t.Parallel()
3686
3687         var tests = []struct {
3688                 script string
3689                 out    [][]byte
3690                 valid  bool
3691         }{
3692                 {
3693                         "0 IF 0 ELSE 2 ENDIF",
3694                         [][]byte{nil, nil},
3695                         true,
3696                 },
3697                 {
3698                         "16777216 10000000",
3699                         [][]byte{
3700                                 {0x00, 0x00, 0x00, 0x01}, // 16777216
3701                                 {0x80, 0x96, 0x98, 0x00}, // 10000000
3702                         },
3703                         true,
3704                 },
3705                 {
3706                         "DUP HASH160 '17VZNX1SN5NtKa8UQFxwQbFeFc3iqRYhem' EQUALVERIFY CHECKSIG",
3707                         [][]byte{
3708                                 // 17VZNX1SN5NtKa8UQFxwQbFeFc3iqRYhem
3709                                 {
3710                                         0x31, 0x37, 0x56, 0x5a, 0x4e, 0x58, 0x31, 0x53, 0x4e, 0x35,
3711                                         0x4e, 0x74, 0x4b, 0x61, 0x38, 0x55, 0x51, 0x46, 0x78, 0x77,
3712                                         0x51, 0x62, 0x46, 0x65, 0x46, 0x63, 0x33, 0x69, 0x71, 0x52,
3713                                         0x59, 0x68, 0x65, 0x6d,
3714                                 },
3715                         },
3716                         true,
3717                 },
3718                 {
3719                         "PUSHDATA4 1000 EQUAL",
3720                         nil,
3721                         false,
3722                 },
3723         }
3724
3725         for i, test := range tests {
3726                 script := mustParseShortForm(test.script)
3727                 data, err := PushedData(script)
3728                 if test.valid && err != nil {
3729                         t.Errorf("TestPushedData failed test #%d: %v\n", i, err)
3730                         continue
3731                 } else if !test.valid && err == nil {
3732                         t.Errorf("TestPushedData failed test #%d: test should "+
3733                                 "be invalid\n", i)
3734                         continue
3735                 }
3736                 if !reflect.DeepEqual(data, test.out) {
3737                         t.Errorf("TestPushedData failed test #%d: want: %x "+
3738                                 "got: %x\n", i, test.out, data)
3739                 }
3740         }
3741 }
3742
3743 // TestHasCanonicalPush ensures the canonicalPush function works as expected.
3744 func TestHasCanonicalPush(t *testing.T) {
3745         t.Parallel()
3746
3747         for i := 0; i < 65535; i++ {
3748                 script, err := NewScriptBuilder().AddInt64(int64(i)).Script()
3749                 if err != nil {
3750                         t.Errorf("Script: test #%d unexpected error: %v\n", i,
3751                                 err)
3752                         continue
3753                 }
3754                 if result := IsPushOnlyScript(script); !result {
3755                         t.Errorf("IsPushOnlyScript: test #%d failed: %x\n", i,
3756                                 script)
3757                         continue
3758                 }
3759                 pops, err := parseScript(script)
3760                 if err != nil {
3761                         t.Errorf("parseScript: #%d failed: %v", i, err)
3762                         continue
3763                 }
3764                 for _, pop := range pops {
3765                         if result := canonicalPush(pop); !result {
3766                                 t.Errorf("canonicalPush: test #%d failed: %x\n",
3767                                         i, script)
3768                                 break
3769                         }
3770                 }
3771         }
3772         for i := 0; i <= MaxScriptElementSize; i++ {
3773                 builder := NewScriptBuilder()
3774                 builder.AddData(bytes.Repeat([]byte{0x49}, i))
3775                 script, err := builder.Script()
3776                 if err != nil {
3777                         t.Errorf("StandardPushesTests test #%d unexpected error: %v\n", i, err)
3778                         continue
3779                 }
3780                 if result := IsPushOnlyScript(script); !result {
3781                         t.Errorf("StandardPushesTests IsPushOnlyScript test #%d failed: %x\n", i, script)
3782                         continue
3783                 }
3784                 pops, err := parseScript(script)
3785                 if err != nil {
3786                         t.Errorf("StandardPushesTests #%d failed to TstParseScript: %v", i, err)
3787                         continue
3788                 }
3789                 for _, pop := range pops {
3790                         if result := canonicalPush(pop); !result {
3791                                 t.Errorf("StandardPushesTests TstHasCanonicalPushes test #%d failed: %x\n", i, script)
3792                                 break
3793                         }
3794                 }
3795         }
3796 }
3797
3798 // TestGetPreciseSigOps ensures the more precise signature operation counting
3799 // mechanism which includes signatures in P2SH scripts works as expected.
3800 func TestGetPreciseSigOps(t *testing.T) {
3801         t.Parallel()
3802
3803         tests := []struct {
3804                 name      string
3805                 scriptSig []byte
3806                 nSigOps   int
3807         }{
3808                 {
3809                         name:      "scriptSig doesn't parse",
3810                         scriptSig: mustParseShortForm("PUSHDATA1 0x02"),
3811                 },
3812                 {
3813                         name:      "scriptSig isn't push only",
3814                         scriptSig: mustParseShortForm("1 DUP"),
3815                         nSigOps:   0,
3816                 },
3817                 {
3818                         name:      "scriptSig length 0",
3819                         scriptSig: nil,
3820                         nSigOps:   0,
3821                 },
3822                 {
3823                         name: "No script at the end",
3824                         // No script at end but still push only.
3825                         scriptSig: mustParseShortForm("1 1"),
3826                         nSigOps:   0,
3827                 },
3828                 {
3829                         name:      "pushed script doesn't parse",
3830                         scriptSig: mustParseShortForm("DATA_2 PUSHDATA1 0x02"),
3831                 },
3832         }
3833
3834         // The signature in the p2sh script is nonsensical for the tests since
3835         // this script will never be executed.  What matters is that it matches
3836         // the right pattern.
3837         pkScript := mustParseShortForm("HASH160 DATA_20 0x433ec2ac1ffa1b7b7d0" +
3838                 "27f564529c57197f9ae88 EQUAL")
3839         for _, test := range tests {
3840                 count := GetPreciseSigOpCount(test.scriptSig, pkScript, true)
3841                 if count != test.nSigOps {
3842                         t.Errorf("%s: expected count of %d, got %d", test.name,
3843                                 test.nSigOps, count)
3844
3845                 }
3846         }
3847 }
3848
3849 // TestGetWitnessSigOpCount tests that the sig op counting for p2wkh, p2wsh,
3850 // nested p2sh, and invalid variants are counted properly.
3851 func TestGetWitnessSigOpCount(t *testing.T) {
3852         t.Parallel()
3853         tests := []struct {
3854                 name string
3855
3856                 sigScript []byte
3857                 pkScript  []byte
3858                 witness   wire.TxWitness
3859
3860                 numSigOps int
3861         }{
3862                 // A regualr p2wkh witness program. The output being spent
3863                 // should only have a single sig-op counted.
3864                 {
3865                         name: "p2wkh",
3866                         pkScript: mustParseShortForm("OP_0 DATA_20 " +
3867                                 "0x365ab47888e150ff46f8d51bce36dcd680f1283f"),
3868                         witness: wire.TxWitness{
3869                                 hexToBytes("3045022100ee9fe8f9487afa977" +
3870                                         "6647ebcf0883ce0cd37454d7ce19889d34ba2c9" +
3871                                         "9ce5a9f402200341cb469d0efd3955acb9e46" +
3872                                         "f568d7e2cc10f9084aaff94ced6dc50a59134ad01"),
3873                                 hexToBytes("03f0000d0639a22bfaf217e4c9428" +
3874                                         "9c2b0cc7fa1036f7fd5d9f61a9d6ec153100e"),
3875                         },
3876                         numSigOps: 1,
3877                 },
3878                 // A p2wkh witness program nested within a p2sh output script.
3879                 // The pattern should be recognized properly and attribute only
3880                 // a single sig op.
3881                 {
3882                         name: "nested p2sh",
3883                         sigScript: hexToBytes("160014ad0ffa2e387f07" +
3884                                 "e7ead14dc56d5a97dbd6ff5a23"),
3885                         pkScript: mustParseShortForm("HASH160 DATA_20 " +
3886                                 "0xb3a84b564602a9d68b4c9f19c2ea61458ff7826c EQUAL"),
3887                         witness: wire.TxWitness{
3888                                 hexToBytes("3045022100cb1c2ac1ff1d57d" +
3889                                         "db98f7bdead905f8bf5bcc8641b029ce8eef25" +
3890                                         "c75a9e22a4702203be621b5c86b771288706be5" +
3891                                         "a7eee1db4fceabf9afb7583c1cc6ee3f8297b21201"),
3892                                 hexToBytes("03f0000d0639a22bfaf217e4c9" +
3893                                         "4289c2b0cc7fa1036f7fd5d9f61a9d6ec153100e"),
3894                         },
3895                         numSigOps: 1,
3896                 },
3897                 // A p2sh script that spends a 2-of-2 multi-sig output.
3898                 {
3899                         name:      "p2wsh multi-sig spend",
3900                         numSigOps: 2,
3901                         pkScript: hexToBytes("0020e112b88a0cd87ba387f" +
3902                                 "449d443ee2596eb353beb1f0351ab2cba8909d875db23"),
3903                         witness: wire.TxWitness{
3904                                 hexToBytes("522103b05faca7ceda92b493" +
3905                                         "3f7acdf874a93de0dc7edc461832031cd69cbb1d1e" +
3906                                         "6fae2102e39092e031c1621c902e3704424e8d8" +
3907                                         "3ca481d4d4eeae1b7970f51c78231207e52ae"),
3908                         },
3909                 },
3910                 // A p2wsh witness program. However, the witness script fails
3911                 // to parse after the valid portion of the script. As a result,
3912                 // the valid portion of the script should still be counted.
3913                 {
3914                         name:      "witness script doesn't parse",
3915                         numSigOps: 1,
3916                         pkScript: hexToBytes("0020e112b88a0cd87ba387f44" +
3917                                 "9d443ee2596eb353beb1f0351ab2cba8909d875db23"),
3918                         witness: wire.TxWitness{
3919                                 mustParseShortForm("DUP HASH160 " +
3920                                         "'17VZNX1SN5NtKa8UQFxwQbFeFc3iqRYhem'" +
3921                                         " EQUALVERIFY CHECKSIG DATA_20 0x91"),
3922                         },
3923                 },
3924         }
3925
3926         for _, test := range tests {
3927                 count := GetWitnessSigOpCount(test.sigScript, test.pkScript,
3928                         test.witness)
3929                 if count != test.numSigOps {
3930                         t.Errorf("%s: expected count of %d, got %d", test.name,
3931                                 test.numSigOps, count)
3932
3933                 }
3934         }
3935 }
3936
3937 // TestRemoveOpcodes ensures that removing opcodes from scripts behaves as
3938 // expected.
3939 func TestRemoveOpcodes(t *testing.T) {
3940         t.Parallel()
3941
3942         tests := []struct {
3943                 name   string
3944                 before string
3945                 remove byte
3946                 err    error
3947                 after  string
3948         }{
3949                 {
3950                         // Nothing to remove.
3951                         name:   "nothing to remove",
3952                         before: "NOP",
3953                         remove: OP_CODESEPARATOR,
3954                         after:  "NOP",
3955                 },
3956                 {
3957                         // Test basic opcode removal.
3958                         name:   "codeseparator 1",
3959                         before: "NOP CODESEPARATOR TRUE",
3960                         remove: OP_CODESEPARATOR,
3961                         after:  "NOP TRUE",
3962                 },
3963                 {
3964                         // The opcode in question is actually part of the data
3965                         // in a previous opcode.
3966                         name:   "codeseparator by coincidence",
3967                         before: "NOP DATA_1 CODESEPARATOR TRUE",
3968                         remove: OP_CODESEPARATOR,
3969                         after:  "NOP DATA_1 CODESEPARATOR TRUE",
3970                 },
3971                 {
3972                         name:   "invalid opcode",
3973                         before: "CAT",
3974                         remove: OP_CODESEPARATOR,
3975                         after:  "CAT",
3976                 },
3977                 {
3978                         name:   "invalid length (insruction)",
3979                         before: "PUSHDATA1",
3980                         remove: OP_CODESEPARATOR,
3981                         err:    scriptError(ErrMalformedPush, ""),
3982                 },
3983                 {
3984                         name:   "invalid length (data)",
3985                         before: "PUSHDATA1 0xff 0xfe",
3986                         remove: OP_CODESEPARATOR,
3987                         err:    scriptError(ErrMalformedPush, ""),
3988                 },
3989         }
3990
3991         // tstRemoveOpcode is a convenience function to parse the provided
3992         // raw script, remove the passed opcode, then unparse the result back
3993         // into a raw script.
3994         tstRemoveOpcode := func(script []byte, opcode byte) ([]byte, error) {
3995                 pops, err := parseScript(script)
3996                 if err != nil {
3997                         return nil, err
3998                 }
3999                 pops = removeOpcode(pops, opcode)
4000                 return unparseScript(pops)
4001         }
4002
4003         for _, test := range tests {
4004                 before := mustParseShortForm(test.before)
4005                 after := mustParseShortForm(test.after)
4006                 result, err := tstRemoveOpcode(before, test.remove)
4007                 if e := tstCheckScriptError(err, test.err); e != nil {
4008                         t.Errorf("%s: %v", test.name, e)
4009                         continue
4010                 }
4011
4012                 if !bytes.Equal(after, result) {
4013                         t.Errorf("%s: value does not equal expected: exp: %q"+
4014                                 " got: %q", test.name, after, result)
4015                 }
4016         }
4017 }
4018
4019 // TestRemoveOpcodeByData ensures that removing data carrying opcodes based on
4020 // the data they contain works as expected.
4021 func TestRemoveOpcodeByData(t *testing.T) {
4022         t.Parallel()
4023
4024         tests := []struct {
4025                 name   string
4026                 before []byte
4027                 remove []byte
4028                 err    error
4029                 after  []byte
4030         }{
4031                 {
4032                         name:   "nothing to do",
4033                         before: []byte{OP_NOP},
4034                         remove: []byte{1, 2, 3, 4},
4035                         after:  []byte{OP_NOP},
4036                 },
4037                 {
4038                         name:   "simple case",
4039                         before: []byte{OP_DATA_4, 1, 2, 3, 4},
4040                         remove: []byte{1, 2, 3, 4},
4041                         after:  nil,
4042                 },
4043                 {
4044                         name:   "simple case (miss)",
4045                         before: []byte{OP_DATA_4, 1, 2, 3, 4},
4046                         remove: []byte{1, 2, 3, 5},
4047                         after:  []byte{OP_DATA_4, 1, 2, 3, 4},
4048                 },
4049                 {
4050                         // padded to keep it canonical.
4051                         name: "simple case (pushdata1)",
4052                         before: append(append([]byte{OP_PUSHDATA1, 76},
4053                                 bytes.Repeat([]byte{0}, 72)...),
4054                                 []byte{1, 2, 3, 4}...),
4055                         remove: []byte{1, 2, 3, 4},
4056                         after:  nil,
4057                 },
4058                 {
4059                         name: "simple case (pushdata1 miss)",
4060                         before: append(append([]byte{OP_PUSHDATA1, 76},
4061                                 bytes.Repeat([]byte{0}, 72)...),
4062                                 []byte{1, 2, 3, 4}...),
4063                         remove: []byte{1, 2, 3, 5},
4064                         after: append(append([]byte{OP_PUSHDATA1, 76},
4065                                 bytes.Repeat([]byte{0}, 72)...),
4066                                 []byte{1, 2, 3, 4}...),
4067                 },
4068                 {
4069                         name:   "simple case (pushdata1 miss noncanonical)",
4070                         before: []byte{OP_PUSHDATA1, 4, 1, 2, 3, 4},
4071                         remove: []byte{1, 2, 3, 4},
4072                         after:  []byte{OP_PUSHDATA1, 4, 1, 2, 3, 4},
4073                 },
4074                 {
4075                         name: "simple case (pushdata2)",
4076                         before: append(append([]byte{OP_PUSHDATA2, 0, 1},
4077                                 bytes.Repeat([]byte{0}, 252)...),
4078                                 []byte{1, 2, 3, 4}...),
4079                         remove: []byte{1, 2, 3, 4},
4080                         after:  nil,
4081                 },
4082                 {
4083                         name: "simple case (pushdata2 miss)",
4084                         before: append(append([]byte{OP_PUSHDATA2, 0, 1},
4085                                 bytes.Repeat([]byte{0}, 252)...),
4086                                 []byte{1, 2, 3, 4}...),
4087                         remove: []byte{1, 2, 3, 4, 5},
4088                         after: append(append([]byte{OP_PUSHDATA2, 0, 1},
4089                                 bytes.Repeat([]byte{0}, 252)...),
4090                                 []byte{1, 2, 3, 4}...),
4091                 },
4092                 {
4093                         name:   "simple case (pushdata2 miss noncanonical)",
4094                         before: []byte{OP_PUSHDATA2, 4, 0, 1, 2, 3, 4},
4095                         remove: []byte{1, 2, 3, 4},
4096                         after:  []byte{OP_PUSHDATA2, 4, 0, 1, 2, 3, 4},
4097                 },
4098                 {
4099                         // This is padded to make the push canonical.
4100                         name: "simple case (pushdata4)",
4101                         before: append(append([]byte{OP_PUSHDATA4, 0, 0, 1, 0},
4102                                 bytes.Repeat([]byte{0}, 65532)...),
4103                                 []byte{1, 2, 3, 4}...),
4104                         remove: []byte{1, 2, 3, 4},
4105                         after:  nil,
4106                 },
4107                 {
4108                         name:   "simple case (pushdata4 miss noncanonical)",
4109                         before: []byte{OP_PUSHDATA4, 4, 0, 0, 0, 1, 2, 3, 4},
4110                         remove: []byte{1, 2, 3, 4},
4111                         after:  []byte{OP_PUSHDATA4, 4, 0, 0, 0, 1, 2, 3, 4},
4112                 },
4113                 {
4114                         // This is padded to make the push canonical.
4115                         name: "simple case (pushdata4 miss)",
4116                         before: append(append([]byte{OP_PUSHDATA4, 0, 0, 1, 0},
4117                                 bytes.Repeat([]byte{0}, 65532)...), []byte{1, 2, 3, 4}...),
4118                         remove: []byte{1, 2, 3, 4, 5},
4119                         after: append(append([]byte{OP_PUSHDATA4, 0, 0, 1, 0},
4120                                 bytes.Repeat([]byte{0}, 65532)...), []byte{1, 2, 3, 4}...),
4121                 },
4122                 {
4123                         name:   "invalid opcode ",
4124                         before: []byte{OP_UNKNOWN187},
4125                         remove: []byte{1, 2, 3, 4},
4126                         after:  []byte{OP_UNKNOWN187},
4127                 },
4128                 {
4129                         name:   "invalid length (instruction)",
4130                         before: []byte{OP_PUSHDATA1},
4131                         remove: []byte{1, 2, 3, 4},
4132                         err:    scriptError(ErrMalformedPush, ""),
4133                 },
4134                 {
4135                         name:   "invalid length (data)",
4136                         before: []byte{OP_PUSHDATA1, 255, 254},
4137                         remove: []byte{1, 2, 3, 4},
4138                         err:    scriptError(ErrMalformedPush, ""),
4139                 },
4140         }
4141
4142         // tstRemoveOpcodeByData is a convenience function to parse the provided
4143         // raw script, remove the passed data, then unparse the result back
4144         // into a raw script.
4145         tstRemoveOpcodeByData := func(script []byte, data []byte) ([]byte, error) {
4146                 pops, err := parseScript(script)
4147                 if err != nil {
4148                         return nil, err
4149                 }
4150                 pops = removeOpcodeByData(pops, data)
4151                 return unparseScript(pops)
4152         }
4153
4154         for _, test := range tests {
4155                 result, err := tstRemoveOpcodeByData(test.before, test.remove)
4156                 if e := tstCheckScriptError(err, test.err); e != nil {
4157                         t.Errorf("%s: %v", test.name, e)
4158                         continue
4159                 }
4160
4161                 if !bytes.Equal(test.after, result) {
4162                         t.Errorf("%s: value does not equal expected: exp: %q"+
4163                                 " got: %q", test.name, test.after, result)
4164                 }
4165         }
4166 }
4167
4168 // TestIsPayToScriptHash ensures the IsPayToScriptHash function returns the
4169 // expected results for all the scripts in scriptClassTests.
4170 func TestIsPayToScriptHash(t *testing.T) {
4171         t.Parallel()
4172
4173         for _, test := range scriptClassTests {
4174                 script := mustParseShortForm(test.script)
4175                 shouldBe := (test.class == ScriptHashTy)
4176                 p2sh := IsPayToScriptHash(script)
4177                 if p2sh != shouldBe {
4178                         t.Errorf("%s: expected p2sh %v, got %v", test.name,
4179                                 shouldBe, p2sh)
4180                 }
4181         }
4182 }
4183
4184 // TestIsPayToWitnessScriptHash ensures the IsPayToWitnessScriptHash function
4185 // returns the expected results for all the scripts in scriptClassTests.
4186 func TestIsPayToWitnessScriptHash(t *testing.T) {
4187         t.Parallel()
4188
4189         for _, test := range scriptClassTests {
4190                 script := mustParseShortForm(test.script)
4191                 shouldBe := (test.class == WitnessV0ScriptHashTy)
4192                 p2wsh := IsPayToWitnessScriptHash(script)
4193                 if p2wsh != shouldBe {
4194                         t.Errorf("%s: expected p2wsh %v, got %v", test.name,
4195                                 shouldBe, p2wsh)
4196                 }
4197         }
4198 }
4199
4200 // TestIsPayToWitnessPubKeyHash ensures the IsPayToWitnessPubKeyHash function
4201 // returns the expected results for all the scripts in scriptClassTests.
4202 func TestIsPayToWitnessPubKeyHash(t *testing.T) {
4203         t.Parallel()
4204
4205         for _, test := range scriptClassTests {
4206                 script := mustParseShortForm(test.script)
4207                 shouldBe := (test.class == WitnessV0PubKeyHashTy)
4208                 p2wkh := IsPayToWitnessPubKeyHash(script)
4209                 if p2wkh != shouldBe {
4210                         t.Errorf("%s: expected p2wkh %v, got %v", test.name,
4211                                 shouldBe, p2wkh)
4212                 }
4213         }
4214 }
4215
4216 // TestHasCanonicalPushes ensures the canonicalPush function properly determines
4217 // what is considered a canonical push for the purposes of removeOpcodeByData.
4218 func TestHasCanonicalPushes(t *testing.T) {
4219         t.Parallel()
4220
4221         tests := []struct {
4222                 name     string
4223                 script   string
4224                 expected bool
4225         }{
4226                 {
4227                         name: "does not parse",
4228                         script: "0x046708afdb0fe5548271967f1a67130b7105cd6a82" +
4229                                 "8e03909a67962e0ea1f61d",
4230                         expected: false,
4231                 },
4232                 {
4233                         name:     "non-canonical push",
4234                         script:   "PUSHDATA1 0x04 0x01020304",
4235                         expected: false,
4236                 },
4237         }
4238
4239         for i, test := range tests {
4240                 script := mustParseShortForm(test.script)
4241                 pops, err := parseScript(script)
4242                 if err != nil {
4243                         if test.expected {
4244                                 t.Errorf("TstParseScript #%d failed: %v", i, err)
4245                         }
4246                         continue
4247                 }
4248                 for _, pop := range pops {
4249                         if canonicalPush(pop) != test.expected {
4250                                 t.Errorf("canonicalPush: #%d (%s) wrong result"+
4251                                         "\ngot: %v\nwant: %v", i, test.name,
4252                                         true, test.expected)
4253                                 break
4254                         }
4255                 }
4256         }
4257 }
4258
4259 // TestIsPushOnlyScript ensures the IsPushOnlyScript function returns the
4260 // expected results.
4261 func TestIsPushOnlyScript(t *testing.T) {
4262         t.Parallel()
4263
4264         test := struct {
4265                 name     string
4266                 script   []byte
4267                 expected bool
4268         }{
4269                 name: "does not parse",
4270                 script: mustParseShortForm("0x046708afdb0fe5548271967f1a67130" +
4271                         "b7105cd6a828e03909a67962e0ea1f61d"),
4272                 expected: false,
4273         }
4274
4275         if IsPushOnlyScript(test.script) != test.expected {
4276                 t.Errorf("IsPushOnlyScript (%s) wrong result\ngot: %v\nwant: "+
4277                         "%v", test.name, true, test.expected)
4278         }
4279 }
4280
4281 // TestIsUnspendable ensures the IsUnspendable function returns the expected
4282 // results.
4283 func TestIsUnspendable(t *testing.T) {
4284         t.Parallel()
4285
4286         tests := []struct {
4287                 name     string
4288                 pkScript []byte
4289                 expected bool
4290         }{
4291                 {
4292                         // Unspendable
4293                         pkScript: []byte{0x6a, 0x04, 0x74, 0x65, 0x73, 0x74},
4294                         expected: true,
4295                 },
4296                 {
4297                         // Spendable
4298                         pkScript: []byte{0x76, 0xa9, 0x14, 0x29, 0x95, 0xa0,
4299                                 0xfe, 0x68, 0x43, 0xfa, 0x9b, 0x95, 0x45,
4300                                 0x97, 0xf0, 0xdc, 0xa7, 0xa4, 0x4d, 0xf6,
4301                                 0xfa, 0x0b, 0x5c, 0x88, 0xac},
4302                         expected: false,
4303                 },
4304         }
4305
4306         for i, test := range tests {
4307                 res := IsUnspendable(test.pkScript)
4308                 if res != test.expected {
4309                         t.Errorf("TestIsUnspendable #%d failed: got %v want %v",
4310                                 i, res, test.expected)
4311                         continue
4312                 }
4313         }
4314 }