dequanto 0.0.1 → 0.1.3

package/src/evm/OpcodesInfo.ts

@@ -0,0 +1,211 @@
+export namespace OpcodesInfo {
+
+    export function get(op: number, full: boolean, freeLogs?: boolean) {
+        let code = CODES[op] ? CODES[op] : ['INVALID', 0, 0, 0, false, false];
+        let opcode = code[0];
+
+        if (full) {
+            if (opcode === 'LOG') {
+                opcode += op - 0xa0;
+            }
+
+            if (opcode === 'PUSH') {
+                opcode += op - 0x5f;
+            }
+
+            if (opcode === 'DUP') {
+                opcode += op - 0x7f;
+            }
+
+            if (opcode === 'SWAP') {
+                opcode += op - 0x8f;
+            }
+        }
+
+        let fee = code[1];
+
+        if (freeLogs) {
+            if (opcode === 'LOG') {
+                fee = 0;
+            }
+        }
+
+        return {
+            name: opcode,
+            opcode: op,
+            fee: fee,
+            in: code[2],
+            out: code[3],
+            dynamic: code[4],
+            async: code[5],
+
+            pc: null,
+            pushData: null,
+        };
+    };
+
+}
+
+const CODES = {
+    // 0x0 range - arithmetic ops
+    // name, baseCost, off stack, on stack, dynamic, async
+    0x00: ['STOP', 0, 0, 0, false],
+    0x01: ['ADD', 3, 2, 1, false],
+    0x02: ['MUL', 5, 2, 1, false],
+    0x03: ['SUB', 3, 2, 1, false],
+    0x04: ['DIV', 5, 2, 1, false],
+    0x05: ['SDIV', 5, 2, 1, false],
+    0x06: ['MOD', 5, 2, 1, false],
+    0x07: ['SMOD', 5, 2, 1, false],
+    0x08: ['ADDMOD', 8, 3, 1, false],
+    0x09: ['MULMOD', 8, 3, 1, false],
+    0x0a: ['EXP', 10, 2, 1, false],
+    0x0b: ['SIGNEXTEND', 5, 2, 1, false],
+
+    // 0x10 range - bit ops
+    0x10: ['LT', 3, 2, 1, false],
+    0x11: ['GT', 3, 2, 1, false],
+    0x12: ['SLT', 3, 2, 1, false],
+    0x13: ['SGT', 3, 2, 1, false],
+    0x14: ['EQ', 3, 2, 1, false],
+    0x15: ['ISZERO', 3, 1, 1, false],
+    0x16: ['AND', 3, 2, 1, false],
+    0x17: ['OR', 3, 2, 1, false],
+    0x18: ['XOR', 3, 2, 1, false],
+    0x19: ['NOT', 3, 1, 1, false],
+    0x1a: ['BYTE', 3, 2, 1, false],
+    0x1b: ['SHL', 3, 2, 1, false],
+    0x1c: ['SHR', 3, 2, 1, false],
+    0x1d: ['SAR', 3, 2, 1, false],
+
+    // 0x20 range - crypto
+    0x20: ['SHA3', 30, 2, 1, false],
+
+    // 0x30 range - closure state
+    0x30: ['ADDRESS', 2, 0, 1, true],
+    0x31: ['BALANCE', 400, 1, 1, true, true],
+    0x32: ['ORIGIN', 2, 0, 1, true],
+    0x33: ['CALLER', 2, 0, 1, true],
+    0x34: ['CALLVALUE', 2, 0, 1, true],
+    0x35: ['CALLDATALOAD', 3, 1, 1, true],
+    0x36: ['CALLDATASIZE', 2, 0, 1, true],
+    0x37: ['CALLDATACOPY', 3, 3, 0, true],
+    0x38: ['CODESIZE', 2, 0, 1, false],
+    0x39: ['CODECOPY', 3, 3, 0, false],
+    0x3a: ['GASPRICE', 2, 0, 1, false],
+    0x3b: ['EXTCODESIZE', 700, 1, 1, true, true],
+    0x3c: ['EXTCODECOPY', 700, 4, 0, true, true],
+    0x3d: ['RETURNDATASIZE', 2, 0, 1, true],
+    0x3e: ['RETURNDATACOPY', 3, 3, 0, true],
+    0x3f: ['EXTCODEHASH', 400, 1, 1, true, true],
+
+    // '0x40' range - block operations
+    0x40: ['BLOCKHASH', 20, 1, 1, true, true],
+    0x41: ['COINBASE', 2, 0, 1, true],
+    0x42: ['TIMESTAMP', 2, 0, 1, true],
+    0x43: ['NUMBER', 2, 0, 1, true],
+    0x44: ['DIFFICULTY', 2, 0, 1, true],
+    0x45: ['GASLIMIT', 2, 0, 1, true],
+
+    // 0x50 range - 'storage' and execution
+    0x50: ['POP', 2, 1, 0, false],
+    0x51: ['MLOAD', 3, 1, 1, false],
+    0x52: ['MSTORE', 3, 2, 0, false],
+    0x53: ['MSTORE8', 3, 2, 0, false],
+    0x54: ['SLOAD', 200, 1, 1, true, true],
+    0x55: ['SSTORE', 0, 2, 0, true, true],
+    0x56: ['JUMP', 8, 1, 0, false],
+    0x57: ['JUMPI', 10, 2, 0, false],
+    0x58: ['PC', 2, 0, 1, false],
+    0x59: ['MSIZE', 2, 0, 1, false],
+    0x5a: ['GAS', 2, 0, 1, false],
+    0x5b: ['JUMPDEST', 1, 0, 0, false],
+
+    // 0x60, range
+    0x60: ['PUSH', 3, 0, 1, false],
+    0x61: ['PUSH', 3, 0, 1, false],
+    0x62: ['PUSH', 3, 0, 1, false],
+    0x63: ['PUSH', 3, 0, 1, false],
+    0x64: ['PUSH', 3, 0, 1, false],
+    0x65: ['PUSH', 3, 0, 1, false],
+    0x66: ['PUSH', 3, 0, 1, false],
+    0x67: ['PUSH', 3, 0, 1, false],
+    0x68: ['PUSH', 3, 0, 1, false],
+    0x69: ['PUSH', 3, 0, 1, false],
+    0x6a: ['PUSH', 3, 0, 1, false],
+    0x6b: ['PUSH', 3, 0, 1, false],
+    0x6c: ['PUSH', 3, 0, 1, false],
+    0x6d: ['PUSH', 3, 0, 1, false],
+    0x6e: ['PUSH', 3, 0, 1, false],
+    0x6f: ['PUSH', 3, 0, 1, false],
+    0x70: ['PUSH', 3, 0, 1, false],
+    0x71: ['PUSH', 3, 0, 1, false],
+    0x72: ['PUSH', 3, 0, 1, false],
+    0x73: ['PUSH', 3, 0, 1, false],
+    0x74: ['PUSH', 3, 0, 1, false],
+    0x75: ['PUSH', 3, 0, 1, false],
+    0x76: ['PUSH', 3, 0, 1, false],
+    0x77: ['PUSH', 3, 0, 1, false],
+    0x78: ['PUSH', 3, 0, 1, false],
+    0x79: ['PUSH', 3, 0, 1, false],
+    0x7a: ['PUSH', 3, 0, 1, false],
+    0x7b: ['PUSH', 3, 0, 1, false],
+    0x7c: ['PUSH', 3, 0, 1, false],
+    0x7d: ['PUSH', 3, 0, 1, false],
+    0x7e: ['PUSH', 3, 0, 1, false],
+    0x7f: ['PUSH', 3, 0, 1, false],
+
+    0x80: ['DUP', 3, 0, 1, false],
+    0x81: ['DUP', 3, 0, 1, false],
+    0x82: ['DUP', 3, 0, 1, false],
+    0x83: ['DUP', 3, 0, 1, false],
+    0x84: ['DUP', 3, 0, 1, false],
+    0x85: ['DUP', 3, 0, 1, false],
+    0x86: ['DUP', 3, 0, 1, false],
+    0x87: ['DUP', 3, 0, 1, false],
+    0x88: ['DUP', 3, 0, 1, false],
+    0x89: ['DUP', 3, 0, 1, false],
+    0x8a: ['DUP', 3, 0, 1, false],
+    0x8b: ['DUP', 3, 0, 1, false],
+    0x8c: ['DUP', 3, 0, 1, false],
+    0x8d: ['DUP', 3, 0, 1, false],
+    0x8e: ['DUP', 3, 0, 1, false],
+    0x8f: ['DUP', 3, 0, 1, false],
+
+    0x90: ['SWAP', 3, 0, 0, false],
+    0x91: ['SWAP', 3, 0, 0, false],
+    0x92: ['SWAP', 3, 0, 0, false],
+    0x93: ['SWAP', 3, 0, 0, false],
+    0x94: ['SWAP', 3, 0, 0, false],
+    0x95: ['SWAP', 3, 0, 0, false],
+    0x96: ['SWAP', 3, 0, 0, false],
+    0x97: ['SWAP', 3, 0, 0, false],
+    0x98: ['SWAP', 3, 0, 0, false],
+    0x99: ['SWAP', 3, 0, 0, false],
+    0x9a: ['SWAP', 3, 0, 0, false],
+    0x9b: ['SWAP', 3, 0, 0, false],
+    0x9c: ['SWAP', 3, 0, 0, false],
+    0x9d: ['SWAP', 3, 0, 0, false],
+    0x9e: ['SWAP', 3, 0, 0, false],
+    0x9f: ['SWAP', 3, 0, 0, false],
+
+    0xa0: ['LOG', 375, 2, 0, false],
+    0xa1: ['LOG', 375, 3, 0, false],
+    0xa2: ['LOG', 375, 4, 0, false],
+    0xa3: ['LOG', 375, 5, 0, false],
+    0xa4: ['LOG', 375, 6, 0, false],
+
+    // '0xf0' range - closures
+    0xf0: ['CREATE', 32000, 3, 1, true, true],
+    0xf1: ['CALL', 700, 7, 1, true, true],
+    0xf2: ['CALLCODE', 700, 7, 1, true, true],
+    0xf3: ['RETURN', 0, 2, 0, false],
+    0xf4: ['DELEGATECALL', 700, 6, 1, true, true],
+    0xf5: ['CREATE2', 32000, 4, 1, true, true],
+    0xfa: ['STATICCALL', 700, 6, 1, true, true],
+    0xfd: ['REVERT', 0, 2, 0, false],
+
+    // '0x70', range - other
+    0xfe: ['INVALID', 0, 0, 0, false],
+    0xff: ['SELFDESTRUCT', 5000, 1, 0, false, true]
+};

package/src/evm/OpcodesWalker.ts

@@ -0,0 +1,156 @@
+import type { EvmBytecode } from './EvmBytecode';
+import { $abiUtils } from '@dequanto/utils/$abiUtils';
+import IOpcode from './interfaces/IOpcode';
+import Stack from './Stack';
+import opcodeFunctions from './utils/opcodes';
+
+export class OpcodesWalker {
+
+    current: IOpcode;
+
+    stack = new Stack();
+
+    constructor(public evm: EvmBytecode, public opcodes: IOpcode[]) {
+
+    }
+
+    getMethodOpcodes (mix: string | { sig: string }) {
+        let sig = typeof mix === 'string'
+            ? $abiUtils.getMethodSignature(mix)
+            : mix.sig;
+
+        let method = this.opcodes.find(x => x.name === 'PUSH4' && x.pushData?.toString('hex') === sig.substring(2));
+        if (method == null) {
+            throw new Error(`ABI ${JSON.stringify(mix)} not found in bytecode`);
+        }
+
+        this.evm.pc = method.pc;
+        this.current = method;
+
+        while (this.next() != null) {
+            if (IsOpcode.ofType(this.current, 'JUMP') === false) {
+                opcodeFunctions[this.current.name](this.current, this.evm);
+                continue;
+            }
+            let dest = this.evm.stack.pop();
+            let destOpcode = this.next(dest);
+            if (IsOpcode.ofType(destOpcode, 'JUMPDEST') === false) {
+                throw new Error(`Jump to ${dest} should be a destination opcode, got ${destOpcode?.name}`);
+            }
+            break;
+        }
+
+        let { opcodes, exit } = this.goToExit();
+        return { opcodes, exit };
+    }
+
+    private goToExit (prev?: IOpcode): { opcodes: IOpcode[], exit?: 'RETURN' | 'STOP' | 'LOOP' | 'END' | 'REVERT' | 'INVALID' } {
+        if (prev != null) {
+            this.current = prev;
+            this.evm.pc = prev.pc;
+        }
+
+        let visited = [];
+        let seen = 0;
+        while (this.next() != null) {
+
+            if (visited.includes(this.current)) {
+                seen++;
+                const MAX_LOOP_DEPTH = 100;
+                if (seen > MAX_LOOP_DEPTH) {
+                    return {
+                        opcodes: visited,
+                        exit: 'LOOP'
+                    };
+                }
+            } else {
+                seen = 0;
+                visited.push(this.current);
+            }
+
+            let name = this.current.name;
+            if (name === 'RETURN' || name === 'STOP') {
+                return {
+                    opcodes: visited,
+                    exit: name
+                };
+            }
+            if (name === 'REVERT' || name === 'INVALID') {
+                return {
+                    opcodes: visited,
+                    exit: name,
+                }
+            }
+
+            // process any non-jump opcodes
+            if (IsOpcode.ofType(this.current, 'JUMP') === false) {
+                opcodeFunctions[this.current.name](this.current, this.evm);
+                continue;
+            }
+
+            let destination = this.evm.stack.pop();
+            if (this.current.name === 'JUMPI') {
+                // Is Conditional
+                this.evm.stack.pop();
+
+                // Visit falsy leaf (as if the jump not occured)
+                let evm = this.evm.clone();
+                let walker = new OpcodesWalker(evm, this.opcodes);
+                let { opcodes } = walker.goToExit(this.current);
+                visited.push(...opcodes);
+            }
+
+            let destOpcode = this.next(destination);
+            if (IsOpcode.ofType(destOpcode, 'JUMPDEST') === false) {
+                throw new Error(`Jump to ${destination} should be a destination opcode, got ${destOpcode?.name}`);
+            }
+        }
+        return {
+            opcodes: visited,
+            exit: 'END'
+        };
+    }
+
+    private next(dest?: bigint | any) {
+        if (dest != null) {
+            if (typeof dest === 'bigint') {
+                dest = Number(dest);
+            }
+            if (typeof dest === 'number') {
+                let opcode = this.opcodes.find(x => x.pc === dest);
+                if (opcode == null) {
+                    console.log(this.opcodes.map(x => `${x.pc.toString(16)} ${x.name}`).join('\n'));
+                    throw new Error(`No OPCODE found at ${dest.toString(16)}`);
+                }
+                this.current = opcode;
+                this.evm.pc = this.current.pc;
+                return this.current;
+            }
+        }
+        let i = this.opcodes.indexOf(this.current);
+
+        this.current = this.opcodes[i + 1];
+        this.evm.pc = this.current.pc;
+        return this.current;
+    }
+}
+
+export namespace IsOpcode {
+    export function ofType (opcode: IOpcode, name: keyof typeof rgxes) {
+        if (opcode == null) {
+            return false;
+        }
+        if (typeof name === 'string') {
+            let rgx = rgxes[name];
+            return rgx.test(opcode.name);
+        }
+        return false;
+    }
+
+    const rgxes = {
+        'PUSH': /^PUSH\d*$/i,
+        'JUMP': /^JUMPI?$/i,
+        'JUMPDEST': /^JUMPDEST$/i,
+        'RETURN': /^RETURN$/i
+    };
+}

package/src/evm/Stack.ts

@@ -0,0 +1,58 @@
+export default class Stack {
+    elements: any[];
+
+    constructor() {
+        this.elements = [];
+    }
+
+    push(item: any): void {
+        if (this.elements.length >= 1024) {
+            throw new Error('Stack too deep');
+        } else {
+            this.elements.unshift(item);
+        }
+    }
+
+    pop(): any {
+        if (this.elements.length === 0) {
+           // throw new Error('POP with empty stack');
+        } else {
+            return this.elements.shift();
+        }
+    }
+
+    duplicate(position: number): void {
+        if (position < 0 || position > 15) {
+            throw new Error('Unsupported position for duplication operation');
+        } else if (!(position in this.elements)) {
+            throw new Error(
+                "Invalid duplication operation, provided position wasn't found in stack"
+            );
+        } else {
+            this.push(this.elements[position]);
+        }
+    }
+
+    swap(secondPosition: number): void {
+        if (secondPosition < 1 || secondPosition > 16) {
+            throw new Error('Unsupported position for swap operation');
+        } else if (!(secondPosition in this.elements)) {
+            throw new Error("Invalid swap operation, provided position wasn't found in stack");
+        } else {
+            const firstValue = this.elements[0];
+            const secondValue = this.elements[secondPosition];
+            this.elements[0] = secondValue;
+            this.elements[secondPosition] = firstValue;
+        }
+    }
+
+    clone(): Stack {
+        const stack = new Stack();
+        stack.elements = [...this.elements];
+        return stack;
+    }
+
+    reset(): void {
+        this.elements = [];
+    }
+}

package/src/evm/functions/$opcodes.ts

@@ -0,0 +1,122 @@
+export namespace $opcodes {
+    export const UINT256_SIZE = 2n**256n;
+    export const UINT256_MAX = UINT256_SIZE - 1n;
+    export const UINT256_MIN = 0n;
+
+    export const INT256_MAX = (UINT256_SIZE / 2n) - 1n;
+    export const INT256_MIN = -UINT256_SIZE / 2n;
+
+    export function add (a: bigint, b: bigint): bigint {
+        return uint256(a + b);
+    }
+    export function mul (a: bigint, b: bigint): bigint {
+        return uint256(a * b);
+    }
+    export function sub (a: bigint, b: bigint): bigint {
+        return uint256(a - b);
+    }
+    export function div (a: bigint, b: bigint): bigint {
+        if (b === 0n) {
+            return b;
+        }
+        return uint256(a / b);
+    }
+    export function sdiv (a: bigint, b: bigint): bigint {
+        if (b === 0n) {
+            return b;
+        }
+        return int256(a) / int256(b);
+    }
+    export function mod (a: bigint, b: bigint): bigint {
+        if (b === 0n) {
+            return 0n;
+        }
+        return a % b;
+    }
+    export function smod (a: bigint, b: bigint): bigint {
+        if (b === 0n) {
+            return 0n;
+        }
+        return uint256(int256(a) % int256(b));
+    }
+    export function addmod(a: bigint, b: bigint, N: bigint): bigint {
+        return mod(a + b, N);
+    }
+    export function mulmod(a: bigint, b: bigint, N: bigint): bigint {
+        return mod(a * b, N);
+    }
+    export function exp (a: bigint, exp: bigint) {
+        return uint256(a ** exp);
+    }
+
+    export function signextend (byteCount: bigint, x: bigint) {
+        // @TODO as bigint is not byte limited, we can not/do not need to extend, return same value
+        return x;
+    }
+    export function lt (a: bigint, b: bigint) {
+        return a < b ? 1n : 0n;
+    }
+    export function gt (a: bigint, b: bigint) {
+        return a > b ? 1n : 0n;
+    }
+    export function slt (a: bigint, b: bigint) {
+        return int256(a) < int256(b) ? 1n : 0n;
+    }
+    export function sgt (a: bigint, b: bigint) {
+        return int256(a) > int256(b) ? 1n : 0n;
+    }
+    export function eq (a: bigint, b: bigint) {
+        return a === b ? 1n : 0n;
+    }
+    export function iszero (a: bigint) {
+        return a === 0n ? 1n : 0n;
+    }
+    export function and (a: bigint, b: bigint) {
+        return a & b;
+    }
+    export function or (a: bigint, b: bigint) {
+        return a | b;
+    }
+    export function xor (a: bigint, b: bigint) {
+        return a ^ b;
+    }
+    export function not (a: bigint) {
+        return uint256(~a);
+    }
+    export function byte (i: number, a: bigint) {
+        // 0xFF === 0x00000000000000000000000000000000000000000000000000000000000000FF
+        // Index 0 is the first Byte in the 32-byte WORD
+        // ...
+        // Index 31 is the last Byte in the 32-byte WORD
+        const LENGTH = 32;
+        const shifted = shr(8 * (LENGTH - i - 1), a);
+        return shifted & 0xFFn;
+    }
+    export function shl (bits: number, a: bigint) {
+        if (bits > 255) {
+            return 0;
+        }
+        return uint256(a << BigInt(bits));
+    }
+    export function shr (bits: number, a: bigint) {
+        return uint256(a >> BigInt(bits));
+    }
+    export function sar (bits: number, a: bigint) {
+        return uint256(int256(a) >> BigInt(bits));
+    }
+
+
+    export function uint256(x: bigint): bigint {
+        return unchecked(x, UINT256_SIZE, UINT256_MIN, UINT256_MAX);
+    }
+    export function int256(x: bigint): bigint {
+        return unchecked(x, UINT256_SIZE, INT256_MIN, INT256_MAX);
+    }
+
+    export function unchecked (a: bigint, size: bigint, min: bigint, max: bigint) {
+        a = a % size;
+        a = a > max ? (a - size) : a;
+        a = a < min ? (a + size) : a;
+        return a;
+    }
+}

package/src/evm/functions/opcodes.spec.ts

@@ -0,0 +1,47 @@
+import { $opcodes } from './$opcodes'
+
+UTest({
+    'overflows' () {
+        eq_($opcodes.int256($opcodes.INT256_MAX + 1n), $opcodes.INT256_MIN);
+
+        eq_($opcodes.sub(0n, 1n), $opcodes.UINT256_MAX);
+        eq_($opcodes.div(1n, 2n), 0n);
+
+        eq_($opcodes.sdiv(
+            0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEn,
+            0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFn
+        ), 2n);
+
+        eq_($opcodes.smod(
+            0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF8n,
+            0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDn
+        ),  0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEn);
+
+        eq_($opcodes.addmod(
+            0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFn,
+            2n,
+            2n
+        ), 1n);
+
+        eq_($opcodes.mulmod(
+            0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFn,
+            0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFn,
+            12n
+        ), 9n);
+
+        eq_($opcodes.slt(
+            0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFn,
+            0n
+        ), 1n);
+
+        eq_($opcodes.not(
+            0n
+        ), 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFn);
+
+        eq_($opcodes.byte(31,0xFFn), 0xFFn);
+        eq_($opcodes.byte(30,0xFF00n), 0xFFn);
+
+        eq_($opcodes.sar(1, 2n), 1n);
+        eq_($opcodes.sar(4, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0n), 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFn);
+    }
+})

package/src/evm/interfaces/IJumps.ts

@@ -0,0 +1,3 @@
+export default interface IJumps {
+    [key: string]: boolean;
+}

package/src/evm/interfaces/IMemory.ts

@@ -0,0 +1,3 @@
+export default interface IMemory {
+    [key: string]: any;
+}

package/src/evm/interfaces/IOpcode.ts

@@ -0,0 +1,11 @@
+export default interface IOpcode {
+    pc: number;
+    pushData?: Buffer;
+    name: string;
+    opcode: number;
+    fee: number;
+    in: number;
+    out: number;
+    dynamic: boolean;
+    async: boolean;
+}

package/src/evm/interfaces/IStorage.ts

@@ -0,0 +1,3 @@
+export default interface IStorage {
+    [key: string]: string;
+}

package/src/evm/opcodes/add.ts

@@ -0,0 +1,49 @@
+import { $is } from '@dequanto/utils/$is';
+import { EvmBytecode } from '../EvmBytecode';
+import Opcode from '../interfaces/IOpcode';
+import { BigNumber } from '../utils/BigNumber';
+import stringify from '../utils/stringify';
+
+export class ADD {
+    readonly name: string;
+    readonly wrapped: boolean;
+    readonly left: any;
+    readonly right: any;
+
+    constructor(left: any, right: any) {
+        this.name = 'ADD';
+        this.wrapped = true;
+        this.left = left;
+        this.right = right;
+    }
+
+    toString() {
+        return stringify(this.left) + ' + ' + stringify(this.right);
+    }
+
+    get type() {
+        if (this.left.type === this.right.type) {
+            return this.left.type;
+        } else if (!this.left.type && this.right.type) {
+            return this.right.type;
+        } else if (!this.right.type && this.left.type) {
+            return this.left.type;
+        } else {
+            return false;
+        }
+    }
+}
+
+export default (opcode: Opcode, state: EvmBytecode): void => {
+    const left = state.stack.pop();
+    const right = state.stack.pop();
+    if ($is.BigInt(left) && $is.BigInt(right)) {
+        state.stack.push(left + right);
+    } else if ($is.BigInt(left) && left === 0n) {
+        state.stack.push(right);
+    } else if ($is.BigInt(right) && right === 0n) {
+        state.stack.push(left);
+    } else {
+        state.stack.push(new ADD(left, right));
+    }
+};

package/src/evm/opcodes/addmod.ts

@@ -0,0 +1,19 @@
+import { $is } from '@dequanto/utils/$is';
+import { EvmBytecode } from '../EvmBytecode';
+import Opcode from '../interfaces/IOpcode';
+import { ADD } from './add';
+import { MOD } from './mod';
+
+
+export default (opcode: Opcode, state: EvmBytecode): void => {
+    const left = state.stack.pop();
+    const right = state.stack.pop();
+    const mod = state.stack.pop();
+    if ($is.BigInt(left) && $is.BigInt(right) && $is.BigInt(mod)) {
+        state.stack.push((left + right) % mod);
+    } else if ($is.BigInt(left) && $is.BigInt(right)) {
+        state.stack.push(new MOD(left + right, mod));
+    } else {
+        state.stack.push(new MOD(new ADD(left, right), mod));
+    }
+};