evmole 0.3.2__tar.gz → 0.3.4__tar.gz

{evmole-0.3.2 → evmole-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: evmole
-Version: 0.3.2
+Version: 0.3.4
 Summary: Extracts function selectors and arguments from EVM bytecode
 Home-page: https://github.com/cdump/evmole
 License: MIT
@@ -12,7 +12,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: benchmark
-Requires-Dist: aiohttp (>=3.9.0,<4.0.0) ; extra == "benchmark"
+Requires-Dist: aiohttp (>=3.9,<4.0) ; extra == "benchmark"
 Project-URL: Repository, https://github.com/cdump/evmole
 Description-Content-Type: text/markdown
 
@@ -77,6 +77,25 @@ print( function_arguments(code, '2125b65b') )
 # Output(str): 'uint32,address,uint224'
 ```
 
+### Foundry
+<a href="https://getfoundry.sh/">Foundy's cast</a> uses the Rust implementation of EVMole
+```sh
+
+$ cast selectors $(cast code 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2)
+0x06fdde03	
+0x095ea7b3	address,uint256
+0x18160ddd	
+0x23b872dd	address,address,uint256
+...
+
+$ cast selectors --resolve $(cast code 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2)
+0x06fdde03	                       	name()
+0x095ea7b3	address,uint256        	approve(address,uint256)
+0x18160ddd	                       	totalSupply()
+0x23b872dd	address,address,uint256	transferFrom(address,address,uint256)
+...
+```
+
 See [examples](./examples) for more
 
 ## Benchmark
@@ -129,11 +148,11 @@ See [examples](./examples) for more
  </tr>
  <tr>
   <td><i>Time</i></td>
-  <td>0.6s · 1.4s · 1.5s</td>
-  <td>2.6s</td>
+  <td>0.7s · 1.5s · 2.0s</td>
+  <td>3.0s</td>
   <td>0.7s</td>
-  <td>598.6s</td>
-  <td>1.4s</td>
+  <td>727.2s</td>
+  <td>1.9s</td>
  </tr>
  <tr><td colspan="7"></td></tr>
  <tr>
@@ -158,6 +177,7 @@ See [examples](./examples) for more
   <td>3 🥇</td>
   <td>51</td>
   <td>10798</td>
+  <!-- -->
   <td>14652</td>
  </tr>
  <tr>
@@ -165,16 +185,18 @@ See [examples](./examples) for more
   <td>10 🥇</td>
   <td>32</td>
   <td>3538</td>
+  <!-- -->
   <td>96</td>
  </tr>
  <tr>
   <td><i>Time</i></td>
-  <td>7.3s · 17.4s · 25.7s</td>
-  <td>46.8s</td>
-  <td>10.2s</td>
-  <td>33.9s</td>
+  <td>9.8s · 19.6s · 36.4s</td>
+  <td>52.3s</td>
+  <td>11.5s</td>
+  <!-- -->
+  <td>46.3s</td>
  </tr>
- <tr><td colspan="7"></td></tr>
+ <tr><td colspan="8"></td></tr>
  <tr>
   <td rowspan="5"><b>vyper</b><br><sub>780<br>contracts<br><br>21244<br>functions</sub></td>
   <td><i>FP <sub>contracts</sub></i></td>
@@ -210,11 +232,11 @@ See [examples](./examples) for more
  </tr>
  <tr>
   <td><i>Time</i></td>
-  <td>0.5s · 0.8s · 1.0s</td>
-  <td>1.9s</td>
-  <td>0.5s</td>
-  <td>15.5s</td>
-  <td>1.0s</td>
+  <td>0.6s · 0.9s · 1.4s</td>
+  <td>2.3s</td>
+  <td>0.6s</td>
+  <td>17.0s</td>
+  <td>1.2s</td>
  </tr>
 </table>
 
@@ -232,49 +254,49 @@ See [examples](./examples) for more
  <tr>
   <td rowspan="2"><b>largest1k</b><br><sub>1000<br>contracts<br><br>24427<br>functions</sub></td>
   <td><i>Errors</i></td>
-  <td>15.0%, 3664 🥇</td>
-  <td>42.6%, 10414</td>
+  <td>15.0%, 3652 🥇</td>
+  <td>42.7%, 10438</td>
   <td>58.3%, 14242</td>
  </tr>
  <tr>
   <td><i>Time</i></td>
-  <td>0.8s · 6.0s · 9.6s</td>
-  <td>602.9s</td>
-  <td>0.6s</td>
+  <td>1.1s · 7.5s · 15.7s</td>
+  <td>731.4s</td>
+  <td>0.8s</td>
  </tr>
  <tr><td colspan="5"></td></tr>
  <tr>
   <td rowspan="2"><b>random50k</b><br><sub>50000<br>contracts<br><br>1171102<br>functions</sub></td>
   <td><i>Errors</i></td>
-  <td>5.4%, 63124 🥇</td>
+  <td>5.1%, 59484 🥇</td>
   <td rowspan="2">waiting fixes</td>
   <td>54.9%, 643213</td>
  </tr>
  <tr>
   <td><i>Time</i></td>
-  <td>17.2s · 179.2s · 300.9s</td>
+  <td>22.6s · 247.0s · 584.7s</td>
   <!-- -->
-  <td>8.1s</td>
+  <td>9.5s</td>
  </tr>
  <tr><td colspan="5"></td></tr>
  <tr>
   <td rowspan="2"><b>vyper</b><br><sub>780<br>contracts<br><br>21244<br>functions</sub></td>
   <td><i>Errors</i></td>
-  <td>52.4%, 11123 🥇</td>
+  <td>50.9%, 10805 🥇</td>
   <td>100.0%, 21244</td>
   <td>56.8%, 12077</td>
  </tr>
  <tr>
   <td><i>Time</i></td>
-  <td>0.8s · 7.0s · 12.9s</td>
-  <td>15.6s</td>
-  <td>0.6s</td>
+  <td>0.9s · 7.3s · 13.9s</td>
+  <td>16.8s</td>
+  <td>0.7s</td>
  </tr>
 </table>
 
 See [benchmark/README.md](./benchmark/) for the methodology and commands to reproduce these results
 
-<i>versions: evmole v0.3.1; whatsabi v0.10.0; evm-hound-rs v0.1.4; heimdall-rs v0.7.3</i>
+<i>versions: evmole v0.3.3; whatsabi v0.11.0; evm-hound-rs v0.1.4; heimdall-rs v0.7.3</i>
 
 ## How it works
 

{evmole-0.3.2 → evmole-0.3.4}/README.md

@@ -59,6 +59,25 @@ print( function_arguments(code, '2125b65b') )
 # Output(str): 'uint32,address,uint224'
 ```
 
+### Foundry
+<a href="https://getfoundry.sh/">Foundy's cast</a> uses the Rust implementation of EVMole
+```sh
+
+$ cast selectors $(cast code 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2)
+0x06fdde03	
+0x095ea7b3	address,uint256
+0x18160ddd	
+0x23b872dd	address,address,uint256
+...
+
+$ cast selectors --resolve $(cast code 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2)
+0x06fdde03	                       	name()
+0x095ea7b3	address,uint256        	approve(address,uint256)
+0x18160ddd	                       	totalSupply()
+0x23b872dd	address,address,uint256	transferFrom(address,address,uint256)
+...
+```
+
 See [examples](./examples) for more
 
 ## Benchmark
@@ -111,11 +130,11 @@ See [examples](./examples) for more
  </tr>
  <tr>
   <td><i>Time</i></td>
-  <td>0.6s · 1.4s · 1.5s</td>
-  <td>2.6s</td>
+  <td>0.7s · 1.5s · 2.0s</td>
+  <td>3.0s</td>
   <td>0.7s</td>
-  <td>598.6s</td>
-  <td>1.4s</td>
+  <td>727.2s</td>
+  <td>1.9s</td>
  </tr>
  <tr><td colspan="7"></td></tr>
  <tr>
@@ -140,6 +159,7 @@ See [examples](./examples) for more
   <td>3 🥇</td>
   <td>51</td>
   <td>10798</td>
+  <!-- -->
   <td>14652</td>
  </tr>
  <tr>
@@ -147,16 +167,18 @@ See [examples](./examples) for more
   <td>10 🥇</td>
   <td>32</td>
   <td>3538</td>
+  <!-- -->
   <td>96</td>
  </tr>
  <tr>
   <td><i>Time</i></td>
-  <td>7.3s · 17.4s · 25.7s</td>
-  <td>46.8s</td>
-  <td>10.2s</td>
-  <td>33.9s</td>
+  <td>9.8s · 19.6s · 36.4s</td>
+  <td>52.3s</td>
+  <td>11.5s</td>
+  <!-- -->
+  <td>46.3s</td>
  </tr>
- <tr><td colspan="7"></td></tr>
+ <tr><td colspan="8"></td></tr>
  <tr>
   <td rowspan="5"><b>vyper</b><br><sub>780<br>contracts<br><br>21244<br>functions</sub></td>
   <td><i>FP <sub>contracts</sub></i></td>
@@ -192,11 +214,11 @@ See [examples](./examples) for more
  </tr>
  <tr>
   <td><i>Time</i></td>
-  <td>0.5s · 0.8s · 1.0s</td>
-  <td>1.9s</td>
-  <td>0.5s</td>
-  <td>15.5s</td>
-  <td>1.0s</td>
+  <td>0.6s · 0.9s · 1.4s</td>
+  <td>2.3s</td>
+  <td>0.6s</td>
+  <td>17.0s</td>
+  <td>1.2s</td>
  </tr>
 </table>
 
@@ -214,49 +236,49 @@ See [examples](./examples) for more
  <tr>
   <td rowspan="2"><b>largest1k</b><br><sub>1000<br>contracts<br><br>24427<br>functions</sub></td>
   <td><i>Errors</i></td>
-  <td>15.0%, 3664 🥇</td>
-  <td>42.6%, 10414</td>
+  <td>15.0%, 3652 🥇</td>
+  <td>42.7%, 10438</td>
   <td>58.3%, 14242</td>
  </tr>
  <tr>
   <td><i>Time</i></td>
-  <td>0.8s · 6.0s · 9.6s</td>
-  <td>602.9s</td>
-  <td>0.6s</td>
+  <td>1.1s · 7.5s · 15.7s</td>
+  <td>731.4s</td>
+  <td>0.8s</td>
  </tr>
  <tr><td colspan="5"></td></tr>
  <tr>
   <td rowspan="2"><b>random50k</b><br><sub>50000<br>contracts<br><br>1171102<br>functions</sub></td>
   <td><i>Errors</i></td>
-  <td>5.4%, 63124 🥇</td>
+  <td>5.1%, 59484 🥇</td>
   <td rowspan="2">waiting fixes</td>
   <td>54.9%, 643213</td>
  </tr>
  <tr>
   <td><i>Time</i></td>
-  <td>17.2s · 179.2s · 300.9s</td>
+  <td>22.6s · 247.0s · 584.7s</td>
   <!-- -->
-  <td>8.1s</td>
+  <td>9.5s</td>
  </tr>
  <tr><td colspan="5"></td></tr>
  <tr>
   <td rowspan="2"><b>vyper</b><br><sub>780<br>contracts<br><br>21244<br>functions</sub></td>
   <td><i>Errors</i></td>
-  <td>52.4%, 11123 🥇</td>
+  <td>50.9%, 10805 🥇</td>
   <td>100.0%, 21244</td>
   <td>56.8%, 12077</td>
  </tr>
  <tr>
   <td><i>Time</i></td>
-  <td>0.8s · 7.0s · 12.9s</td>
-  <td>15.6s</td>
-  <td>0.6s</td>
+  <td>0.9s · 7.3s · 13.9s</td>
+  <td>16.8s</td>
+  <td>0.7s</td>
  </tr>
 </table>
 
 See [benchmark/README.md](./benchmark/) for the methodology and commands to reproduce these results
 
-<i>versions: evmole v0.3.1; whatsabi v0.10.0; evm-hound-rs v0.1.4; heimdall-rs v0.7.3</i>
+<i>versions: evmole v0.3.3; whatsabi v0.11.0; evm-hound-rs v0.1.4; heimdall-rs v0.7.3</i>
 
 ## How it works
 

{evmole-0.3.2 → evmole-0.3.4}/evmole/arguments.py

@@ -29,12 +29,33 @@ class IsZeroResult:
     dynamic: bool = False
 
 
+class ArgsResult:
+    args: dict[int, str]
+
+    def __init__(self):
+        self.args = {}
+
+    def set(self, offset: int, atype: str):
+        self.args[offset] = atype
+
+    def set_if(self, offset: int, if_val: str, atype: str):
+        v = self.args.get(offset)
+        if v is not None:
+            if v == if_val:
+                self.args[offset] = atype
+        elif atype == '':
+            self.args[offset] = atype
+
+    def join_to_string(self) -> str:
+        return ','.join(v[1] if v[1] != '' else 'uint256' for v in sorted(self.args.items()))
+
+
 def function_arguments(code: bytes | str, selector: bytes | str, gas_limit: int = int(1e4)) -> str:
     bytes_selector = to_bytes(selector)
     vm = Vm(code=to_bytes(code), calldata=Element(data=bytes_selector, label='calldata'))
     gas_used = 0
     inside_function = False
-    args: dict[int, str] = {}
+    args = ArgsResult()
     while not vm.stopped:
         try:
             ret = vm.step()
@@ -44,7 +65,7 @@ def function_arguments(code: bytes | str, selector: bytes | str, gas_limit: int
                 break
 
             if inside_function:
-                # print(vm, '\n')
+                # print(vm, '\n', sep='')
                 # print(ret)
                 pass
         except (StackIndexError, UnsupportedOpError) as ex:
@@ -62,21 +83,26 @@ def function_arguments(code: bytes | str, selector: bytes | str, gas_limit: int
         match ret:
             case (Op.CALLDATASIZE, _):
                 vm.stack.pop()
-                vm.stack.push_uint(8192)
+                vm.stack.push_uint(131072)
 
             case (Op.CALLDATALOAD, _, Element(Arg() as arg)):
-                args[arg.offset] = 'bytes'
+                args.set(arg.offset, 'bytes')
                 vm.stack.pop()
                 vm.stack.push(Element(data=(1).to_bytes(32, 'big'), label=ArgDynamicLength(offset=arg.offset)))
 
             case (Op.CALLDATALOAD, _, Element(ArgDynamic() as arg)):
-                vm.stack.peek().label = Arg(offset=arg.offset, dynamic=True)
+                vm.stack.pop()
+                vm.stack.push(Element(data=(0).to_bytes(32, 'big'), label=Arg(offset=arg.offset, dynamic=True)))
 
             case (Op.CALLDATALOAD, _, Element() as offset):
                 off = int.from_bytes(offset.data, 'big')
-                if off >= 4 and off < 2**32:
-                    vm.stack.peek().label = Arg(offset=off)
-                    args[off] = ''
+                if off >= 4 and off < (131072 - 1024):
+                    vm.stack.pop()
+                    vm.stack.push(Element(data=(0).to_bytes(32, 'big'), label=Arg(offset=off)))
+                    args.set_if(off, '', '')
+
+            case (Op.MUL, _, Element(Arg() as arg), Element()) | (Op.MUL, _, Element(), Element(Arg() as arg)):
+                args.set_if(arg.offset, 'bool', '')
 
             case (Op.ADD, _, Element(Arg() as arg), Element() as ot) | (Op.ADD, _, Element() as ot, Element(Arg() as arg)):
                 vm.stack.peek().label = (
@@ -88,14 +114,14 @@ def function_arguments(code: bytes | str, selector: bytes | str, gas_limit: int
 
             case (Op.SHL, _, Element() as ot, Element(ArgDynamicLength() as arg)):
                 if int.from_bytes(ot.data, 'big') == 5:
-                    args[arg.offset] = 'uint256[]'
+                    args.set(arg.offset, 'uint256[]')
 
             case (
                 (Op.MUL, _, Element(ArgDynamicLength() as arg), Element() as ot)
                 | (Op.MUL, _, Element() as ot, Element(ArgDynamicLength() as arg))
             ):
                 if int.from_bytes(ot.data, 'big') == 32:
-                    args[arg.offset] = 'uint256[]'
+                    args.set(arg.offset, 'uint256[]')
 
             case (Op.AND, _, Element(Arg() as arg), Element() as ot) | (Op.AND, _, Element() as ot, Element(Arg() as arg)):
                 v = int.from_bytes(ot.data, 'big')
@@ -106,7 +132,7 @@ def function_arguments(code: bytes | str, selector: bytes | str, gas_limit: int
                     bl = v.bit_length()
                     if bl % 8 == 0:
                         t = 'address' if bl == 160 else f'uint{bl}'
-                        args[arg.offset] = f'{t}[]' if arg.dynamic else t
+                        args.set(arg.offset, f'{t}[]' if arg.dynamic else t)
                 else:
                     # 0xffff0000
                     v = int.from_bytes(ot.data, 'little')
@@ -114,24 +140,33 @@ def function_arguments(code: bytes | str, selector: bytes | str, gas_limit: int
                         bl = v.bit_length()
                         if bl % 8 == 0:
                             t = f'bytes{bl // 8}'
-                            args[arg.offset] = f'{t}[]' if arg.dynamic else t
+                            args.set(arg.offset, f'{t}[]' if arg.dynamic else t)
 
             case (Op.ISZERO, _, Element(Arg() as arg)):
                 vm.stack.peek().label = IsZeroResult(offset=arg.offset, dynamic=arg.dynamic)
 
             case (Op.ISZERO, _, Element(IsZeroResult() as arg)):
-                args[arg.offset] = 'bool[]' if arg.dynamic else 'bool'
+                # Detect check for 0 in DIV, it's not bool in that case: ISZERO, ISZERO, PUSH off, JUMPI, JUMPDEST, DIV
+                is_bool = True
+                op = vm.code[vm.pc]
+                if op >= Op.PUSH1 and op <= Op.PUSH4:
+                    n = op - Op.PUSH0
+                    if vm.code[vm.pc + n + 1] == Op.JUMPI:
+                        jumpdest = int.from_bytes(vm.code[(vm.pc + 1) : (vm.pc + 1 + n)], signed=False)
+                        if jumpdest + 1 < len(vm.code) and vm.code[jumpdest] == Op.JUMPDEST and vm.code[jumpdest + 1] == Op.DIV:
+                            is_bool = False
+                if is_bool:
+                    args.set(arg.offset, 'bool[]' if arg.dynamic else 'bool')
 
             case (Op.SIGNEXTEND, _, s0, Element(Arg() as arg)):
                 if s0 < 32:
                     t = f'int{(s0+1)*8}'
-                    args[arg.offset] = f'{t}[]' if arg.dynamic else t
+                    args.set(arg.offset, f'{t}[]' if arg.dynamic else t)
 
             case (Op.BYTE, _, _, Element(Arg() as arg)):
-                if args[arg.offset] == '':
-                    args[arg.offset] = 'bytes32'
+                args.set_if(arg.offset, '', 'bytes32')
 
             # case (Op.LT, _, CallDataArgument() as arg, _):
             #     args[arg.offset] = 'uint8' # enum
 
-    return ','.join(v[1] if v[1] != '' else 'uint256' for v in sorted(args.items()))
+    return args.join_to_string()

{evmole-0.3.2 → evmole-0.3.4}/evmole/evm/element.py

@@ -5,9 +5,9 @@ class Element:
     __match_args__ = ('label',)
 
     data: bytes
-    label: Any|None
+    label: Any | None
 
-    def __init__(self, data: bytes, label: Any|None = None):
+    def __init__(self, data: bytes, label: Any | None = None):
         self.data = data
         self.label = label
 

{evmole-0.3.2 → evmole-0.3.4}/evmole/evm/memory.py

@@ -12,6 +12,11 @@ class Memory:
     def store(self, offset: int, value: Element):
         self._data.append((offset, value))
 
+    def size(self) -> int:
+        if len(self._data) == 0:
+            return 0
+        return max(off + len(val.data) for off, val in self._data)
+
     def load(self, offset: int) -> tuple[bytes, set]:
         used = set()
         res = [b'\x00'] * 32

{evmole-0.3.2 → evmole-0.3.4}/evmole/evm/opcodes.py

@@ -60,6 +60,8 @@ class Op:
     CHAINID = 0x46
     SELFBALANCE = 0x47
     BASEFEE = 0x48
+    BLOBHASH = 0x49
+    BLOBBASEFEE = 0x4A
 
     POP = 0x50
     MLOAD = 0x51
@@ -73,6 +75,9 @@ class Op:
     MSIZE = 0x59
     GAS = 0x5A
     JUMPDEST = 0x5B
+    TLOAD = 0x5C
+    TSTORE = 0x5D
+    MCOPY = 0x5E
     PUSH0 = 0x5F
 
     PUSH1 = 0x60

{evmole-0.3.2 → evmole-0.3.4}/evmole/evm/vm.py

@@ -60,6 +60,18 @@ class Vm:
             self.stopped = True
         return (op, *ret)
 
+    def _bop(self, cb):
+        raws0 = self.stack.pop()
+        raws1 = self.stack.pop()
+
+        s0 = int.from_bytes(raws0.data, 'big', signed=False)
+        s1 = int.from_bytes(raws1.data, 'big', signed=False)
+
+        gas_used, res = cb(raws0, s0, raws1, s1)
+
+        self.stack.push_uint(res)
+        return (gas_used, raws0, raws1)
+
     def _exec_opcode(self, op: OpCode) -> tuple[int, *tuple[Any, ...]]:
         match op:
             case op if op >= Op.PUSH0 and op <= Op.PUSH32:
@@ -88,71 +100,57 @@ class Vm:
             case Op.JUMPDEST:
                 return (1,)
 
-            case Op.REVERT:
-                # skip 2 stack pop()s
+            case Op.REVERT | Op.STOP | Op.RETURN:
+                # skip stack pop()s
                 self.stopped = True
                 return (4,)
 
-            case op if op in {
-                Op.EQ,
-                Op.LT,
-                Op.GT,
-                Op.SUB,
-                Op.ADD,
-                Op.DIV,
-                Op.MUL,
-                Op.EXP,
-                Op.XOR,
-                Op.AND,
-                Op.OR,
-                Op.SHR,
-                Op.SHL,
-                Op.BYTE,
-            }:
-                raws0 = self.stack.pop()
-                raws1 = self.stack.pop()
+            case Op.EQ:
+                return self._bop(lambda raws0, s0, raws1, s1: (3, 1 if s0 == s1 else 0))
 
-                s0 = int.from_bytes(raws0.data, 'big', signed=False)
-                s1 = int.from_bytes(raws1.data, 'big', signed=False)
+            case Op.LT:
+                return self._bop(lambda raws0, s0, raws1, s1: (3, 1 if s0 < s1 else 0))
 
-                gas_used = 3
-                match op:
-                    case Op.EQ:
-                        res = 1 if s0 == s1 else 0
-                    case Op.LT:
-                        res = 1 if s0 < s1 else 0
-                    case Op.GT:
-                        res = 1 if s0 > s1 else 0
-                    case Op.SUB:
-                        res = (s0 - s1) & E256M1
-                    case Op.ADD:
-                        res = (s0 + s1) & E256M1
-                    case Op.DIV:
-                        res = 0 if s1 == 0 else s0 // s1
-                        gas_used = 5
-                    case Op.MUL:
-                        res = (s0 * s1) & E256M1
-                        gas_used = 5
-                    case Op.EXP:
-                        res = pow(s0, s1, E256)
-                        gas_used = 50 * (1 + (s1.bit_length() // 8))  # ~approx
-                    case Op.XOR:
-                        res = s0 ^ s1
-                    case Op.AND:
-                        res = s0 & s1
-                    case Op.OR:
-                        res = s0 | s1
-                    case Op.SHR:
-                        res = 0 if s0 >= 256 else (s1 >> s0) & E256M1
-                    case Op.SHL:
-                        res = 0 if s0 >= 256 else (s1 << s0) & E256M1
-                    case Op.BYTE:
-                        res = 0 if s0 >= 32 else raws1.data[s0]
-                    case _:
-                        raise Exception(f'BUG: op {op} not handled in match')
+            case Op.GT:
+                return self._bop(lambda raws0, s0, raws1, s1: (3, 1 if s0 > s1 else 0))
 
-                self.stack.push_uint(res)
-                return (gas_used, raws0, raws1)
+            case Op.SUB:
+                return self._bop(lambda raws0, s0, raws1, s1: (3, (s0 - s1) & E256M1))
+
+            case Op.ADD:
+                return self._bop(lambda raws0, s0, raws1, s1: (3, (s0 + s1) & E256M1))
+
+            case Op.DIV:
+                return self._bop(lambda raws0, s0, raws1, s1: (5, 0 if s1 == 0 else s0 // s1))
+
+            case Op.MOD:
+                return self._bop(lambda raws0, s0, raws1, s1: (5, 0 if s1 == 0 else s0 % s1))
+
+            case Op.MUL:
+                return self._bop(lambda raws0, s0, raws1, s1: (5, (s0 * s1) & E256M1))
+
+            case Op.EXP:
+                return self._bop(
+                    lambda raws0, s0, raws1, s1: (50 * (1 + (s1.bit_length() // 8)), pow(s0, s1, E256))
+                )  # ~approx gas
+
+            case Op.XOR:
+                return self._bop(lambda raws0, s0, raws1, s1: (3, s0 ^ s1))
+
+            case Op.AND:
+                return self._bop(lambda raws0, s0, raws1, s1: (3, s0 & s1))
+
+            case Op.OR:
+                return self._bop(lambda raws0, s0, raws1, s1: (3, s0 | s1))
+
+            case Op.SHR:
+                return self._bop(lambda raws0, s0, raws1, s1: (3, 0 if s0 >= 256 else (s1 >> s0) & E256M1))
+
+            case Op.SHL:
+                return self._bop(lambda raws0, s0, raws1, s1: (3, 0 if s0 >= 256 else (s1 << s0) & E256M1))
+
+            case Op.BYTE:
+                return self._bop(lambda raws0, s0, raws1, s1: (3, 0 if s0 >= 32 else raws1.data[s0]))
 
             case op if op in {Op.SLT, Op.SGT}:
                 raws0 = self.stack.pop()
@@ -196,6 +194,17 @@ class Vm:
                 self.stack.swap(op - Op.SWAP1 + 1)
                 return (3,)
 
+            case Op.MSIZE:
+                self.stack.push_uint(self.memory.size())
+                return (2,)
+
+            case Op.MSTORE8:
+                offset = self.stack.pop_uint()
+                value = self.stack.pop()
+                el = Element(data=value.data[31:32], label=value.label)
+                self.memory.store(offset, el)
+                return (3,)
+
             case Op.MSTORE:
                 offset = self.stack.pop_uint()
                 value = self.stack.pop()
@@ -229,8 +238,8 @@ class Vm:
                 self.stack.push_uint(res)
                 return (5, s0, raws1)
 
-            case Op.ADDRESS:
-                self.stack.push_uint(1)
+            case Op.ADDRESS | Op.ORIGIN | Op.CALLER:
+                self.stack.push_uint(0)
                 return (2,)
 
             case Op.CALLDATACOPY:
@@ -243,5 +252,45 @@ class Vm:
                 self.memory.store(mem_off, value)
                 return (4,)
 
+            case Op.SLOAD:
+                slot = self.stack.pop()
+                self.stack.push_uint(0)
+                return (100, slot)
+
+            case Op.SSTORE:
+                slot = self.stack.pop()
+                sval = self.stack.pop()
+                return (100, slot, sval)
+
+            case Op.BALANCE:
+                self.stack.pop()
+                self.stack.push_uint(1)
+                return (100,)
+
+            case Op.SELFBALANCE:
+                self.stack.push_uint(1)
+                return (5,)
+
+            case Op.GAS:
+                self.stack.push_uint(1_000_000)
+                return (2,)
+
+            case Op.CALL | Op.DELEGATECALL | Op.STATICCALL:
+                self.stack.pop()
+                p1 = self.stack.pop()
+                p2 = self.stack.pop()
+                self.stack.pop()
+                self.stack.pop()
+                self.stack.pop()
+
+                if op == Op.CALL:
+                    self.stack.pop()
+
+                self.stack.push_uint(0)  # failure
+
+                if op == Op.CALL:
+                    return (100, p1, p2)
+                return (100, p1)
+
             case _:
                 raise UnsupportedOpError(op)

{evmole-0.3.2 → evmole-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "evmole"
-version = "0.3.2"
+version = "0.3.4"
 description = "Extracts function selectors and arguments from EVM bytecode"
 authors = ["Maxim Andreev <andreevmaxim@gmail.com>"]
 license = "MIT"
@@ -9,12 +9,12 @@ repository = "https://github.com/cdump/evmole"
 
 [tool.poetry.dependencies]
 python = "^3.11"
-aiohttp = {version = "^3.9.0", optional = true}
+aiohttp = {version = "^3.9", optional = true}
 
 [tool.poetry.group.dev.dependencies]
-pytest = "^7.4.3"
-mypy = "^1.7.1"
-ruff = "^0.1.6"
+pytest = "^8.2"
+mypy = "^1.10"
+ruff = "^0.4"
 
 [tool.poetry.extras]
 benchmark = ["aiohttp"]
@@ -24,15 +24,17 @@ requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.ruff]
-extend-select = ["B", "Q", "I"]
 line-length = 130
 target-version = "py311"
 
-[tool.ruff.flake8-quotes]
+[tool.ruff.lint]
+extend-select = ["B", "Q", "I"]
+
+[tool.ruff.lint.flake8-quotes]
 inline-quotes = "single"
 
 [tool.ruff.format]
 quote-style = "single"
 
-[tool.ruff.per-file-ignores]
+[tool.ruff.lint.per-file-ignores]
 "__init__.py" = ["F401"]