How Bitcoin checks a spending script

501                case OP_2:
502                case OP_3:
503                case OP_4:
504                case OP_5:
505                case OP_6:
506                case OP_7:
507                case OP_8:
508                case OP_9:
509                case OP_10:
510                case OP_11:
511                case OP_12:
512                case OP_13:
513                case OP_14:
514                case OP_15:
515                case OP_16:
516                {
517                    // ( -- value)
518                    CScriptNum bn((int)opcode - (int)(OP_1 - 1));
519                    stack.push_back(bn.getvch());
520                    // The result of these opcodes should always be the minimal way to push the data
521                    // they push, so no need for a CheckMinimalPush here.
522                }
523                break;
524
525
526                //
527                // Control
528                //
529                case OP_NOP:
530                    break;
531
532                case OP_CHECKLOCKTIMEVERIFY:
533                {
534                    if (!(flags & SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY)) {
535                        // not enabled; treat as a NOP2
536                        break;
537                    }
538
539                    if (stack.size() < 1)
540                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
541
542                    // Note that elsewhere numeric opcodes are limited to
543                    // operands in the range -2**31+1 to 2**31-1, however it is
544                    // legal for opcodes to produce results exceeding that
545                    // range. This limitation is implemented by CScriptNum's
546                    // default 4-byte limit.
547                    //
548                    // If we kept to that limit we'd have a year 2038 problem,
549                    // even though the nLockTime field in transactions
550                    // themselves is uint32 which only becomes meaningless
551                    // after the year 2106.
552                    //
553                    // Thus as a special case we tell CScriptNum to accept up
554                    // to 5-byte bignums, which are good until 2**39-1, well
555                    // beyond the 2**32-1 limit of the nLockTime field itself.
556                    const CScriptNum nLockTime(stacktop(-1), fRequireMinimal, 5);
557
558                    // In the rare event that the argument may be < 0 due to
559                    // some arithmetic being done first, you can always use
560                    // 0 MAX CHECKLOCKTIMEVERIFY.
561                    if (nLockTime < 0)
562                        return set_error(serror, SCRIPT_ERR_NEGATIVE_LOCKTIME);
563
564                    // Actually compare the specified lock time with the transaction.
565                    if (!checker.CheckLockTime(nLockTime))
566                        return set_error(serror, SCRIPT_ERR_UNSATISFIED_LOCKTIME);
567
568                    break;
569                }
570
571                case OP_CHECKSEQUENCEVERIFY:
572                {
573                    if (!(flags & SCRIPT_VERIFY_CHECKSEQUENCEVERIFY)) {
574                        // not enabled; treat as a NOP3
575                        break;
576                    }
577
578                    if (stack.size() < 1)
579                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
580
581                    // nSequence, like nLockTime, is a 32-bit unsigned integer
582                    // field. See the comment in CHECKLOCKTIMEVERIFY regarding
583                    // 5-byte numeric operands.
584                    const CScriptNum nSequence(stacktop(-1), fRequireMinimal, 5);
585
586                    // In the rare event that the argument may be < 0 due to
587                    // some arithmetic being done first, you can always use
588                    // 0 MAX CHECKSEQUENCEVERIFY.
589                    if (nSequence < 0)
590                        return set_error(serror, SCRIPT_ERR_NEGATIVE_LOCKTIME);
591
592                    // To provide for future soft-fork extensibility, if the
593                    // operand has the disabled lock-time flag set,
594                    // CHECKSEQUENCEVERIFY behaves as a NOP.
595                    if ((nSequence & CTxIn::SEQUENCE_LOCKTIME_DISABLE_FLAG) != 0)
596                        break;
597
598                    // Compare the specified sequence number with the input.
599                    if (!checker.CheckSequence(nSequence))
600                        return set_error(serror, SCRIPT_ERR_UNSATISFIED_LOCKTIME);
601
602                    break;
603                }
604
605                case OP_NOP1: case OP_NOP4: case OP_NOP5:
606                case OP_NOP6: case OP_NOP7: case OP_NOP8: case OP_NOP9: case OP_NOP10:
607                {
608                    if (flags & SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS)
609                        return set_error(serror, SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS);
610                }
611                break;
612
613                case OP_IF:
614                case OP_NOTIF:
615                {
616                    // <expression> if [statements] [else [statements]] endif
617                    bool fValue = false;
618                    if (fExec)
619                    {
620                        if (stack.size() < 1)
621                            return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
622                        valtype& vch = stacktop(-1);
623                        // Tapscript requires minimal IF/NOTIF inputs as a consensus rule.
624                        if (sigversion == SigVersion::TAPSCRIPT) {
625                            // The input argument to the OP_IF and OP_NOTIF opcodes must be either
626                            // exactly 0 (the empty vector) or exactly 1 (the one-byte vector with value 1).
627                            if (vch.size() > 1 || (vch.size() == 1 && vch[0] != 1)) {
628                                return set_error(serror, SCRIPT_ERR_TAPSCRIPT_MINIMALIF);
629                            }
630                        }
631                        // Under witness v0 rules it is only a policy rule, enabled through SCRIPT_VERIFY_MINIMALIF.
632                        if (sigversion == SigVersion::WITNESS_V0 && (flags & SCRIPT_VERIFY_MINIMALIF)) {
633                            if (vch.size() > 1)
634                                return set_error(serror, SCRIPT_ERR_MINIMALIF);
635                            if (vch.size() == 1 && vch[0] != 1)
636                                return set_error(serror, SCRIPT_ERR_MINIMALIF);
637                        }
638                        fValue = CastToBool(vch);
639                        if (opcode == OP_NOTIF)
640                            fValue = !fValue;
641                        popstack(stack);
642                    }
643                    vfExec.push_back(fValue);
644                }
645                break;
646
647                case OP_ELSE:
648                {
649                    if (vfExec.empty())
650                        return set_error(serror, SCRIPT_ERR_UNBALANCED_CONDITIONAL);
651                    vfExec.toggle_top();
652                }
653                break;
654
655                case OP_ENDIF:
656                {
657                    if (vfExec.empty())
658                        return set_error(serror, SCRIPT_ERR_UNBALANCED_CONDITIONAL);
659                    vfExec.pop_back();
660                }
661                break;
662
663                case OP_VERIFY:
664                {
665                    // (true -- ) or
666                    // (false -- false) and return
667                    if (stack.size() < 1)
668                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
669                    bool fValue = CastToBool(stacktop(-1));
670                    if (fValue)
671                        popstack(stack);
672                    else
673                        return set_error(serror, SCRIPT_ERR_VERIFY);
674                }
675                break;
676
677                case OP_RETURN:
678                {
679                    return set_error(serror, SCRIPT_ERR_OP_RETURN);
680                }
681                break;
682
683
684                //
685                // Stack ops
686                //
687                case OP_TOALTSTACK:
688                {
689                    if (stack.size() < 1)
690                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
691                    altstack.push_back(stacktop(-1));
692                    popstack(stack);
693                }
694                break;
695
696                case OP_FROMALTSTACK:
697                {
698                    if (altstack.size() < 1)
699                        return set_error(serror, SCRIPT_ERR_INVALID_ALTSTACK_OPERATION);
700                    stack.push_back(altstacktop(-1));
701                    popstack(altstack);
702                }
703                break;
704
705                case OP_2DROP:
706                {
707                    // (x1 x2 -- )
708                    if (stack.size() < 2)
709                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
710                    popstack(stack);
711                    popstack(stack);
712                }
713                break;
714
715                case OP_2DUP:
716                {
717                    // (x1 x2 -- x1 x2 x1 x2)
718                    if (stack.size() < 2)
719                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
720                    valtype vch1 = stacktop(-2);
721                    valtype vch2 = stacktop(-1);
722                    stack.push_back(vch1);
723                    stack.push_back(vch2);
724                }
725                break;
726
727                case OP_3DUP:
728                {
729                    // (x1 x2 x3 -- x1 x2 x3 x1 x2 x3)
730                    if (stack.size() < 3)
731                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
732                    valtype vch1 = stacktop(-3);
733                    valtype vch2 = stacktop(-2);
734                    valtype vch3 = stacktop(-1);
735                    stack.push_back(vch1);
736                    stack.push_back(vch2);
737                    stack.push_back(vch3);
738                }
739                break;
740
741                case OP_2OVER:
742                {
743                    // (x1 x2 x3 x4 -- x1 x2 x3 x4 x1 x2)
744                    if (stack.size() < 4)
745                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
746                    valtype vch1 = stacktop(-4);
747                    valtype vch2 = stacktop(-3);
748                    stack.push_back(vch1);
749                    stack.push_back(vch2);
750                }