11_StackOp2/StackOp2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "2b96b12e",
   "metadata": {},
   "outputs": [],
   "source": [
    "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",
    "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",
    "\n",
    "class StopException(Exception):\n",
    "    pass\n",
    "\n",
    "class EVM:\n",
    "    def __init__(self, code):\n",
    "        self.code = code # 初始化字节码，bytes对象\n",
    "        self.pc = 0  # 初始化程序计数器为0\n",
    "        self.stack = [] # 堆栈初始为空\n",
    "        self.memory = bytearray()  # 内存初始化为空\n",
    "        self.storage = {}  # 存储初始化为空字典\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 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 self.code[destination] != JUMPDEST:\n",
    "            raise Exception('Invalid jump destination')\n",
    "        self.pc = destination\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 self.code[destination] != JUMPDEST:\n",
    "                raise Exception('Invalid jump destination')\n",
    "            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 run(self):\n",
    "        while self.pc < len(self.code):\n",
    "            op = self.next_instruction()\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",
    "            else:\n",
    "                raise Exception('Invalid opcode')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "4b4537e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 2]\n"
     ]
    }
   ],
   "source": [
    "# DUP1\n",
    "code = b\"\\x60\\x01\\x60\\x02\\x80\"\n",
    "evm = EVM(code)\n",
    "evm.run()\n",
    "print(evm.stack)  \n",
    "# output: [1, 2, 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "cf5d9e9e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 1]\n"
     ]
    }
   ],
   "source": [
    "# SWAP1\n",
    "code = b\"\\x60\\x01\\x60\\x02\\x90\"\n",
    "evm = EVM(code)\n",
    "evm.run()\n",
    "print(evm.stack)  \n",
    "# output: [2, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "471cbe31",
   "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
}