tx-engine 0.7.4__cp314-cp314-win_amd64.whl

tx_engine/__init__.py

@@ -0,0 +1,14 @@
+"""
+This is a tx_engine doc str
+"""
+# noqa: F401 - 'x' - imported but unused
+
+from tx_engine.tx_engine import Tx, TxIn, TxOut, Script, Stack, 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_preimage_checksig_index, sig_hash, sig_hash_checksig_index, wif_to_bytes, bytes_to_wif, wif_from_pw_nonce  # 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
+from tx_engine.engine.cryptography_utils import create_wallet_from_pem_bytes, create_pem_from_wallet  # noqa: F401

tx_engine/engine/context.py

@@ -0,0 +1,91 @@
+""" This is the execution context for the script
+"""
+
+from typing import Optional, List
+
+from tx_engine.tx_engine import py_script_eval_pystack, Script, Stack
+
+
+class Context:
+    """ This class captures an execution context for the script
+    """
+    def __init__(self, script: None | Script = None, ip_start: None | int = None, ip_limit: None | int = None, z: None | bytes = None):
+        """ Intial setup
+        """
+        self.ip_start: Optional[int]
+        self.ip_limit: Optional[int]
+        self.z: Optional[bytes]
+        self.stack: Stack = Stack()
+        self.alt_stack: Stack = Stack()
+
+        if script:
+            self.cmds = script.get_commands()
+        else:
+            self.cmds = []
+
+        self.ip_start = ip_start if ip_start else None
+        self.ip_limit = ip_limit if ip_limit else None
+        self.z = z if z else None
+
+    def set_commands(self, script: Script) -> None:
+        """ Set the commands
+        """
+        self.cmds = script.get_commands()
+
+    def reset_stacks(self) -> None:
+        """ Reset the stacks
+        """
+        self.stack = Stack()
+        self.alt_stack = 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:
+            (self.stack, self.alt_stack, finish_loc) = py_script_eval_pystack(self.cmds, self.ip_start, self.ip_limit, self.z, self.stack, self.alt_stack)
+        except Exception as e:
+            if not quiet:
+                print(f"script_eval exception '{e}'")
+            return False
+        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
+
+        if self.stack.size() == 0:
+            return False
+
+        # if the size is 1, then check the top element for either empty or zero
+        if self.stack.size() == 1:
+            # no entry or 0 => false.
+            if self.get_stack() == Stack([[]]) or self.get_stack() == Stack([[0]]):
+                return False
+
+        if self.get_stack()[0] == [0] or self.get_stack()[0] == []:
+            return False
+        return True
+
+    def get_stack(self) -> Stack:
+        """ Return the data stack as human readable
+        """
+        return self.stack
+
+    def get_altstack(self) -> Stack:
+        """ Return the get_altstack as human readable
+        """
+        return self.alt_stack
+
+    def get_stack_hex(self) -> List[str]:
+        return self.stack.get_stack_hex()
+
+    def set_ip_start(self, start: int) -> None:
+        self.ip_start = start
+
+    def set_ip_limit(self, limit: int) -> None:
+        self.ip_limit = limit

tx_engine/engine/cryptography_utils.py

@@ -0,0 +1,46 @@
+from tx_engine import Wallet
+
+from cryptography.hazmat.primitives.serialization import load_pem_private_key
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives import serialization
+
+
+def bigint_to_private_key(private_key_int: int) -> ec.EllipticCurvePrivateKey:
+    '''Convert a BigInt to an ECDSA private key.
+    '''
+    return ec.derive_private_key(private_key_int, ec.SECP256K1())
+
+
+def create_wallet_from_pem_file(pem_file_path: str, network: str) -> Wallet:
+    # Load the PEM file
+    with open(pem_file_path, 'rb') as pem_file:
+        pem_data = pem_file.read()
+
+    return create_wallet_from_pem_bytes(pem_data, network)
+
+
+def create_wallet_from_pem_bytes(pem_data: bytes, network: str) -> Wallet:
+    # Load the private key from the PEM data
+    private_key = load_pem_private_key(pem_data, password=None, backend=default_backend())
+    assert isinstance(private_key, ec.EllipticCurvePrivateKey)
+
+    # Extract the private numbers (this includes the scalar/private key value)
+    private_numbers = private_key.private_numbers()
+
+    # The scalar value of the private key (as an integer)
+    private_key_scalar = private_numbers.private_value
+
+    # Convert the scalar value to bytes
+    private_key_bytes = private_key_scalar.to_bytes((private_key_scalar.bit_length() + 7) // 8, byteorder='big')
+
+    return Wallet.from_bytes(network, private_key_bytes)
+
+
+def create_pem_from_wallet(user_wallet: Wallet) -> str:
+    ec_pri_key: ec.EllipticCurvePrivateKey = bigint_to_private_key(user_wallet.to_int())
+    pem = ec_pri_key.private_bytes(encoding=serialization.Encoding.PEM,
+                                   format=serialization.PrivateFormat.PKCS8,
+                                   encryption_algorithm=serialization.NoEncryption()
+                                   )
+    return pem.decode('utf-8')

tx_engine/engine/engine_types.py

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

tx_engine/engine/util.py

@@ -0,0 +1,109 @@
+""" Engine utility scripts and constants
+"""
+from typing import List, Final
+
+from .engine_types import StackElement
+
+# Maximum script number length before Genesis (equal to CScriptNum::MAXIMUM_ELEMENT_SIZE)
+MAX_SCRIPT_NUM_LENGTH_BEFORE_GENESIS: Final = 4
+# Maximum script number length after Genesis
+MAX_SCRIPT_NUM_LENGTH_AFTER_GENESIS: Final = 750 * 1000
+# Maximum size that we are using
+MAXIMUM_ELEMENT_SIZE: Final = MAX_SCRIPT_NUM_LENGTH_AFTER_GENESIS
+
+# Curve constants
+# perhaps we can source these from the secp256k1 library rather than here?
+PRIME_INT: Final = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
+GROUP_ORDER_INT: Final = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
+HALF_GROUP_ORDER_INT: Final = GROUP_ORDER_INT // 2
+Gx: Final = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
+Gx_bytes: Final = bytes.fromhex('79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798')
+Gy: Final = 0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8
+GUncompressed: Final = "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()}")
+        raise ValueError(f"Value is not minimally encoded: {element}")
+
+    if isinstance(element, int):
+        return element
+
+    if 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
+        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,84 @@
+""" This contains the base class for all blockchain interfaces
+"""
+
+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):
+        """ Configures the interface based on the provided config
+        """
+
+    @abstractmethod
+    def get_utxo(self, address: str):
+        """ Given the address returns the associated UTXO
+        """
+
+    @abstractmethod
+    def get_block_count(self) -> int:
+        """ Returns the current block height
+        """
+
+    @abstractmethod
+    def get_raw_transaction(self, txid: str) -> Optional[str]:
+        """ Given the txid return the transaction
+        """
+
+    @abstractmethod
+    def get_transaction(self, txid: str) -> Dict:
+        """ Given the txid return the transaction as a dictionary
+        """
+
+    @abstractmethod
+    def broadcast_tx(self, tx: str):
+        """ Broadcast a transaction
+        """
+
+    @abstractmethod
+    def is_testnet(self) -> bool:
+        """ Return true if the interface is operating on testnet
+        """
+
+    @abstractmethod
+    def get_balance(self, address) -> int:
+        """ Return the balance associated with the provided address
+        """
+
+    @abstractmethod
+    def get_best_block_hash(self) -> str:
+        """ Return the current best block hash
+        """
+
+    @abstractmethod
+    def get_tx_out(self, txid: str, txindex: int) -> Dict:
+        """ abstract method definition to define the get_tx_out call to an RPC SV node
+        """
+
+    @abstractmethod
+    def get_block(self, blockhash: str) -> Dict:
+        """ Given the blockhash return the block as a dictionary
+        """
+
+    @abstractmethod
+    def get_merkle_proof(self, block_hash: str, tx_id: str) -> str:
+        """ Given the blockhash and tx_id return the merkle proof
+        """
+
+    @abstractmethod
+    def get_block_header(self, block_hash: str) -> Dict:
+        """ Given the block hash return the block header
+        """
+
+    @abstractmethod
+    def verifyscript(self, scripts: list, stop_on_first_invalid: bool = True, timeout: int = 100) -> List[Any]:
+        """ Given an script and context, verify the script
+            This call is only available from local RPC interface
+        """

tx_engine/interface/interface_factory.py

@@ -0,0 +1,28 @@
+""" This creates interfaces to the BSV blockchain
+"""
+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:
+        """ Given a config returns the required configured Interface
+        """
+        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()