feat(script): deprecate unnecessary opcodes

glevco · glevco · commit 746d648b2540 · 2026-01-22T16:42:02.000-03:00
diff --git a/.yamllint.yml b/.yamllint.yml
@@ -1,5 +1,8 @@
 extends: default
 
+ignore:
+  - .venv/
+
 rules:
   document-start: disable
   line-length:
diff --git a/hathor/conf/settings.py b/hathor/conf/settings.py
@@ -485,6 +485,9 @@ def GENESIS_TX2_TIMESTAMP(self) -> int:
     # Used to enable fee-based tokens.
     ENABLE_FEE_BASED_TOKENS: FeatureSetting = FeatureSetting.DISABLED
 
+    # Used to enable the deprecation of some opcodes.
+    ENABLE_DEPRECATE_OPCODES: FeatureSetting = FeatureSetting.DISABLED
+
     # List of enabled blueprints.
     BLUEPRINTS: dict[bytes, str] = {}
 
diff --git a/hathor/consensus/consensus.py b/hathor/consensus/consensus.py
@@ -427,6 +427,9 @@ def _feature_activation_rules(self, tx: Transaction, old_best_block: Block, new_
                 case Feature.COUNT_CHECKDATASIG_OP:
                     if not self._checkdatasig_count_rule(tx):
                         return False
+                case Feature.DEPRECATE_OPCODES:
+                    if not self._deprecate_opcodes_activation_rule(is_active):
+                        return False
                 case (
                     Feature.INCREASE_MAX_MERKLE_PATH_LENGTH
                     | Feature.NOP_FEATURE_1
@@ -489,6 +492,15 @@ def _checkdatasig_count_rule(self, tx: Transaction) -> bool:
             return False
         return True
 
+    def _deprecate_opcodes_activation_rule(self, is_active: bool) -> bool:
+        """
+        Check whether a tx became invalid because the reorg changed the deprecate opcodes feature activation state.
+        """
+        # For this rule, whenever a reorg flips it from non-active to active, we simply clean all mempool.
+        # Reason being, this is very unlikely to happen, and if it does we would have to re-check tx inputs,
+        # nc_signature... might as well just remove all txs just to make sure.
+        return not is_active
+
     def _feature_activation_flips(self, *, old_best_block: Block, new_best_block: Block) -> dict[Feature, bool]:
         """
         Get a diff of feature activation states that flipped from active to non-active,
diff --git a/hathor/feature_activation/feature.py b/hathor/feature_activation/feature.py
@@ -32,3 +32,4 @@ class Feature(StrEnum):
     COUNT_CHECKDATASIG_OP = 'COUNT_CHECKDATASIG_OP'
     NANO_CONTRACTS = 'NANO_CONTRACTS'
     FEE_TOKENS = 'FEE_TOKENS'
+    DEPRECATE_OPCODES = 'DEPRECATE_OPCODES'
diff --git a/hathor/feature_activation/utils.py b/hathor/feature_activation/utils.py
@@ -19,6 +19,7 @@
 
 from hathor.feature_activation.feature import Feature
 from hathor.feature_activation.model.feature_state import FeatureState
+from hathor.transaction.scripts.opcode import OpcodeVersion
 
 if TYPE_CHECKING:
     from hathor.conf.settings import FeatureSetting, HathorSettings
@@ -33,6 +34,7 @@ class Features:
     count_checkdatasig_op: bool
     nano: bool
     fee_tokens: bool
+    opcode_version: OpcodeVersion
 
     @staticmethod
     def from_vertex(*, settings: HathorSettings, feature_service: FeatureService, vertex: Vertex) -> Features:
@@ -43,17 +45,21 @@ def from_vertex(*, settings: HathorSettings, feature_service: FeatureService, ve
             Feature.COUNT_CHECKDATASIG_OP: FeatureSetting.FEATURE_ACTIVATION,
             Feature.NANO_CONTRACTS: settings.ENABLE_NANO_CONTRACTS,
             Feature.FEE_TOKENS: settings.ENABLE_FEE_BASED_TOKENS,
+            Feature.DEPRECATE_OPCODES: settings.ENABLE_DEPRECATE_OPCODES,
         }
 
-        features = {
+        feature_is_active: dict[Feature, bool] = {
             feature: _is_feature_active(setting, feature_states.get(feature, FeatureState.DEFINED))
             for feature, setting in feature_settings.items()
         }
 
+        opcode_version = OpcodeVersion.V2 if feature_is_active[Feature.DEPRECATE_OPCODES] else OpcodeVersion.V1
+
         return Features(
-            count_checkdatasig_op=features[Feature.COUNT_CHECKDATASIG_OP],
-            nano=features[Feature.NANO_CONTRACTS],
-            fee_tokens=features[Feature.FEE_TOKENS],
+            count_checkdatasig_op=feature_is_active[Feature.COUNT_CHECKDATASIG_OP],
+            nano=feature_is_active[Feature.NANO_CONTRACTS],
+            fee_tokens=feature_is_active[Feature.FEE_TOKENS],
+            opcode_version=opcode_version,
         )
 
 
diff --git a/hathor/nanocontracts/types.py b/hathor/nanocontracts/types.py
@@ -32,6 +32,7 @@
 from hathor.nanocontracts.exception import BlueprintSyntaxError, NCSerializationError
 from hathor.nanocontracts.faux_immutable import FauxImmutableMeta
 from hathor.serialization import SerializationError
+from hathor.transaction.scripts.opcode import OpcodeVersion
 from hathor.transaction.util import bytes_to_int, get_deposit_token_withdraw_amount, int_to_bytes
 from hathor.utils.typing import InnerTypeMixin
 
@@ -162,7 +163,7 @@ def checksig(self, script: bytes) -> bool:
         from hathor.transaction.exceptions import ScriptError
         from hathor.transaction.scripts import ScriptExtras
         from hathor.transaction.scripts.execute import raw_script_eval
-        extras = ScriptExtras(tx=self)  # type: ignore[arg-type]
+        extras = ScriptExtras(tx=self, version=OpcodeVersion.V2)  # type: ignore[arg-type]
         try:
             raw_script_eval(input_data=self.script_input, output_script=script, extras=extras)
         except ScriptError:
diff --git a/hathor/p2p/sync_v2/transaction_streaming_client.py b/hathor/p2p/sync_v2/transaction_streaming_client.py
@@ -28,6 +28,7 @@
 from hathor.p2p.sync_v2.streamers import StreamEnd
 from hathor.transaction import BaseTransaction, Transaction
 from hathor.transaction.exceptions import HathorError, TxValidationError
+from hathor.transaction.scripts.opcode import OpcodeVersion
 from hathor.types import VertexId
 from hathor.verification.verification_params import VerificationParams
 
@@ -59,6 +60,7 @@ def __init__(self,
                 count_checkdatasig_op=False,
                 nano=False,
                 fee_tokens=False,
+                opcode_version=OpcodeVersion.V1,
             )
         )
 
diff --git a/hathor/transaction/resources/create_tx.py b/hathor/transaction/resources/create_tx.py
@@ -22,6 +22,7 @@
 from hathor.transaction import Transaction, TxInput, TxOutput
 from hathor.transaction.scripts import create_output_script
 from hathor.util import api_catch_exceptions, json_dumpb, json_loadb
+from hathor.verification.verification_params import VerificationParams
 
 
 def from_raw_output(raw_output: dict, tokens: list[bytes]) -> TxOutput:
@@ -116,11 +117,12 @@ def _verify_unsigned_skip_pow(self, tx: Transaction) -> None:
         verifiers.tx.verify_output_token_indexes(tx)
         verifiers.vertex.verify_sigops_output(tx, enable_checkdatasig_count=True)
         verifiers.tx.verify_sigops_input(tx, enable_checkdatasig_count=True)
+        best_block = self.manager.tx_storage.get_best_block()
+        params = VerificationParams.default_for_mempool(best_block=best_block)
         # need to run verify_inputs first to check if all inputs exist
-        verifiers.tx.verify_inputs(tx, skip_script=True)
+        verifiers.tx.verify_inputs(tx, params, skip_script=True)
         verifiers.vertex.verify_parents(tx)
 
-        best_block = self.manager.tx_storage.get_best_block()
         block_storage = self.manager.get_nc_block_storage(best_block)
         verifiers.tx.verify_sum(self.manager._settings, tx, tx.get_complete_token_info(block_storage))
 
diff --git a/hathor/transaction/scripts/execute.py b/hathor/transaction/scripts/execute.py
@@ -12,17 +12,23 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from __future__ import annotations
+
 import struct
 from dataclasses import dataclass
-from typing import NamedTuple, Optional, Union
+from typing import TYPE_CHECKING, NamedTuple, Optional, Union
 
 from hathor.transaction import BaseTransaction, Transaction, TxInput
 from hathor.transaction.exceptions import DataIndexError, FinalStackInvalid, InvalidScriptError, OutOfData
 
+if TYPE_CHECKING:
+    from hathor.transaction.scripts.opcode import OpcodeVersion
+
 
 @dataclass(slots=True, frozen=True, kw_only=True)
 class ScriptExtras:
     tx: Transaction
+    version: OpcodeVersion
 
 
 @dataclass(slots=True, frozen=True, kw_only=True)
@@ -72,7 +78,7 @@ def execute_eval(data: bytes, log: list[str], extras: ScriptExtras) -> None:
             continue
 
         # this is an opcode manipulating the stack
-        execute_op_code(Opcode(opcode), context)
+        execute_op_code(Opcode(opcode), context, extras.version)
 
     evaluate_final_stack(stack, log)
 
@@ -94,7 +100,7 @@ def evaluate_final_stack(stack: Stack, log: list[str]) -> None:
         raise FinalStackInvalid('\n'.join(log))
 
 
-def script_eval(tx: Transaction, txin: TxInput, spent_tx: BaseTransaction) -> None:
+def script_eval(tx: Transaction, txin: TxInput, spent_tx: BaseTransaction, version: OpcodeVersion) -> None:
     """Evaluates the output script and input data according to
     a very limited subset of Bitcoin's scripting language.
 
@@ -112,7 +118,7 @@ def script_eval(tx: Transaction, txin: TxInput, spent_tx: BaseTransaction) -> No
     raw_script_eval(
         input_data=txin.data,
         output_script=spent_tx.outputs[txin.index].script,
-        extras=UtxoScriptExtras(tx=tx, txin=txin, spent_tx=spent_tx),
+        extras=UtxoScriptExtras(tx=tx, txin=txin, spent_tx=spent_tx, version=version),
     )
 
 
diff --git a/hathor/transaction/scripts/opcode.py b/hathor/transaction/scripts/opcode.py
@@ -15,6 +15,7 @@
 import datetime
 import struct
 from enum import IntEnum
+from typing import Callable
 
 from cryptography.exceptions import InvalidSignature
 from cryptography.hazmat.primitives import hashes
@@ -48,6 +49,11 @@
 from hathor.transaction.scripts.script_context import ScriptContext
 
 
+class OpcodeVersion(IntEnum):
+    V1 = 1
+    V2 = 2
+
+
 class Opcode(IntEnum):
     OP_0 = 0x50
     OP_1 = 0x51
@@ -626,7 +632,7 @@ def op_integer(opcode: int, stack: Stack) -> None:
         raise ScriptError(e) from e
 
 
-def execute_op_code(opcode: Opcode, context: ScriptContext) -> None:
+def execute_op_code(opcode: Opcode, context: ScriptContext, version: OpcodeVersion) -> None:
     """
     Execute a function opcode.
 
@@ -635,17 +641,27 @@ def execute_op_code(opcode: Opcode, context: ScriptContext) -> None:
         context: the script context to be manipulated.
     """
     context.logs.append(f'Executing function opcode {opcode.name} ({hex(opcode.value)})')
-    match opcode:
-        case Opcode.OP_DUP: op_dup(context)
-        case Opcode.OP_EQUAL: op_equal(context)
-        case Opcode.OP_EQUALVERIFY: op_equalverify(context)
-        case Opcode.OP_CHECKSIG: op_checksig(context)
-        case Opcode.OP_HASH160: op_hash160(context)
-        case Opcode.OP_GREATERTHAN_TIMESTAMP: op_greaterthan_timestamp(context)
-        case Opcode.OP_CHECKMULTISIG: op_checkmultisig(context)
-        case Opcode.OP_DATA_STREQUAL: op_data_strequal(context)
-        case Opcode.OP_DATA_GREATERTHAN: op_data_greaterthan(context)
-        case Opcode.OP_DATA_MATCH_VALUE: op_data_match_value(context)
-        case Opcode.OP_CHECKDATASIG: op_checkdatasig(context)
-        case Opcode.OP_FIND_P2PKH: op_find_p2pkh(context)
-        case _: raise ScriptError(f'unknown opcode: {opcode}')
+    opcode_fns: dict[Opcode, Callable[[ScriptContext], None]] = {
+        Opcode.OP_DUP: op_dup,
+        Opcode.OP_EQUAL: op_equal,
+        Opcode.OP_EQUALVERIFY: op_equalverify,
+        Opcode.OP_CHECKSIG: op_checksig,
+        Opcode.OP_HASH160: op_hash160,
+        Opcode.OP_GREATERTHAN_TIMESTAMP: op_greaterthan_timestamp,
+        Opcode.OP_CHECKMULTISIG: op_checkmultisig,
+    }
+
+    if version == OpcodeVersion.V1:
+        opcode_fns.update({
+            Opcode.OP_DATA_STREQUAL: op_data_strequal,
+            Opcode.OP_DATA_GREATERTHAN: op_data_greaterthan,
+            Opcode.OP_DATA_MATCH_VALUE: op_data_match_value,
+            Opcode.OP_CHECKDATASIG: op_checkdatasig,
+            Opcode.OP_FIND_P2PKH: op_find_p2pkh,
+        })
+
+    opcode_fn = opcode_fns.get(opcode)
+    if opcode_fn is None:
+        raise ScriptError(f'unknown opcode: {opcode}')
+
+    opcode_fn(context)
diff --git a/hathor/verification/nano_header_verifier.py b/hathor/verification/nano_header_verifier.py
@@ -76,7 +76,7 @@ def __init__(self, *, settings: HathorSettings, tx_storage: TransactionStorage)
         self._settings = settings
         self._tx_storage = tx_storage
 
-    def verify_nc_signature(self, tx: BaseTransaction) -> None:
+    def verify_nc_signature(self, tx: BaseTransaction, params: VerificationParams) -> None:
         """Verify if the caller's signature is valid."""
         assert tx.is_nano_contract()
         assert isinstance(tx, Transaction)
@@ -103,7 +103,7 @@ def verify_nc_signature(self, tx: BaseTransaction) -> None:
             raw_script_eval(
                 input_data=nano_header.nc_script,
                 output_script=output_script,
-                extras=ScriptExtras(tx=tx)
+                extras=ScriptExtras(tx=tx, version=params.features.opcode_version)
             )
         except ScriptError as e:
             raise NCInvalidSignature from e
diff --git a/hathor/verification/transaction_verifier.py b/hathor/verification/transaction_verifier.py
@@ -128,7 +128,7 @@ def verify_sigops_input(self, tx: Transaction, enable_checkdatasig_count: bool =
             raise TooManySigOps(
                 'TX[{}]: Max number of sigops for inputs exceeded ({})'.format(tx.hash_hex, n_txops))
 
-    def verify_inputs(self, tx: Transaction, *, skip_script: bool = False) -> None:
+    def verify_inputs(self, tx: Transaction, params: VerificationParams, *, skip_script: bool = False) -> None:
         """Verify inputs signatures and ownership and all inputs actually exist"""
         spent_outputs: set[tuple[VertexId, int]] = set()
         for input_tx in tx.inputs:
@@ -149,7 +149,7 @@ def verify_inputs(self, tx: Transaction, *, skip_script: bool = False) -> None:
                 ))
 
             if not skip_script:
-                self.verify_script(tx=tx, input_tx=input_tx, spent_tx=spent_tx)
+                self.verify_script(tx=tx, input_tx=input_tx, spent_tx=spent_tx, params=params)
 
             # check if any other input in this tx is spending the same output
             key = (input_tx.tx_id, input_tx.index)
@@ -158,15 +158,22 @@ def verify_inputs(self, tx: Transaction, *, skip_script: bool = False) -> None:
                     tx.hash_hex, input_tx.tx_id.hex(), input_tx.index))
             spent_outputs.add(key)
 
-    def verify_script(self, *, tx: Transaction, input_tx: TxInput, spent_tx: BaseTransaction) -> None:
+    def verify_script(
+        self,
+        *,
+        tx: Transaction,
+        input_tx: TxInput,
+        spent_tx: BaseTransaction,
+        params: VerificationParams,
+    ) -> None:
         """
         :type tx: Transaction
         :type input_tx: TxInput
         :type spent_tx: Transaction
         """
         from hathor.transaction.scripts import script_eval
         try:
-            script_eval(tx, input_tx, spent_tx)
+            script_eval(tx, input_tx, spent_tx, params.features.opcode_version)
         except ScriptError as e:
             raise InvalidInputData(e) from e
 
diff --git a/hathor/verification/verification_params.py b/hathor/verification/verification_params.py
@@ -18,6 +18,7 @@
 
 from hathor.feature_activation.utils import Features
 from hathor.transaction import Block
+from hathor.transaction.scripts.opcode import OpcodeVersion
 
 
 @dataclass(slots=True, frozen=True, kw_only=True)
@@ -48,7 +49,8 @@ def default_for_mempool(cls, *, best_block: Block, features: Features | None = N
             features = Features(
                 count_checkdatasig_op=True,
                 nano=True,
-                fee_tokens=False
+                fee_tokens=False,
+                opcode_version=OpcodeVersion.V2,
             )
 
         return cls(
diff --git a/hathor/verification/verification_service.py b/hathor/verification/verification_service.py
@@ -261,7 +261,7 @@ def _verify_tx(
             return
         self.verify_without_storage(tx, params)
         self.verifiers.tx.verify_sigops_input(tx, params.features.count_checkdatasig_op)
-        self.verifiers.tx.verify_inputs(tx)  # need to run verify_inputs first to check if all inputs exist
+        self.verifiers.tx.verify_inputs(tx, params)  # need to run verify_inputs first to check if all inputs exist
         self.verifiers.tx.verify_version(tx, params)
 
         block_storage = self._get_block_storage(params)
@@ -320,7 +320,7 @@ def verify_without_storage(self, vertex: BaseTransaction, params: VerificationPa
 
         if vertex.is_nano_contract():
             assert self._settings.ENABLE_NANO_CONTRACTS
-            self._verify_without_storage_nano_header(vertex)
+            self._verify_without_storage_nano_header(vertex, params)
 
     def _verify_without_storage_base_block(self, block: Block, params: VerificationParams) -> None:
         self.verifiers.block.verify_no_inputs(block)
@@ -359,9 +359,9 @@ def _verify_without_storage_token_creation_tx(
     ) -> None:
         self._verify_without_storage_tx(tx, params)
 
-    def _verify_without_storage_nano_header(self, tx: BaseTransaction) -> None:
+    def _verify_without_storage_nano_header(self, tx: BaseTransaction, params: VerificationParams) -> None:
         assert tx.is_nano_contract()
-        self.verifiers.nano_header.verify_nc_signature(tx)
+        self.verifiers.nano_header.verify_nc_signature(tx, params)
         self.verifiers.nano_header.verify_actions(tx)
 
     def _verify_without_storage_fee_header(self, tx: BaseTransaction) -> None:
diff --git a/hathor_cli/mining.py b/hathor_cli/mining.py
diff --git a/hathor_tests/nanocontracts/test_actions.py b/hathor_tests/nanocontracts/test_actions.py
diff --git a/hathor_tests/nanocontracts/test_nanocontract.py b/hathor_tests/nanocontracts/test_nanocontract.py
diff --git a/hathor_tests/tx/test_scripts.py b/hathor_tests/tx/test_scripts.py

Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,7 @@`
`28`	`28`	`from hathor.p2p.sync_v2.streamers import StreamEnd`
`29`	`29`	`from hathor.transaction import BaseTransaction, Transaction`
`30`	`30`	`from hathor.transaction.exceptions import HathorError, TxValidationError`
	`31`	`+from hathor.transaction.scripts.opcode import OpcodeVersion`
`31`	`32`	`from hathor.types import VertexId`
`32`	`33`	`from hathor.verification.verification_params import VerificationParams`
`33`	`34`
`@@ -59,6 +60,7 @@ def __init__(self,`
`59`	`60`	`count_checkdatasig_op=False,`
`60`	`61`	`nano=False,`
`61`	`62`	`fee_tokens=False,`
	`63`	`+ opcode_version=OpcodeVersion.V1,`
`62`	`64`	`)`
`63`	`65`	`)`
`64`	`66`