21_Create/CreateOp.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "2b96b12e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import sha3\n",
    "import rlp\n",
    "\n",
    "STOP = 0x00\n",
    "ADD = 0x01\n",
    "MUL = 0x02\n",
    "SUB = 0x03\n",
    "DIV = 0x04\n",
    "SDIV = 0x05\n",
    "MOD = 0x06\n",
    "SMOD = 0x07\n",
    "ADDMOD = 0x08\n",
    "MULMOD = 0x09\n",
    "EXP = 0x0A\n",
    "SIGNEXTEND = 0x0B\n",
    "LT = 0x10\n",
    "GT = 0x11\n",
    "SLT = 0x12\n",
    "SGT = 0x13\n",
    "EQ = 0x14\n",
    "ISZERO = 0x15\n",
    "AND = 0x16\n",
    "OR = 0x17\n",
    "XOR = 0x18\n",
    "NOT = 0x19\n",
    "BYTE = 0x1A\n",
    "SHL = 0x1B\n",
    "SHR = 0x1C\n",
    "SAR = 0x1D\n",
    "SHA3 = 0x20\n",
    "ADDRESS = 0x30\n",
    "BALANCE = 0x31\n",
    "ORIGIN = 0x32\n",
    "CALLER = 0x33\n",
    "CALLVALUE = 0x34\n",
    "CALLDATALOAD = 0x35\n",
    "CALLDATASIZE = 0x36\n",
    "CALLDATACOPY = 0x37\n",
    "CODESIZE = 0x38\n",
    "CODECOPY = 0x39\n",
    "GASPRICE = 0x3A\n",
    "EXTCODESIZE = 0x3B\n",
    "EXTCODECOPY = 0x3C\n",
    "EXTCODEHASH = 0x3F\n",
    "BLOCKHASH = 0x40\n",
    "COINBASE = 0x41\n",
    "TIMESTAMP = 0x42\n",
    "NUMBER = 0x43\n",
    "PREVRANDAO = 0x44\n",
    "GASLIMIT = 0x45\n",
    "CHAINID = 0x46\n",
    "SELFBALANCE = 0x47\n",
    "BASEFEE = 0x48\n",
    "PUSH0 = 0x5F\n",
    "PUSH1 = 0x60\n",
    "PUSH32 = 0x7F\n",
    "DUP1 = 0x80\n",
    "DUP16 = 0x8F\n",
    "SWAP1 = 0x90\n",
    "SWAP16 = 0x9F\n",
    "POP = 0x50\n",
    "MLOAD = 0x51\n",
    "MSTORE = 0x52\n",
    "MSTORE8 = 0x53\n",
    "SLOAD = 0x54\n",
    "SSTORE = 0x55\n",
    "JUMP = 0x56\n",
    "JUMPI = 0x57\n",
    "PC = 0x58\n",
    "MSIZE = 0x59\n",
    "JUMPDEST = 0x5B\n",
    "LOG0 = 0xA0\n",
    "LOG1 = 0xA1\n",
    "LOG2 = 0xA2\n",
    "LOG3 = 0xA3\n",
    "LOG4 = 0xA4\n",
    "RETURN = 0xF3\n",
    "RETURNDATASIZE = 0x3D\n",
    "RETURNDATACOPY = 0x3E\n",
    "CREATE = 0xF0\n",
    "CALL = 0xF1\n",
    "CALLCODE = 0xF2\n",
    "DELEGATECALL = 0xF4\n",
    "STATICCALL = 0xFA\n",
    "REVERT = 0xFD\n",
    "INVALID = 0xFE\n",
    "\n",
    "account_db = {\n",
    "    '0x9bbfed6889322e016e0a02ee459d306fc19545d8': {\n",
    "        'balance': 100, # wei\n",
    "        'nonce': 1, \n",
    "        'storage': {},\n",
    "        'code': b''\n",
    "    },\n",
    "    '0x1000000000000000000000000000000000000c42': {\n",
    "        'balance': 0, # wei\n",
    "        'nonce': 0, \n",
    "        'storage': {},\n",
    "        'code': b'\\x60\\x42\\x60\\x00\\x52\\x60\\x01\\x60\\x1f\\xf3'  # PUSH1 0x42 PUSH1 0 MSTORE PUSH1 1 PUSH1 31 RETURN\n",
    "    },\n",
    "\n",
    "    # ... 其他账户数据 ...\n",
    "}\n",
    "\n",
    "class Transaction:\n",
    "    def __init__(self, to = '', value = 0, data = '', caller='0x00', origin='0x00', thisAddr='0x00', gasPrice=1, gasLimit=21000, nonce=0, v=0, r=0, s=0):\n",
    "        self.nonce = nonce\n",
    "        self.gasPrice = gasPrice\n",
    "        self.gasLimit = gasLimit\n",
    "        self.to = to\n",
    "        self.value = value\n",
    "        self.data = data\n",
    "        self.caller = caller\n",
    "        self.origin = origin\n",
    "        self.thisAddr = thisAddr\n",
    "        self.v = v\n",
    "        self.r = r\n",
    "        self.s = s\n",
    "\n",
    "class StopException(Exception):\n",
    "    pass\n",
    "\n",
    "class Log:\n",
    "    def __init__(self, address, data, topics=[]):\n",
    "        self.address = address\n",
    "        self.data = data\n",
    "        self.topics = topics\n",
    "\n",
    "    def __str__(self):\n",
    "        return f'Log(address={self.address}, data={self.data}, topics={self.topics})'\n",
    "\n",
    "class EVM:\n",
    "    def __init__(self, code, txn = None, is_static=False):\n",
    "        self.code = code # 初始化字节码，bytes对象\n",
    "        self.is_static = is_static\n",
    "        self.pc = 0  # 初始化程序计数器为0\n",
    "        self.stack = [] # 堆栈初始为空\n",
    "        self.memory = bytearray()  # 内存初始化为空\n",
    "        self.storage = {}  # 存储初始化为空字典\n",
    "        self.success = True\n",
    "        self.txn = txn\n",
    "        self.logs = []\n",
    "        self.returnData = bytearray()\n",
    "        self.current_block = {\n",
    "            \"blockhash\": 0x7527123fc877fe753b3122dc592671b4902ebf2b325dd2c7224a43c0cbeee3ca,\n",
    "            \"coinbase\": 0x388C818CA8B9251b393131C08a736A67ccB19297,\n",
    "            \"timestamp\": 1625900000,\n",
    "            \"number\": 17871709,\n",
    "            \"prevrandao\": 0xce124dee50136f3f93f19667fb4198c6b94eecbacfa300469e5280012757be94,\n",
    "            \"gaslimit\": 30,\n",
    "            \"chainid\": 1,\n",
    "            \"selfbalance\": 100,\n",
    "            \"basefee\": 30,\n",
    "        }\n",
    "\n",
    "    def next_instruction(self):\n",
    "        op = self.code[self.pc]  # 获取当前指令\n",
    "        self.pc += 1  # 递增\n",
    "        return op\n",
    "\n",
    "    def findValidJumpDestinations(self):\n",
    "        # 确保JumpDest不是PUSH的参数\n",
    "        pc = 0\n",
    "\n",
    "        while pc < len(self.code):\n",
    "            op = self.code[pc]\n",
    "            if op == JUMPDEST:\n",
    "                self.validJumpDest[pc] = True\n",
    "            elif op >= PUSH1 and op <= PUSH32:\n",
    "                pc += op - PUSH1 + 1\n",
    "            pc += 1\n",
    "\n",
    "    def push(self, size):\n",
    "        data = self.code[self.pc:self.pc + size] # 按照size从code中获取数据\n",
    "        value = int.from_bytes(data, 'big') # 将bytes转换为int\n",
    "        self.stack.append(value) # 压入堆栈\n",
    "        self.pc += size # pc增加size单位\n",
    "\n",
    "    def pop(self):\n",
    "        if len(self.stack) == 0:\n",
    "            raise Exception('Stack underflow')\n",
    "        return self.stack.pop() # 弹出堆栈\n",
    "\n",
    "    def add(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        b = self.stack.pop()\n",
    "        res = (a + b) % (2**256) # 加法结果需要模2^256，防止溢出\n",
    "        self.stack.append(res)\n",
    "        \n",
    "    def mul(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        b = self.stack.pop()\n",
    "        res = (a * b) % (2**256) # 乘法结果需要模2^256，防止溢出\n",
    "        self.stack.append(res)\n",
    "\n",
    "    def sub(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        b = self.stack.pop()\n",
    "        res = (a - b) % (2**256) # 结果需要模2^256，防止溢出\n",
    "        self.stack.append(res)\n",
    "\n",
    "    def div(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        b = self.stack.pop()\n",
    "        if a == 0:\n",
    "            res = 0\n",
    "        else:\n",
    "            res =  (a // b) % (2**256)\n",
    "        self.stack.append(res)\n",
    "\n",
    "    def sdiv(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        b = self.stack.pop()\n",
    "        res = a//b % (2**256) if a!=0 else 0\n",
    "        self.stack.append(res)\n",
    "\n",
    "    def mod(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        b = self.stack.pop()\n",
    "        res = a % b if a != 0 else 0\n",
    "        self.stack.append(res)\n",
    "\n",
    "    def smod(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        b = self.stack.pop()\n",
    "        res = a % b if a != 0 else 0\n",
    "        self.stack.append(res)\n",
    "\n",
    "    def addmod(self):\n",
    "        if len(self.stack) < 3:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        b = self.stack.pop()\n",
    "        n = self.stack.pop()\n",
    "        res = (a + b) % n if n != 0 else 0\n",
    "        self.stack.append(res)\n",
    "\n",
    "    def mulmod(self):\n",
    "        if len(self.stack) < 3:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        b = self.stack.pop()\n",
    "        n = self.stack.pop()\n",
    "        res = (a * b) % n if n != 0 else 0\n",
    "        self.stack.append(res)\n",
    "\n",
    "    def exp(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        b = self.stack.pop()\n",
    "        res = pow(a, b) % (2**256)\n",
    "        self.stack.append(res)\n",
    "        \n",
    "    def signextend(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        b = self.stack.pop()\n",
    "        x = self.stack.pop()\n",
    "        if b < 32: # 如果b>=32，则不需要扩展\n",
    "            sign_bit = 1 << (8 * b - 1) # b 字节的最高位（符号位）对应的掩码值，将用来检测 x 的符号位是否为1\n",
    "            x = x & ((1 << (8 * b)) - 1)  # 对 x 进行掩码操作，保留 x 的前 b+1 字节的值，其余字节全部置0\n",
    "            if x & sign_bit:  # 检查 x 的符号位是否为1\n",
    "                x = x | ~((1 << (8 * b)) - 1)  # 将 x 的剩余部分全部置1\n",
    "        self.stack.append(x)\n",
    "        \n",
    "    def lt(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        b = self.stack.pop()\n",
    "        self.stack.append(int(b < a)) # 注意这里的比较顺序\n",
    "\n",
    "    def gt(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        b = self.stack.pop()\n",
    "        self.stack.append(int(b > a)) # 注意这里的比较顺序\n",
    "\n",
    "    def slt(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        b = self.stack.pop()\n",
    "        self.stack.append(int(b < a)) # 极简evm stack中的值已经是以有符号整数存储了，所以和lt一样实现\n",
    "\n",
    "    def sgt(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        b = self.stack.pop()\n",
    "        self.stack.append(int(b > a)) # 极简evm stack中的值已经是以有符号整数存储了，所以和gt一样实现\n",
    "\n",
    "    def eq(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        b = self.stack.pop()\n",
    "        self.stack.append(int(a == b))\n",
    "\n",
    "    def iszero(self):\n",
    "        if len(self.stack) < 1:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        self.stack.append(int(a == 0))\n",
    "\n",
    "    def and_op(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        b = self.stack.pop()\n",
    "        self.stack.append(a & b)\n",
    "\n",
    "    def or_op(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        b = self.stack.pop()\n",
    "        self.stack.append(a | b)\n",
    "\n",
    "    def xor_op(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        b = self.stack.pop()\n",
    "        self.stack.append(a ^ b)\n",
    "\n",
    "    def not_op(self):\n",
    "        if len(self.stack) < 1:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        self.stack.append(~a % (2**256)) # 按位非操作的结果需要模2^256，防止溢出\n",
    "\n",
    "    def byte_op(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        position = self.stack.pop()\n",
    "        value = self.stack.pop()\n",
    "        if position >= 32:\n",
    "            res = 0\n",
    "        else:\n",
    "            res = (value // pow(256, 31 - position)) & 0xFF\n",
    "        self.stack.append(res)\n",
    "\n",
    "    def shl(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        b = self.stack.pop()\n",
    "        self.stack.append((b << a) % (2**256)) # 左移位操作的结果需要模2^256\n",
    "    \n",
    "    def shr(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        b = self.stack.pop()\n",
    "        self.stack.append(b >> a) # 右移位操作\n",
    "        \n",
    "    def sar(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        a = self.stack.pop()\n",
    "        b = self.stack.pop()\n",
    "        self.stack.append(b >> a) # 右移位操作\n",
    "\n",
    "    def mstore(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        offset = self.stack.pop()\n",
    "        value = self.stack.pop()\n",
    "        while len(self.memory) < offset + 32:\n",
    "            self.memory.append(0) # 内存扩展\n",
    "        self.memory[offset:offset+32] = value.to_bytes(32, 'big')\n",
    "\n",
    "    def mstore8(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        offset = self.stack.pop()\n",
    "        value = self.stack.pop()\n",
    "        while len(self.memory) < offset + 32:\n",
    "            self.memory.append(0) # 内存扩展\n",
    "        self.memory[offset] = value & 0xFF # 取最低有效字节\n",
    "\n",
    "    def mload(self):\n",
    "        if len(self.stack) < 1:\n",
    "            raise Exception('Stack underflow')\n",
    "        offset = self.stack.pop()\n",
    "        while len(self.memory) < offset + 32:\n",
    "            self.memory.append(0) # 内存扩展\n",
    "        value = int.from_bytes(self.memory[offset:offset+32], 'big')\n",
    "        self.stack.append(value)\n",
    "\n",
    "    def sload(self):\n",
    "        if len(self.stack) < 1:\n",
    "            raise Exception('Stack underflow')\n",
    "        key = self.stack.pop()\n",
    "        value = self.storage.get(key, 0) # 如果键不存在，返回0\n",
    "        self.stack.append(value)\n",
    "\n",
    "    def sstore(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        key = self.stack.pop()\n",
    "        value = self.stack.pop()\n",
    "        self.storage[key] = value\n",
    "\n",
    "    def jump(self):\n",
    "        if len(self.stack) < 1:\n",
    "            raise Exception('Stack underflow')\n",
    "        destination = self.stack.pop()\n",
    "        if destination not in self.validJumpDest:\n",
    "            raise Exception('Invalid jump destination')\n",
    "        else:  self.pc = destination\n",
    "        \n",
    "\n",
    "    def jumpi(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        destination = self.stack.pop()\n",
    "        condition = self.stack.pop()\n",
    "        if condition != 0:\n",
    "            if destination not in self.validJumpDest:\n",
    "                raise Exception('Invalid jump destination')\n",
    "            else:  self.pc = destination\n",
    "\n",
    "    def pc(self):\n",
    "        self.stack.append(self.pc)\n",
    "\n",
    "    def msize(self):\n",
    "        self.stack.append(len(self.memory))\n",
    "\n",
    "    def jumpdest(self):\n",
    "        pass\n",
    "\n",
    "    def blockhash(self):\n",
    "        if len(self.stack) < 1:\n",
    "            raise Exception('Stack underflow')\n",
    "        number = self.stack.pop()\n",
    "        # 在真实场景中, 你会需要访问历史的区块hash\n",
    "        if number == self.current_block[\"number\"]:\n",
    "            self.stack.append(self.current_block[\"blockhash\"])\n",
    "        else:\n",
    "            self.stack.append(0)  # 如果不是当前块，返回0\n",
    "\n",
    "    def coinbase(self):\n",
    "        self.stack.append(self.current_block[\"coinbase\"])\n",
    "\n",
    "    def timestamp(self):\n",
    "        self.stack.append(self.current_block[\"timestamp\"])\n",
    "\n",
    "    def number(self):\n",
    "        self.stack.append(self.current_block[\"number\"])\n",
    "        \n",
    "    def prevrandao(self):\n",
    "        self.stack.append(self.current_block[\"prevrandao\"])\n",
    "        \n",
    "    def gaslimit(self):\n",
    "        self.stack.append(self.current_block[\"gaslimit\"])\n",
    "\n",
    "    def chainid(self):\n",
    "        self.stack.append(self.current_block[\"chainid\"])\n",
    "\n",
    "    def selfbalance(self):\n",
    "        self.stack.append(self.current_block[\"selfbalance\"])\n",
    "\n",
    "    def basefee(self):\n",
    "        self.stack.append(self.current_block[\"basefee\"])\n",
    "\n",
    "    def dup(self, position):\n",
    "        if len(self.stack) < position:\n",
    "            raise Exception('Stack underflow')\n",
    "        value = self.stack[-position]\n",
    "        self.stack.append(value)\n",
    "\n",
    "    def swap(self, position):\n",
    "        if len(self.stack) < position + 1:\n",
    "            raise Exception('Stack underflow')\n",
    "        idx1, idx2 = -1, -position - 1\n",
    "        self.stack[idx1], self.stack[idx2] = self.stack[idx2], self.stack[idx1]\n",
    "        \n",
    "    def sha3(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "\n",
    "        offset = self.pop()\n",
    "        size = self.pop()\n",
    "        data = self.memory[offset:offset+size]  # 从内存中获取数据\n",
    "        hash_value = int.from_bytes(sha3.keccak_256(data).digest(), 'big')  # 计算哈希值\n",
    "        self.stack.append(hash_value)  # 将哈希值压入堆栈\n",
    "\n",
    "    def balance(self):\n",
    "        if len(self.stack) < 1:\n",
    "            raise Exception('Stack underflow')\n",
    "        addr_int = self.stack.pop()\n",
    "        # 将stack中的int转换为bytes，然后再转换为十六进制字符串\n",
    "        addr_str = '0x' + addr_int.to_bytes(20, byteorder='big').hex()\n",
    "        self.stack.append(account_db.get(addr_str, {}).get('balance', 0))\n",
    "\n",
    "    def extcodesize(self):\n",
    "        if len(self.stack) < 1:\n",
    "            raise Exception('Stack underflow')\n",
    "        addr_int = self.stack.pop()\n",
    "        # 将stack中的int转换为bytes，然后再转换为十六进制字符串，用于在账户数据库中查询\n",
    "        addr_str = '0x' + addr_int.to_bytes(20, byteorder='big').hex()\n",
    "        self.stack.append(len(account_db.get(addr_str, {}).get('code', b'')))\n",
    "\n",
    "    def extcodecopy(self):\n",
    "        # 确保堆栈中有足够的数据\n",
    "        if len(self.stack) < 4:\n",
    "            raise Exception('Stack underflow')\n",
    "        addr_int = self.stack.pop()\n",
    "        mem_offset = self.stack.pop()\n",
    "        code_offset = self.stack.pop()\n",
    "        length = self.stack.pop()\n",
    "        # 将stack中的int转换为bytes，然后再转换为十六进制字符串，用于在账户数据库中查询\n",
    "        addr_str = '0x' + addr_int.to_bytes(20, byteorder='big').hex()\n",
    "        code = account_db.get(addr_str, {}).get('code', b'')[code_offset:code_offset+length]\n",
    "        while len(self.memory) < mem_offset + length:\n",
    "            self.memory.append(0)\n",
    "\n",
    "        self.memory[mem_offset:mem_offset+length] = code\n",
    "\n",
    "    def extcodehash(self):\n",
    "        if len(self.stack) < 1:\n",
    "            raise Exception('Stack underflow')\n",
    "        addr_int = self.stack.pop()\n",
    "        # 将stack中的int转换为bytes，然后再转换为十六进制字符串，用于在账户数据库中查询\n",
    "        addr_str = '0x' + addr_int.to_bytes(20, byteorder='big').hex()\n",
    "        code = account_db.get(addr_str, {}).get('code', b'')        \n",
    "        code_hash = int.from_bytes(sha3.keccak_256(code).digest(), 'big')  # 计算哈希值\n",
    "        self.stack.append(code_hash)\n",
    "\n",
    "    def address(self):\n",
    "        self.stack.append(self.txn.thisAddr)\n",
    "\n",
    "    def origin(self):\n",
    "        self.stack.append(self.txn.origin)\n",
    "\n",
    "    def caller(self):\n",
    "        self.stack.append(self.txn.caller)\n",
    "\n",
    "    def callvalue(self):\n",
    "        self.stack.append(self.txn.value)\n",
    "\n",
    "    def calldataload(self):\n",
    "        if len(self.stack) < 1:\n",
    "            raise Exception('Stack underflow')\n",
    "        offset = self.stack.pop()\n",
    "        # 从字符形式转换为bytes数组\n",
    "        calldata_bytes = bytes.fromhex(self.txn.data[2:])  # 假设由 '0x' 开头\n",
    "        data = bytearray(32)\n",
    "        # 复制calldata\n",
    "        for i in range(32):\n",
    "            if offset + i < len(calldata_bytes):\n",
    "                data[i] = calldata_bytes[offset + i]\n",
    "        self.stack.append(int.from_bytes(data, 'big'))\n",
    "\n",
    "    def calldatasize(self):\n",
    "        # Assuming calldata is a hex string with a '0x' prefix\n",
    "        size = (len(self.txn.data) - 2) // 2\n",
    "        self.stack.append(size)\n",
    "\n",
    "    def calldatacopy(self):\n",
    "        # 确保堆栈中有足够的数据\n",
    "        if len(self.stack) < 3:\n",
    "            raise Exception('Stack underflow')\n",
    "        mem_offset = self.stack.pop()\n",
    "        calldata_offset = self.stack.pop()\n",
    "        length = self.stack.pop()\n",
    "\n",
    "        # 拓展内存\n",
    "        if len(self.memory) < mem_offset + length:\n",
    "            self.memory.extend([0] * (mem_offset + length - len(self.memory)))\n",
    "\n",
    "        # 从字符形式转换为bytes数组.\n",
    "        calldata_bytes = bytes.fromhex(self.txn.data[2:])  # Assuming it's prefixed with '0x'\n",
    "\n",
    "        # 将calldata复制到内存\n",
    "        for i in range(length):\n",
    "            if calldata_offset + i < len(calldata_bytes):\n",
    "                self.memory[mem_offset + i] = calldata_bytes[calldata_offset + i]\n",
    "\n",
    "    def codesize(self):\n",
    "        addr = self.txn.thisAddr\n",
    "        self.stack.append(len(account_db.get(addr, {}).get('code', b'')))\n",
    "\n",
    "    def codecopy(self):\n",
    "        if len(self.stack) < 3:\n",
    "            raise Exception('Stack underflow')\n",
    "\n",
    "        mem_offset = self.stack.pop()\n",
    "        code_offset = self.stack.pop()\n",
    "        length = self.stack.pop()\n",
    "\n",
    "        # 获取当前地址的code\n",
    "        addr = self.txn.thisAddr\n",
    "        code = account_db.get(addr, {}).get('code', b'')\n",
    "\n",
    "        # 拓展内存\n",
    "        if len(self.memory) < mem_offset + length:\n",
    "            self.memory.extend([0] * (mem_offset + length - len(self.memory)))\n",
    "\n",
    "        # 将代码复制到内存\n",
    "        for i in range(length):\n",
    "            if code_offset + i < len(code):\n",
    "                self.memory[mem_offset + i] = code[code_offset + i]\n",
    "            \n",
    "    def gasprice(self):\n",
    "        self.stack.append(self.txn.gasPrice)\n",
    "\n",
    "    def log(self, num_topics):\n",
    "        if len(self.stack) < 2 + num_topics:\n",
    "            raise Exception('Stack underflow')\n",
    "\n",
    "        mem_offset = self.stack.pop()\n",
    "        length = self.stack.pop()\n",
    "        topics = [self.stack.pop() for _ in range(num_topics)]\n",
    "\n",
    "        data = self.memory[mem_offset:mem_offset + length]\n",
    "        log_entry = {\n",
    "            \"address\": self.txn.thisAddr,\n",
    "            \"data\": data.hex(),\n",
    "            \"topics\": [f\"0x{topic:064x}\" for topic in topics]\n",
    "        }\n",
    "        self.logs.append(log_entry)\n",
    "\n",
    "    def return_op(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "\n",
    "        mem_offset = self.stack.pop()\n",
    "        length = self.stack.pop()\n",
    "\n",
    "        # 拓展内存\n",
    "        if len(self.memory) < mem_offset + length:\n",
    "            self.memory.extend([0] * (mem_offset + length - len(self.memory)))\n",
    "\n",
    "        self.returnData = self.memory[mem_offset:mem_offset + length]      \n",
    "\n",
    "    def returndatasize(self):\n",
    "        self.stack.append(len(self.returnData))\n",
    "\n",
    "    def returndatacopy(self):\n",
    "        if len(self.stack) < 3:\n",
    "            raise Exception('Stack underflow')\n",
    "\n",
    "        mem_offset = self.stack.pop()\n",
    "        return_offset = self.stack.pop()\n",
    "        length = self.stack.pop()\n",
    "\n",
    "        if return_offset + length > len(self.returnData):\n",
    "            raise Exception(\"Invalid returndata size\")\n",
    "\n",
    "        # 扩展内存\n",
    "        if len(self.memory) < mem_offset + length:\n",
    "            self.memory.extend([0] * (mem_offset + length - len(self.memory)))\n",
    "\n",
    "        # 使用切片进行复制\n",
    "        self.memory[mem_offset:mem_offset + length] = self.returnData[return_offset:return_offset + length]\n",
    "\n",
    "    def create(self):\n",
    "        if len(self.stack) < 3:\n",
    "            raise Exception('Stack underflow')\n",
    "\n",
    "        # 弹出堆栈数据\n",
    "        value = self.stack.pop()\n",
    "        mem_offset = self.stack.pop()\n",
    "        length = self.stack.pop()\n",
    "\n",
    "        # 扩展内存\n",
    "        if len(self.memory) < mem_offset + length:\n",
    "            self.memory.extend([0] * (mem_offset + length - len(self.memory)))\n",
    "\n",
    "        # 获取初始代码\n",
    "        init_code = self.memory[mem_offset: mem_offset + length]\n",
    "\n",
    "        # 检查创建者的余额是否足够\n",
    "        creator_account = account_db[self.txn.thisAddr]\n",
    "        if creator_account['balance'] < value:\n",
    "            raise Exception('Insufficient balance to create contract!')\n",
    "\n",
    "        # 为创建者扣除指定的金额\n",
    "        creator_account['balance'] -= value\n",
    "\n",
    "        # 生成新的合约地址（参考geth中的方式，使用创建者的地址和nonce）\n",
    "        creator_nonce = creator_account['nonce']\n",
    "        new_contract_address_bytes = sha3.keccak_256(self.txn.thisAddr.encode() + str(creator_nonce).encode()).digest()\n",
    "        new_contract_address = '0x' + new_contract_address_bytes[-20:].hex()  # 取后20字节作为地址\n",
    "\n",
    "        # 更新创建者的nonce\n",
    "        creator_account['nonce'] += 1\n",
    "\n",
    "        # 使用txn构建上下文\n",
    "        ctx = Transaction(to=new_contract_address,\n",
    "                          data=init_code,\n",
    "                          value=value,\n",
    "                          caller=self.txn.thisAddr,\n",
    "                          origin=self.txn.origin,\n",
    "                          thisAddr=new_contract_address,\n",
    "                          gasPrice=self.txn.gasPrice,\n",
    "                          gasLimit=self.txn.gasLimit)\n",
    "\n",
    "        # 创建并运行新的EVM实例\n",
    "        evm_create = EVM(init_code, ctx)\n",
    "        evm_create.run()\n",
    "\n",
    "        # 如果EVM实例返回错误，压入0，表示创建失败\n",
    "        if evm_create.success == False:\n",
    "            self.stack.append(0)\n",
    "            return\n",
    "\n",
    "        # 存储合约的状态\n",
    "        account_db[new_contract_address] = {\n",
    "            'balance': value,\n",
    "            'nonce': 0,  # 新合约的nonce从0开始\n",
    "            'storage': evm_create.storage,\n",
    "            'code': evm_create.returnData\n",
    "        }\n",
    "        \n",
    "        # 压入新创建的合约地址\n",
    "        self.stack.append(int(new_contract_address, 16))\n",
    "\n",
    "    def call(self):\n",
    "        if len(self.stack) < 7:\n",
    "            raise Exception('Stack underflow')\n",
    "            \n",
    "        gas = self.stack.pop()\n",
    "        to_addr = self.stack.pop()\n",
    "        value = self.stack.pop()\n",
    "        mem_in_start = self.stack.pop()\n",
    "        mem_in_size = self.stack.pop()\n",
    "        mem_out_start = self.stack.pop()\n",
    "        mem_out_size = self.stack.pop()\n",
    "        \n",
    "        if self.is_static and value != 0:\n",
    "            self.success = False\n",
    "            raise Exception(\"State changing operation detected during STATICCALL!\")\n",
    "\n",
    "        # 拓展内存\n",
    "        if len(self.memory) < mem_in_start + mem_in_size:\n",
    "            self.memory.extend([0] * (mem_in_start + mem_in_size - len(self.memory)))\n",
    "\n",
    "        # 从内存中获取输入数据\n",
    "        data = self.memory[mem_in_start: mem_in_start + mem_in_size]\n",
    "    \n",
    "        account_source = account_db[self.txn.caller]\n",
    "        account_target = account_db[hex(to_addr)]\n",
    "        \n",
    "        # 检查caller的余额\n",
    "        if account_source['balance'] < value:\n",
    "            self.success = False\n",
    "            print(\"Insufficient balance for the transaction!\")\n",
    "            self.stack.append(0) \n",
    "            return\n",
    "        \n",
    "        # 更新余额\n",
    "        account_source['balance'] -= value\n",
    "        account_target['balance'] += value\n",
    "        \n",
    "        # 使用txn构建上下文\n",
    "        ctx = Transaction(to=hex(to_addr), \n",
    "                          data=data,\n",
    "                          value=value,\n",
    "                          caller=self.txn.thisAddr, \n",
    "                          origin=self.txn.origin, \n",
    "                          thisAddr=hex(to_addr), \n",
    "                          gasPrice=self.txn.gasPrice, \n",
    "                          gasLimit=self.txn.gasLimit, \n",
    "                         )\n",
    "        \n",
    "        # 创建evm子环境\n",
    "        evm_call = EVM(account_target['code'], ctx)\n",
    "        evm_call.run()\n",
    "        \n",
    "        # 拓展内存\n",
    "        if len(self.memory) < mem_out_start + mem_out_size:\n",
    "            self.memory.extend([0] * (mem_out_start + mem_out_size - len(self.memory)))\n",
    "        \n",
    "        self.memory[mem_out_start: mem_out_start + mem_out_size] = evm_call.returnData\n",
    "        \n",
    "        if evm_call.success:\n",
    "            self.stack.append(1)  \n",
    "        else:\n",
    "            self.stack.append(0)  \n",
    "\n",
    "\n",
    "    def delegatecall(self):\n",
    "        if len(self.stack) < 6:\n",
    "            raise Exception('Stack underflow')\n",
    "        \n",
    "        gas = self.stack.pop()\n",
    "        to_addr = self.stack.pop()\n",
    "        mem_in_start = self.stack.pop()\n",
    "        mem_in_size = self.stack.pop()\n",
    "        mem_out_start = self.stack.pop()\n",
    "        mem_out_size = self.stack.pop()\n",
    "        \n",
    "        # 拓展内存\n",
    "        if len(self.memory) < mem_in_start + mem_in_size:\n",
    "            self.memory.extend([0] * (mem_in_start + mem_in_size - len(self.memory)))\n",
    "\n",
    "        # 从内存中获取输入数据\n",
    "        data = self.memory[mem_in_start: mem_in_start + mem_in_size]\n",
    "        \n",
    "        account_target = account_db[hex(to_addr)]\n",
    "        \n",
    "        # 创建evm子环境，注意，这里的上下文是原始的调用合约，而不是目标合约\n",
    "        evm_delegate = EVM(account_target['code'], self.txn)\n",
    "        evm_delegate.storage = self.storage\n",
    "        # 运行代码\n",
    "        evm_delegate.run()\n",
    "        \n",
    "        # 拓展内存\n",
    "        if len(self.memory) < mem_out_start + mem_out_size:\n",
    "            self.memory.extend([0] * (mem_out_start + mem_out_size - len(self.memory)))\n",
    "        \n",
    "        self.memory[mem_out_start: mem_out_start + mem_out_size] = evm_delegate.returnData\n",
    "        \n",
    "        if evm_delegate.success:\n",
    "            self.stack.append(1)  \n",
    "        else:\n",
    "            self.stack.append(0)  \n",
    "            print(\"Delegatecall execution failed!\")\n",
    "\n",
    "\n",
    "    def callcode(self):\n",
    "        self.stack.append(0)  \n",
    "        print(\"Callcode not support!\")\n",
    "\n",
    "    def is_state_changing_opcode(self, opcode): # 检查static call不能包含的opcodes\n",
    "        state_changing_opcodes = [\n",
    "            0xF0, # CREATE\n",
    "            0xF5, # CREATE2\n",
    "            0xFF, # SELFDESTRUCT\n",
    "            0xA0, # LOG0\n",
    "            0xA1, # LOG1\n",
    "            0xA2, # LOG2\n",
    "            0xA3, # LOG3\n",
    "            0xA4, # LOG4\n",
    "            0x55  # SSTORE\n",
    "        ]\n",
    "        return opcode in state_changing_opcodes\n",
    "\n",
    "    def staticcall(self):\n",
    "        if len(self.stack) < 6:\n",
    "            raise Exception('Stack underflow')\n",
    "            \n",
    "        gas = self.stack.pop()\n",
    "        to_addr = self.stack.pop()\n",
    "        mem_in_start = self.stack.pop()\n",
    "        mem_in_size = self.stack.pop()\n",
    "        mem_out_start = self.stack.pop()\n",
    "        mem_out_size = self.stack.pop()\n",
    "        \n",
    "        # 拓展内存\n",
    "        if len(self.memory) < mem_in_start + mem_in_size:\n",
    "            self.memory.extend([0] * (mem_in_start + mem_in_size - len(self.memory)))\n",
    "\n",
    "        # 从内存中获取输入数据\n",
    "        data = self.memory[mem_in_start: mem_in_start + mem_in_size]\n",
    "    \n",
    "        account_target = account_db[hex(to_addr)]\n",
    "        \n",
    "        # 使用txn构建上下文\n",
    "        ctx = Transaction(to=hex(to_addr), \n",
    "                          data=data,\n",
    "                          value=0,\n",
    "                          caller=self.txn.thisAddr, \n",
    "                          origin=self.txn.origin, \n",
    "                          thisAddr=hex(to_addr), \n",
    "                          gasPrice=self.txn.gasPrice, \n",
    "                          gasLimit=self.txn.gasLimit, \n",
    "                         )\n",
    "        \n",
    "        # 创建evm子环境\n",
    "        evm_staticcall = EVM(account_target['code'], ctx, is_static=True)\n",
    "        # 运行代码\n",
    "        evm_staticcall.run()\n",
    "        \n",
    "        # 拓展内存\n",
    "        if len(self.memory) < mem_out_start + mem_out_size:\n",
    "            self.memory.extend([0] * (mem_out_start + mem_out_size - len(self.memory)))\n",
    "        \n",
    "        self.memory[mem_out_start: mem_out_start + mem_out_size] = evm_staticcall.returnData\n",
    "        \n",
    "        if evm_staticcall.success:\n",
    "            self.stack.append(1)  \n",
    "        else:\n",
    "            self.stack.append(0)  \n",
    "\n",
    "    def revert(self):\n",
    "        if len(self.stack) < 2:\n",
    "            raise Exception('Stack underflow')\n",
    "        mem_offset = self.stack.pop()\n",
    "        length = self.stack.pop()\n",
    "\n",
    "        # 拓展内存\n",
    "        if len(self.memory) < mem_offset + length:\n",
    "            self.memory.extend([0] * (mem_offset + length - len(self.memory)))\n",
    "\n",
    "        self.returnData = self.memory[mem_offset:mem_offset+length]\n",
    "        self.success = False\n",
    " \n",
    "    def invalid(self):\n",
    "        self.success = False\n",
    "\n",
    "    def run(self):\n",
    "        while self.pc < len(self.code) and self.success:\n",
    "            op = self.next_instruction()\n",
    "\n",
    "            if self.is_static and self.is_state_changing_opcode(op):\n",
    "                self.success = False\n",
    "                raise Exception(\"State changing operation detected during STATICCALL!\")\n",
    "\n",
    "            if PUSH1 <= op <= PUSH32: # 如果为PUSH1-PUSH32\n",
    "                size = op - PUSH1 + 1\n",
    "                self.push(size)\n",
    "            elif op == PUSH0: # 如果为PUSH0\n",
    "                self.stack.append(0)\n",
    "            elif DUP1 <= op <= DUP16: # 如果是DUP1-DUP16\n",
    "                position = op - DUP1 + 1\n",
    "                self.dup(position)\n",
    "            elif SWAP1 <= op <= SWAP16: # 如果是SWAP1-SWAP16\n",
    "                position = op - SWAP1 + 1\n",
    "                self.swap(position)\n",
    "            elif op == POP: # 如果为POP\n",
    "                self.pop()\n",
    "            elif op == ADD: # 处理ADD指令\n",
    "                self.add()\n",
    "            elif op == MUL: # 处理MUL指令\n",
    "                self.mul()\n",
    "            elif op == SUB: # 处理SUB指令\n",
    "                self.sub()\n",
    "            elif op == DIV: # 处理DIV指令\n",
    "                self.div()\n",
    "            elif op == SDIV:\n",
    "                self.sdiv()\n",
    "            elif op == MOD:\n",
    "                self.mod()\n",
    "            elif op == SMOD:\n",
    "                self.smod()\n",
    "            elif op == ADDMOD:\n",
    "                self.addmod()\n",
    "            elif op == MULMOD:\n",
    "                self.mulmod()\n",
    "            elif op == EXP:\n",
    "                self.exp()\n",
    "            elif op == SIGNEXTEND:\n",
    "                self.signextend()\n",
    "            elif op == LT:\n",
    "                self.lt()\n",
    "            elif op == GT:\n",
    "                self.gt()\n",
    "            elif op == SLT:\n",
    "                self.slt()\n",
    "            elif op == SGT:\n",
    "                self.sgt()\n",
    "            elif op == EQ:\n",
    "                self.eq()\n",
    "            elif op == ISZERO:\n",
    "                self.iszero()\n",
    "            elif op == AND:  # 处理AND指令\n",
    "                self.and_op()\n",
    "            elif op == OR:  # 处理AND指令\n",
    "                self.or_op()\n",
    "            elif op == XOR:  # 处理AND指令\n",
    "                self.xor_op()\n",
    "            elif op == NOT:  # 处理AND指令\n",
    "                self.not_op()\n",
    "            elif op == BYTE:  # 处理AND指令\n",
    "                self.byte_op()\n",
    "            elif op == SHL:  # 处理AND指令\n",
    "                self.shl()\n",
    "            elif op == SHR:  # 处理AND指令\n",
    "                self.shr()\n",
    "            elif op == SAR:  # 处理AND指令\n",
    "                self.sar()\n",
    "            elif op == MLOAD: # 处理MLOAD指令\n",
    "                self.mload()\n",
    "            elif op == MSTORE: # 处理MSTORE指令\n",
    "                self.mstore()\n",
    "            elif op == MSTORE8: # 处理MSTORE8指令\n",
    "                self.mstore8()\n",
    "            elif op == SLOAD: \n",
    "                self.sload()\n",
    "            elif op == SSTORE: # 处理SSTORE指令\n",
    "                self.sstore()\n",
    "            elif op == MSIZE: # 处理MSIZE指令\n",
    "                self.msize()\n",
    "            elif op == JUMP: \n",
    "                self.jump()\n",
    "            elif op == JUMPDEST: \n",
    "                self.jumpdest()\n",
    "            elif op == JUMPI: \n",
    "                self.jumpi()\n",
    "            elif op == STOP: # 处理STOP指令\n",
    "                print('Program has been stopped')\n",
    "                break\n",
    "            elif op == PC:\n",
    "                self.pc()\n",
    "            elif op == BLOCKHASH:\n",
    "                self.blockhash()\n",
    "            elif op == COINBASE:\n",
    "                self.coinbase()\n",
    "            elif op == TIMESTAMP:\n",
    "                self.timestamp()\n",
    "            elif op == NUMBER:\n",
    "                self.number()\n",
    "            elif op == PREVRANDAO:\n",
    "                self.prevrandao()\n",
    "            elif op == GASLIMIT:\n",
    "                self.gaslimit()\n",
    "            elif op == CHAINID:\n",
    "                self.chainid()\n",
    "            elif op == SELFBALANCE:\n",
    "                self.selfbalance()\n",
    "            elif op == BASEFEE:\n",
    "                self.basefee()        \n",
    "            elif op == SHA3: # 如果为SHA3\n",
    "                self.sha3()\n",
    "            elif op == BALANCE: \n",
    "                self.balance()\n",
    "            elif op == EXTCODESIZE: \n",
    "                self.extcodesize()\n",
    "            elif op == EXTCODECOPY: \n",
    "                self.extcodecopy()\n",
    "            elif op == EXTCODEHASH: \n",
    "                self.extcodehash()\n",
    "            elif op == ADDRESS: \n",
    "                self.address()\n",
    "            elif op == ORIGIN: \n",
    "                self.origin()\n",
    "            elif op == CALLER: \n",
    "                self.caller()\n",
    "            elif op == CALLVALUE: \n",
    "                self.callvalue()\n",
    "            elif op == CALLDATALOAD: \n",
    "                self.calldataload()\n",
    "            elif op == CALLDATASIZE: \n",
    "                self.calldatasize()\n",
    "            elif op == CALLDATACOPY: \n",
    "                self.calldatacopy()\n",
    "            elif op == CODESIZE: \n",
    "                self.codesize()\n",
    "            elif op == CODECOPY: \n",
    "                self.codecopy()\n",
    "            elif op == GASPRICE: \n",
    "                self.gasprice()\n",
    "            elif op == EXTCODEHASH: \n",
    "                self.extcodehash()\n",
    "            elif op == LOG0:\n",
    "                self.log(0)\n",
    "            elif op == LOG1:\n",
    "                self.log(1)\n",
    "            elif op == LOG2:\n",
    "                self.log(2)\n",
    "            elif op == LOG3:\n",
    "                self.log(3)\n",
    "            elif op == LOG4:\n",
    "                self.log(4)\n",
    "            elif op == RETURN:\n",
    "                self.return_op()\n",
    "            elif op == RETURNDATASIZE:\n",
    "                self.returndatasize()\n",
    "            elif op == RETURNDATACOPY:\n",
    "                self.returndatacopy()\n",
    "            elif op == RETURNDATACOPY:\n",
    "                self.returndatacopy()\n",
    "            elif op == REVERT:\n",
    "                self.revert() \n",
    "            elif op == CREATE:\n",
    "                self.create()                       \n",
    "            elif op == CALL:\n",
    "                self.call()                       \n",
    "            elif op == CALLCODE:\n",
    "                self.callcode()            \n",
    "            elif op == DELEGATECALL:\n",
    "                self.delegatecall()            \n",
    "            elif op == STATICCALL:\n",
    "                self.staticcall()     \n",
    "            else:\n",
    "                self.invalid()\n",
    "                raise Exception('Invalid opcode')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "id": "471cbe31",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define Txn\n",
    "addr = '0x9bbfed6889322e016e0a02ee459d306fc19545d8'\n",
    "txn = Transaction(to=None, value=10, data='0x9059cbb20000000000000000000000009bbfed6889322e016e0a02ee459d306fc19545d80000000000000000000000000000000000000000000000000000000000000001', \n",
    "                  caller=addr, origin=addr, thisAddr=addr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "id": "95d496ec",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0x260144093a2920f68e1ae2e26b3bd15ddd610dfe\n",
      "{'balance': 9, 'nonce': 0, 'storage': {}, 'code': bytearray(b'')}\n"
     ]
    }
   ],
   "source": [
    "# CREATE (empty code, 9 wei balance)\n",
    "code = b\"\\x5f\\x5f\\x60\\x09\\xf0\"\n",
    "evm = EVM(code, txn)\n",
    "evm.run()\n",
    "print(hex(evm.stack[-1]))\n",
    "# output: 0x260144093a2920f68e1ae2e26b3bd15ddd610dfe\n",
    "print(account_db[hex(evm.stack[-1])])\n",
    "# output: {'balance': 9, 'nonce': 0, 'storage': {}, 'code': bytearray(b'')}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "id": "07672af5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0x6dddd3288a19f0bf4eee7bfb9e168ad29e1395d0\n",
      "{'balance': 0, 'nonce': 0, 'storage': {}, 'code': bytearray(b'\\xff\\xff\\xff\\xff')}\n"
     ]
    }
   ],
   "source": [
    "# CREATE (with 4x FF)\n",
    "code = b\"\\x6c\\x63\\xff\\xff\\xff\\xff\\x60\\x00\\x52\\x60\\x04\\x60\\x1c\\xf3\\x60\\x00\\x52\\x60\\x0d\\x60\\x13\\x60\\x00\\xf0\"\n",
    "# PUSH13 0x63ffffffff6000526004601cf3 PUSH1 0x00 MSTORE PUSH1 0x0d PUSH1 0x13 PUSH1 0x00 CREATE\n",
    "evm = EVM(code, txn)\n",
    "evm.run()\n",
    "print(hex(evm.stack[-1]))\n",
    "# output: 0x6dddd3288a19f0bf4eee7bfb9e168ad29e1395d0\n",
    "print(account_db[hex(evm.stack[-1])])\n",
    "# {'balance': 0, 'nonce': 0, 'storage': {}, 'code': bytearray(b'\\xff\\xff\\xff\\xff')}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa711be8",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}