tx-engine 0.6.6__cp312-none-win_amd64.whl

tx_engine/__init__.py

@@ -0,0 +1,13 @@
+"""
+This is a tx_engine doc str
+"""
+# noqa: F401 - 'x' - imported but unused
+
+from tx_engine.tx_engine import Tx, TxIn, TxOut, Script, Wallet, p2pkh_script, hash160, hash256d, address_to_public_key_hash, public_key_to_address  # noqa: F401
+from tx_engine.tx_engine import sig_hash_preimage, sig_hash, wif_to_bytes  # noqa: F401
+from tx_engine.engine.context import Context  # noqa: F401
+from tx_engine.engine.util import encode_num, decode_num  # noqa: F401
+from tx_engine.tx.sighash import SIGHASH  # noqa: F401
+from tx_engine.interface.interface_factory import interface_factory   # noqa: F401
+from tx_engine.interface.woc_interface import WoCInterface   # noqa: F401
+from tx_engine.interface.mock_interface import MockInterface   # noqa: F401

tx_engine/engine/context.py

@@ -0,0 +1,116 @@
+from typing import Optional
+
+from tx_engine.tx_engine import py_script_eval, Script
+from tx_engine.engine.util import decode_num
+
+
+from .engine_types import Commands, Stack, StackElement
+from .op_codes import OP_PUSHDATA1, OP_PUSHDATA2, OP_PUSHDATA4
+
+
+def decode_element(elem: StackElement) -> int:
+    try:
+        retval = decode_num(bytes(elem))
+    except RuntimeError as e:
+        print(f"runtime error {e}")
+        retval = elem  # type: ignore[assignment]
+        print(f"elem={elem}, retval={retval}, type={type(retval)}")  # type: ignore[str-bytes-safe]
+    return retval
+
+
+def cmds_as_bytes(cmds: Commands) -> bytes:
+    """ Given commands return bytes - prior to passing to Rust
+    """
+    retval = bytearray()
+    for c in cmds:
+        if isinstance(c, int):
+            retval += c.to_bytes(1, byteorder='big')
+        elif isinstance(c, list):
+            retval += cmds_as_bytes(c)
+        else:
+            # If we have a byte array without a preceeding length, add it, if less than 0x4c
+            # Otherwise would expect OP_PUSHDATA preceeding
+            if len(c) < 0x4c:
+                if len(retval) == 0:
+                    retval += len(c).to_bytes(1, byteorder='big')
+                elif not retval[-1] in [OP_PUSHDATA1, OP_PUSHDATA2, OP_PUSHDATA4] and retval[-1] != len(c):
+                    retval += len(c).to_bytes(1, byteorder='big')
+            retval += c
+    return bytes(retval)
+
+
+class Context:
+    """ This class captures an execution context for the script
+    """
+    def __init__(self, script: None | Script = None, cmds: None | Commands = None, ip_limit: None | int = None, z: None | bytes = None):
+        self.cmds: Commands
+        self.ip_limit: Optional[int]
+        self.z: Optional[bytes]
+        self.stack: Stack = []
+        self.alt_stack: Stack = []
+        self.raw_stack: Stack = []
+        self.raw_alt_stack: Stack = []
+
+        if script:
+            self.cmds = script.get_commands()
+        elif cmds:
+            self.cmds = cmds[:]
+        else:
+            self.cmds = []
+
+        self.ip_limit = ip_limit if ip_limit else None
+        self.z = z if z else None
+
+    def set_commands(self, cmds: Commands) -> None:
+        self.cmds = cmds[:]
+
+    def reset_stacks(self) -> None:
+        self.stack = []
+        self.alt_stack = []
+        self.raw_stack = []
+        self.raw_alt_stack = []
+
+    def evaluate_core(self, quiet: bool = False) -> bool:
+        """ evaluate_core calls the interpreter and returns the stacks
+            if quiet is true, dont print exceptions
+        """
+        try:
+            cmds = cmds_as_bytes(self.cmds)
+        except Exception as e:
+            if not quiet:
+                print(f"cmds_as_bytes exception '{e}'")
+            return False
+        try:
+            (self.raw_stack, self.raw_alt_stack) = py_script_eval(cmds, self.ip_limit, self.z)
+        except Exception as e:
+            if not quiet:
+                print(f"script_eval exception '{e}'")
+            return False
+        else:
+            return True
+
+    def evaluate(self, quiet: bool = False) -> bool:
+        """ evaluate calls Evaluate_core and checks the stack has the correct value on return
+            if quiet is true, dont print exceptions
+        """
+        if not self.evaluate_core(quiet):
+            return False
+        self.stack = [decode_element(s) for s in self.raw_stack]
+        self.alt_stack = [decode_element(s) for s in self.raw_alt_stack]
+        if len(self.stack) == 0:
+            return False
+        if self.stack[-1] == 0:  # was b""
+            return False
+        return True
+
+    def get_stack(self) -> Stack:
+        """ Return the data stack as human readable
+        """
+        self.stack = [decode_element(s) for s in self.raw_stack]
+        return self.stack
+
+    def get_altstack(self):
+        """ Return the get_altstack as human readable
+        """
+        self.alt_stack = [decode_element(s) for s in self.raw_alt_stack]
+        return self.alt_stack

tx_engine/engine/decode_op.py

@@ -0,0 +1,38 @@
+from typing import Union
+
+from .util import encode_num
+from .op_code_names import OP_CODE_NAMES
+
+
+# Create a dictionary of OP_DUP -> 118, DUP -> 118
+OPS_STANDARD = {v: k for (k, v) in OP_CODE_NAMES.items()}
+SHORT_TO_LONG_OP = {k.split("_")[1]: v for (k, v) in OPS_STANDARD.items()}
+ALL_OPS = {**OPS_STANDARD, **SHORT_TO_LONG_OP}
+
+
+def decode_op(op: str) -> Union[int, bytes]:
+    """ Given an op as string convert it to parsable value
+        e.g. "OP_2" -> 0x52
+    """
+    op = op.strip()
+    if op[:2] == "0x":
+        b: bytes = bytes.fromhex(op[2:])
+        return b
+
+    elif op in ALL_OPS:
+        n: int = ALL_OPS[op]
+        return n
+
+    else:
+        n = eval(op)
+        if isinstance(n, int):
+            x: bytes = encode_num(n)
+            return x
+        elif isinstance(n, str):
+            y = n.encode("utf-8")
+            return y
+        elif isinstance(n, bytes):
+            return n
+        else:
+            # have not captured conversion
+            assert 1 == 2  # should not get here

tx_engine/engine/engine_types.py

@@ -0,0 +1,7 @@
+from typing import List, Union, MutableSequence
+
+Command = Union[int, bytes]
+Commands = MutableSequence[Command]
+
+StackElement = Union[int, bytes]
+Stack = List[StackElement]

tx_engine/engine/op_code_names.py

@@ -0,0 +1,108 @@
+from typing import Dict
+
+OP_CODE_NAMES: Dict[int, str] = {
+    0: "OP_0",
+    76: "OP_PUSHDATA1",
+    77: "OP_PUSHDATA2",
+    78: "OP_PUSHDATA4",
+    79: "OP_1NEGATE",
+    80: "OP_RESERVED",
+    81: "OP_1",
+    82: "OP_2",
+    83: "OP_3",
+    84: "OP_4",
+    85: "OP_5",
+    86: "OP_6",
+    87: "OP_7",
+    88: "OP_8",
+    89: "OP_9",
+    90: "OP_10",
+    91: "OP_11",
+    92: "OP_12",
+    93: "OP_13",
+    94: "OP_14",
+    95: "OP_15",
+    96: "OP_16",
+    97: "OP_NOP",
+    98: "OP_VER",
+    99: "OP_IF",
+    100: "OP_NOTIF",
+    101: "OP_VERIF",
+    102: "OP_NOTVERIF",
+    103: "OP_ELSE",
+    104: "OP_ENDIF",
+    105: "OP_VERIFY",
+    106: "OP_RETURN",
+    107: "OP_TOALTSTACK",
+    108: "OP_FROMALTSTACK",
+    109: "OP_2DROP",
+    110: "OP_2DUP",
+    111: "OP_3DUP",
+    112: "OP_2OVER",
+    113: "OP_2ROT",
+    114: "OP_2SWAP",
+    115: "OP_IFDUP",
+    116: "OP_DEPTH",
+    117: "OP_DROP",
+    118: "OP_DUP",
+    119: "OP_NIP",
+    120: "OP_OVER",
+    121: "OP_PICK",
+    122: "OP_ROLL",
+    123: "OP_ROT",
+    124: "OP_SWAP",
+    125: "OP_TUCK",
+    126: "OP_CAT",
+    127: "OP_SPLIT",
+    128: "OP_NUM2BIN",
+    129: "OP_BIN2NUM",
+    130: "OP_SIZE",
+    131: "OP_INVERT",
+    132: "OP_AND",
+    133: "OP_OR",
+    134: "OP_XOR",
+    135: "OP_EQUAL",
+    136: "OP_EQUALVERIFY",
+    137: "OP_RESERVED1",
+    138: "OP_RESERVED2",
+    139: "OP_1ADD",
+    140: "OP_1SUB",
+    141: "OP_2MUL",  # disabled
+    142: "OP_2DIV",  # disabled
+    143: "OP_NEGATE",
+    144: "OP_ABS",
+    145: "OP_NOT",
+    146: "OP_0NOTEQUAL",
+    147: "OP_ADD",
+    148: "OP_SUB",
+    149: "OP_MUL",
+    150: "OP_DIV",
+    151: "OP_MOD",
+    152: "OP_LSHIFT",
+    153: "OP_RSHIFT",
+    154: "OP_BOOLAND",
+    155: "OP_BOOLOR",
+    156: "OP_NUMEQUAL",
+    157: "OP_NUMEQUALVERIFY",
+    158: "OP_NUMNOTEQUAL",
+    159: "OP_LESSTHAN",
+    160: "OP_GREATERTHAN",
+    161: "OP_LESSTHANOREQUAL",
+    162: "OP_GREATERTHANOREQUAL",
+    163: "OP_MIN",
+    164: "OP_MAX",
+    165: "OP_WITHIN",
+    166: "OP_RIPEMD160",
+    167: "OP_SHA1",
+    168: "OP_SHA256",
+    169: "OP_HASH160",
+    170: "OP_HASH256",
+    171: "OP_CODESEPARATOR",
+    172: "OP_CHECKSIG",
+    173: "OP_CHECKSIGVERIFY",
+    174: "OP_CHECKMULTISIG",
+    175: "OP_CHECKMULTISIGVERIFY",
+    176: "OP_NOP1",
+    177: "OP_CHECKLOCKTIMEVERIFY",
+    178: "OP_CHECKSEQUENCEVERIFY"
+}

tx_engine/engine/op_codes.py

@@ -0,0 +1,122 @@
+# Used to convert OP name to code
+
+OP_0 = 0
+OP_FALSE = 0
+OP_PUSHDATA1 = 0x4C
+OP_PUSHDATA2 = 0x4D
+OP_PUSHDATA4 = 0x4E
+OP_1NEGATE = 0x4F
+OP_RESERVED = 0x50
+OP_TRUE = 0x51
+OP_1 = 0x51
+OP_2 = 0x52
+OP_3 = 0x53
+OP_4 = 0x54
+OP_5 = 0x55
+OP_6 = 0x56
+OP_7 = 0x57
+OP_8 = 0x58
+OP_9 = 0x59
+OP_10 = 0x5A
+OP_11 = 0x5B
+OP_12 = 0x5C
+OP_13 = 0x5D
+OP_14 = 0x5E
+OP_15 = 0x5F
+OP_16 = 0x60
+
+# Control
+OP_NOP = 0x61
+OP_VER = 0x62
+OP_IF = 0x63
+OP_NOTIF = 0x64
+OP_VERIF = 0x65
+OP_VERNOTIF = 0x66
+OP_ELSE = 0x67
+OP_ENDIF = 0x68
+OP_VERIFY = 0x69
+OP_RETURN = 0x6A
+
+# stack ops
+OP_TOALTSTACK = 0x6B
+OP_FROMALTSTACK = 0x6C
+OP_2DROP = 0x6D
+OP_2DUP = 0x6E
+OP_3DUP = 0x6F
+OP_2OVER = 0x70
+OP_2ROT = 0x71
+OP_2SWAP = 0x72
+OP_IFDUP = 0x73
+OP_DEPTH = 0x74
+OP_DROP = 0x75
+OP_DUP = 0x76
+OP_NIP = 0x77
+OP_OVER = 0x78
+OP_PICK = 0x79
+OP_ROLL = 0x7A
+OP_ROT = 0x7B
+OP_SWAP = 0x7C
+OP_TUCK = 0x7D
+
+# Splice ops - BSV
+OP_CAT = 0x7E
+OP_SPLIT = 0x7F
+OP_NUM2BIN = 0x80
+OP_BIN2NUM = 0x81
+OP_SIZE = 0x82
+# 0x83{131} .. 0x86{134} - transaction invalid for non BSV
+
+# Bit logic - BSV
+OP_INVERT = 0x83
+OP_AND = 0x84
+OP_OR = 0x85
+OP_XOR = 0x86
+OP_EQUAL = 0x87
+OP_EQUALVERIFY = 0x88
+OP_RESERVED1 = 0x89
+OP_RESERVED2 = 0x8A
+
+# Artithmetic
+OP_1ADD = 0x8B
+OP_1SUB = 0x8C
+OP_2MUL = 0x8D  # Disabled
+OP_2DIV = 0x8E  # Disabled
+OP_NEGATE = 0x8F
+OP_ABS = 0x90
+OP_NOT = 0x91
+OP_0NOTEQUAL = 0x92
+OP_ADD = 0x93
+OP_SUB = 0x94
+OP_MUL = 0x95
+OP_DIV = 0x96
+OP_MOD = 0x97
+OP_LSHIFT = 0x98
+OP_RSHIFT = 0x99
+
+OP_BOOLAND = 0x9A
+OP_BOOLOR = 0x9B
+OP_NUMEQUAL = 0x9C
+OP_NUMEQUALVERIFY = 0x9D
+OP_NUMNOTEQUAL = 0x9E
+OP_LESSTHAN = 0x9F
+OP_GREATERTHAN = 0xA0
+OP_LESSTHANOREQUAL = 0xA1
+OP_GREATERTHANOREQUAL = 0xA2
+OP_MIN = 0xA3
+OP_MAX = 0xA4
+OP_WITHIN = 0xA5
+OP_RIPEMD160 = 0xA6
+OP_SHA1 = 0xA7
+OP_SHA256 = 0xA8
+OP_HASH160 = 0xA9
+OP_HASH256 = 0xAA
+OP_CODESEPARATOR = 0xAB
+OP_CHECKSIG = 0xAC
+OP_CHECKSIGVERIFY = 0xAD
+OP_CHECKMULTISIG = 0xAE
+OP_CHECKMULTISIGVERIFY = 0xAF
+
+# Expansion
+OP_NOP1 = 0xB0
+OP_CHECKLOCKTIMEVERIFY = 0xB1
+OP_CHECKSEQUENCEVERIFY = 0xB2

tx_engine/engine/util.py

@@ -0,0 +1,109 @@
+from typing import List
+
+from .engine_types import StackElement
+
+# Maximum script number length before Genesis (equal to CScriptNum::MAXIMUM_ELEMENT_SIZE)
+MAX_SCRIPT_NUM_LENGTH_BEFORE_GENESIS = 4
+# Maximum script number length after Genesis
+MAX_SCRIPT_NUM_LENGTH_AFTER_GENESIS = 750 * 1000
+# Maximum size that we are using
+MAXIMUM_ELEMENT_SIZE = MAX_SCRIPT_NUM_LENGTH_AFTER_GENESIS
+
+# Curve constants
+# perhaps we can source these from the secp256k1 library rather than here?
+PRIME_INT = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
+GROUP_ORDER_INT = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
+HALF_GROUP_ORDER_INT = GROUP_ORDER_INT // 2
+Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
+Gx_bytes = bytes.fromhex('79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798')
+Gy = 0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8
+GUncompressed = "0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8"
+
+
+def encode_num(num: int) -> bytes:
+    """ Encode a number, return a bytearray in little endian
+    """
+    if num == 0:
+        return b""
+    abs_num = abs(num)
+    negative = num < 0
+    result = bytearray()
+    while abs_num:
+        result.append(abs_num & 0xFF)
+        abs_num >>= 8
+    if result[-1] & 0x80:
+        if negative:
+            result.append(0x80)
+        else:
+            result.append(0)
+    elif negative:
+        result[-1] |= 0x80
+    return bytes(result)
+
+
+def is_minimally_encoded(element, max_element_size=MAXIMUM_ELEMENT_SIZE) -> bool:
+    """ Determines if an element is minimally encoded, returns True if it is.
+        Code copied from SV codebase for details see:
+            file: int_serialization.h, function: IsMinimallyEncoded, line: 98
+    """
+    if isinstance(element, int):
+        return True
+    size = len(element)
+    if size > max_element_size:
+        return False
+    if size > 0:
+        elem = element[::-1]
+        if elem[0] & 0x7f == 0:
+            if size <= 1 or (elem[1] & 0x80 == 0):
+                return False
+    return True
+
+
+def decode_num(element: StackElement, check_encoding=False) -> int:
+    """ Take a byte(array), return a number
+    """
+    if element == b"":
+        return 0
+
+    if check_encoding and not is_minimally_encoded(element):
+        if isinstance(element, bytes):
+            raise ValueError(f"Value is not minimally encoded: {element.hex()}")
+        else:
+            raise ValueError(f"Value is not minimally encoded: {element}")
+
+    if isinstance(element, int):
+        return element
+
+    elif isinstance(element, bytes):
+        try:
+            b = element
+            big_endian = b[::-1]
+        except TypeError:
+            # TypeError: 'int' object is not subscriptable
+            return int(element)
+        if big_endian[0] & 0x80:
+            negative = True
+            result = big_endian[0] & 0x7F
+        else:
+            negative = False
+            result = big_endian[0]
+        for c in big_endian[1:]:
+            result <<= 8
+            result += c
+        if negative:
+            return -result
+        else:
+            return result
+    else:
+        raise ValueError(f"Value is of unknown type: {element} {type(element)}")
+
+
+def insert_num(val: int) -> List[int]:
+    """ This function is used to insert numbers into script
+    """
+    val_as_bytes = bytearray(encode_num(val))
+    length = len(val_as_bytes)
+    assert length < 0x4c, "Length of number too long, need to encode using OP_PUSHDATA"
+    # Insert the length
+    val_as_bytes.insert(0, length)
+    return list(val_as_bytes)

tx_engine/interface/blockchain_interface.py

@@ -0,0 +1,79 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Optional, MutableMapping, Any, List
+
+ConfigType = MutableMapping[str, Any]
+
+
+class BlockchainInterface(ABC):
+    """ This is a BlockchainInterface abstract base class
+        This will need to be extended with the used methods
+    """
+
+    @abstractmethod
+    def set_config(self, config: ConfigType):
+        pass
+
+    @abstractmethod
+    def get_utxo(self, address: str):
+        pass
+
+    @abstractmethod
+    def get_block_count(self) -> int:
+        pass
+
+    @abstractmethod
+    def get_raw_transaction(self, txid: str) -> Optional[str]:
+        pass
+
+    @abstractmethod
+    def get_transaction(self, txid: str) -> Dict:
+        pass
+
+    @abstractmethod
+    def broadcast_tx(self, tx: str):
+        pass
+
+    @abstractmethod
+    def is_testnet(self) -> bool:
+        pass
+
+    @abstractmethod
+    def get_balance(self, address) -> int:
+        pass
+
+    """ abstract method definition for get_best_block_hash
+    """
+    @abstractmethod
+    def get_best_block_hash(self) -> str:
+        pass
+
+    """ abstract method definition to define the get_tx_out call to an RPC SV node
+    """
+    @abstractmethod
+    def get_tx_out(self, txid: str, txindex: int) -> Dict:
+        pass
+
+    """ abstract method definition to define an interface for getblock
+    """
+    @abstractmethod
+    def get_block(self, blockhash: str) -> Dict:
+        pass
+
+    """ absract method definition for merkle proof retrieval
+    """
+    @abstractmethod
+    def get_merkle_proof(self, block_hash: str, tx_id: str) -> str:
+        pass
+
+    ''' abstract method definition for getting block headers from WoC
+    '''
+    @abstractmethod
+    def get_block_header(self, block_hash: str) -> Dict:
+        pass
+
+    ''' abstract method definition for executing verify script.
+        This call is not available from WoC
+    '''
+    @abstractmethod
+    def verifyscript(self, scripts: list, stopOnFirstInvalid: bool = True, totalTimeout: int = 100) -> List[Any]:
+        pass

tx_engine/interface/interface_factory.py

@@ -0,0 +1,24 @@
+from .blockchain_interface import ConfigType
+from .mock_interface import MockInterface
+from .woc_interface import WoCInterface
+from .rpc_interface import RPCInterface
+
+
+INTERFACE_MAPPING = {
+    "mock": MockInterface,
+    "woc": WoCInterface,
+    "rpc": RPCInterface,
+}
+
+
+class InterfaceFactory:
+    """ A class for creating interfaces to the BSV blockchain """
+
+    def set_config(self, config: ConfigType) -> MockInterface | WoCInterface | RPCInterface:
+        interface_type = config['interface_type']
+        interface = INTERFACE_MAPPING[interface_type]()  # type: ignore[abstract]
+        interface.set_config(config)
+        return interface  # type: ignore[return-value]
+
+
+interface_factory = InterfaceFactory()