@bradthomasbrown/evm-single-context 1.0.0

package/README.md

@@ -0,0 +1,91 @@
+# evm-single-context
+This is an implementation of a "single-context machine" partial interpretation of an Ethereum Virtual Machine (EVM). 
+By "single-context machine", we mean that an instance of one of these machines will run until the point where most EVM implementations would recurse into a new execution context, like on any CALL-type or CREATE-type opcode.
+This kind of machine will be different in that instances will simply block when these opcodes are reached and will wait for a higher machine or coordinator to do what is necessary and then unblock the machine.
+
+## Why?
+For local testing, we found quickly that Anvil has execution consensus divergences (bugs) with go-ethereum (`geth`). If we want to deploy a contract on Ethereum Mainnet, we should not use Anvil.
+`geth` itself is very inflexible and not friendly for local development work and testing. If you want to test handling chain reorganizations, this will end up being a lot of work. Anvil allows easy testing of this, but has the aformentioned bugs.
+Both require spinning up a node with an external application/binary and probably some form of container runtime.
+The official JS/TS implementation is just as inflexible since it is designed to closely mirror `geth` and contains a lot of complexity and bloat since it aims to be as close to full EVM functionality as possible.
+This will be the first of a set of light, simple, and flexible implementations designed to be easy to work with and use for developing/testing/verification.
+
+## Installation
+```sh
+npm i @bradthomasbrown/evm-single-context
+```
+
+## Usage
+```js
+import type { Context } from "@bradthomasbrown/evm-single-context/types";
+import { EvmEntity } from "@bradthomasbrown/entity/evm";
+import { createContext } from "@bradthomasbrown/evm-single-context/lib";
+import { SingleContextMachine, traceObjects } from "@bradthomasbrown/evm-single-context";
+
+// set up some test parameters
+const parameters = {
+    from: "0x45c3bde5d2cc59a626bee55ac8e494cf128e866e",
+    gas: 217590n,
+    value: 111360000000000000n,
+    input: await Bun.file("testinput.hex").text(), // or any other way to set the input/data/calldata, which should appear as `0x<hex>...`
+    code: await Bun.file("testcode.hex").text(), // or any other way to set the code, which should appear as `0x<hex>...`
+};
+
+// assign a random address for a contract
+const contract = EvmEntity.random();
+
+// get the code as a uint8array
+const code = parameters.code === null
+    ? Uint8Array.fromHex(parameters.input.slice(2)).buffer
+    : Uint8Array.fromHex(parameters.code.slice(2)).buffer;
+
+// create state
+const accounts:Context["states"][number]["accounts"] = new Map([ [contract.address, { nonce: 1n, balance: 0n, code }] ]);
+const states:Context["states"] = [{ accounts, transientStorage: null, storage: null }];
+
+// create a context
+const context = createContext({
+    origin:parameters.from,
+    sender:parameters.from,
+    value:parameters.value,
+    to:contract.address,
+    gas:parameters.gas,
+    calldata:Uint8Array.fromHex(parameters.input.slice(2)).buffer,
+    code,
+    states
+});
+
+// do some initial context handling (more related to transactions, not single-contexts),
+// like initial transaction cost and pre-warming precompile addresses
+let g0_data = 0n;
+if (context.calldata !== null)
+    for (const byte of new Uint8Array(context.calldata))
+        g0_data += byte === 0 ? 4n : 16n;
+let g0_create = 0n;
+if (context.to === null) {
+    const codeArray = new Uint8Array(context.calldata!);
+    g0_create += 32000n;
+    g0_create += 2n * BigInt((codeArray.byteLength + 0x1f & ~0x1f) >> 5);
+}
+const g0_transaction = 21000n;
+const g0 = g0_data + g0_create + g0_transaction;
+context.gas -= g0;
+context.accountAccessSet.add(`0x${"1".padStart(40, '0')}`);
+
+// create a single-context machine from this context, initialize and run it, then log trace objects
+// should replicate go-ethereum's traces
+const machine = new SingleContextMachine(context);
+machine.initializeAndRun();
+console.log(traceObjects);
+/* ..., {
+    pc: 409,
+    op: "JUMP",
+    gas: 189836,
+    gasCost: 8,
+    depth: 1,
+    stack: [ "0x0", "0x19a", "0x36c", "0x13c" ],
+    memory: [ "0000000000000000000000000000000000000000000000000000000000000000", "0000000000000000000000000000000000000000000000000000000000000000",
+        "0000000000000000000000000000000000000000000000000000000000000080"
+    ],
+}, ... */
+```

package/dist/lib.d.ts

@@ -0,0 +1,26 @@
+import type { MapComponents, Context, PartialContext } from "./types.js";
+import { keccak256 } from "@bradthomasbrown/keccak/keccak256";
+declare function byteSliceToBigInt_be(bytes: Uint8Array, offset: number, size: number, permitOobZeroes: boolean): bigint;
+declare function numberToHex(value: number | bigint, padding: number): string;
+declare const F: {
+    p: bigint;
+    sqrt: (a: number | bigint) => bigint;
+    add(a: bigint | number, b: bigint | number): bigint;
+    multiply(a: bigint | number, b: bigint | number): bigint;
+    inverse(a: bigint | number): bigint;
+    subtract(a: bigint | number, b: bigint | number): bigint;
+    reciprocal(a: bigint | number): bigint;
+    divide(a: bigint | number, b: bigint | number): bigint;
+    power(b: bigint | number, e: bigint | number): bigint;
+};
+declare function pop(stack: Array<bigint>, count: number): bigint[];
+declare function peek(stack: Array<bigint>, count: number): bigint[];
+declare function copy(destinationBuffer: ArrayBuffer, sourceBuffer: null | ArrayBuffer, destinationOffset: number, sourceOffset: number, size: number, permitOobZeroes: boolean): void;
+declare function memoryExpand(context: Context, size: number): void;
+declare function getStateValue<I extends keyof Context["states"][number], M extends Context["states"][number][I], C extends MapComponents<NonNullable<M>>, K extends C["keyPath"], V extends C["value"]>(states: Context["states"], maxIndex: null | number, mapIdentifier: I, keyPath: K): null | V;
+declare function createContext(partialContext: PartialContext): Context;
+declare function deriveAddress(context: Context): string;
+declare function deriveAddress2(sender: string, salt: bigint, code: ArrayBuffer): string;
+declare function write(destination: ArrayBuffer, value: bigint, offset: number, size: number): void;
+export { byteSliceToBigInt_be, numberToHex, F, keccak256, pop, peek, copy, memoryExpand, getStateValue, write, createContext, deriveAddress, deriveAddress2 };
+//# sourceMappingURL=lib.d.ts.map

package/dist/lib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../src/lib.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEzE,OAAO,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAG9D,iBAAS,oBAAoB,CAAC,KAAK,EAAC,UAAU,EAAE,MAAM,EAAC,MAAM,EAAE,IAAI,EAAC,MAAM,EAAE,eAAe,EAAC,OAAO,UAOlG;AAED,iBAAS,WAAW,CAAC,KAAK,EAAC,MAAM,GAAC,MAAM,EAAE,OAAO,EAAC,MAAM,UAEvD;AAMD,QAAA,MAAM,CAAC;;;;;;;;;;CAAqB,CAAC;AAE7B,iBAAS,GAAG,CAAC,KAAK,EAAC,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,EAAC,MAAM,YAK7C;AAED,iBAAS,IAAI,CAAC,KAAK,EAAC,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,EAAC,MAAM,YAK9C;AAED,iBAAS,IAAI,CAAC,iBAAiB,EAAC,WAAW,EAAE,YAAY,EAAC,IAAI,GAAC,WAAW,EAAE,iBAAiB,EAAC,MAAM,EAAE,YAAY,EAAC,MAAM,EAAE,IAAI,EAAC,MAAM,EAAE,eAAe,EAAC,OAAO,QAa9J;AAED,iBAAS,YAAY,CAAC,OAAO,EAAC,OAAO,EAAE,IAAI,EAAC,MAAM,QAWjD;AAED,iBAAS,aAAa,CAClB,CAAC,SAAS,MAAM,OAAO,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,EACzC,CAAC,SAAS,OAAO,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EACtC,CAAC,SAAS,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EACvC,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC,EACtB,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,EACtB,MAAM,EAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,QAAQ,EAAC,IAAI,GAAC,MAAM,EAAE,aAAa,EAAC,CAAC,EAAE,OAAO,EAAC,CAAC,GAAE,IAAI,GAAC,CAAC,CAenF;AAED,iBAAS,aAAa,CAAC,cAAc,EAAC,cAAc,GAAE,OAAO,CA0B5D;AAED,iBAAS,aAAa,CAAC,OAAO,EAAC,OAAO,UAIrC;AAED,iBAAS,cAAc,CAAC,MAAM,EAAC,MAAM,EAAE,IAAI,EAAC,MAAM,EAAE,IAAI,EAAC,WAAW,UAOnE;AAED,iBAAS,KAAK,CAAC,WAAW,EAAC,WAAW,EAAE,KAAK,EAAC,MAAM,EAAE,MAAM,EAAC,MAAM,EAAE,IAAI,EAAC,MAAM,QAI/E;AAED,OAAO,EAAE,oBAAoB,EAAE,WAAW,EAAE,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,YAAY,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,cAAc,EAAE,CAAC"}

package/dist/lib.js

@@ -0,0 +1,129 @@
+import { _7c3dda_ } from "@bradthomasbrown/finite-field";
+import { keccak256 } from "@bradthomasbrown/keccak/keccak256";
+import { encode } from "@bradthomasbrown/rlp";
+function byteSliceToBigInt_be(bytes, offset, size, permitOobZeroes) {
+    if ((permitOobZeroes === false) && (offset + size > bytes.byteLength))
+        throw new Error("out of bounds", { cause: { bytes, offset, size } });
+    let value = 0n;
+    for (let i = offset; i < offset + size; i++)
+        value = (value << 8n) + (i >= bytes.byteLength ? 0n : BigInt(bytes[i]));
+    return value;
+}
+function numberToHex(value, padding) {
+    return value.toString(16).padStart(padding, '0');
+}
+// shouldn't use p3mod4 field implementation here, so we make our own field implementation
+function sqrt() { throw new Error("sqrt unsupported"); return 0n; }
+const FiniteField = _7c3dda_(sqrt);
+const p = (1n << 256n);
+const F = new FiniteField(p);
+function pop(stack, count) {
+    const array = new Array(count);
+    for (let j = 0; j < count; j++)
+        array[j] = stack.pop();
+    return array;
+}
+function peek(stack, count) {
+    const array = new Array(count);
+    for (let j = 0; j < count; j++)
+        array[j] = stack.at(0 - (j + 1));
+    return array;
+}
+function copy(destinationBuffer, sourceBuffer, destinationOffset, sourceOffset, size, permitOobZeroes) {
+    if (size == 0)
+        return;
+    let sourceBytesAvailable = 0;
+    if (sourceBuffer !== null && sourceOffset < sourceBuffer.byteLength)
+        sourceBytesAvailable = Math.min(sourceBuffer.byteLength - sourceOffset, size);
+    const destinationArray = new Uint8Array(destinationBuffer);
+    if (sourceBytesAvailable > 0) {
+        const sourceArray = new Uint8Array(sourceBuffer.slice(sourceOffset, sourceOffset + sourceBytesAvailable));
+        destinationArray.set(sourceArray, destinationOffset);
+    }
+    const bytesRemaining = size - sourceBytesAvailable;
+    if (bytesRemaining == 0)
+        return;
+    if (permitOobZeroes === false)
+        throw new Error(`outOfBoundsCopy`, { cause: { destinationBuffer, sourceBuffer, destinationOffset, sourceOffset, size } });
+    destinationArray.fill(0, destinationOffset + sourceBytesAvailable, bytesRemaining);
+}
+function memoryExpand(context, size) {
+    if (size == 0)
+        return;
+    if (context.memory === null)
+        context.memory = new ArrayBuffer(1);
+    const memoryWords = (size + 0x1f) >> 5;
+    if (context.memoryWords >= memoryWords)
+        return;
+    const C_mem = 3n * BigInt(memoryWords) + BigInt(memoryWords) ** 2n / 512n;
+    context.gas -= C_mem - context.C_mem_prev;
+    context.memoryWords = memoryWords;
+    context.C_mem_prev = C_mem;
+    while (context.memory.byteLength < size)
+        context.memory = context.memory.transfer(context.memory.byteLength << 1);
+}
+function getStateValue(states, maxIndex, mapIdentifier, keyPath) {
+    let value = null;
+    l0: for (let i = Math.min(maxIndex ?? states.length - 1, states.length - 1); i >= 0; i--) {
+        let map = states[i][mapIdentifier];
+        if (map === null)
+            continue;
+        for (let j = 0; j < keyPath.length - 1; j++) {
+            if (map.has(keyPath[j]) === false)
+                continue l0;
+            map = map.get(keyPath[j]);
+        }
+        const lastKeyComponent = keyPath[keyPath.length - 1];
+        if (map.has(lastKeyComponent) === false)
+            continue;
+        value = map.get(lastKeyComponent);
+        break;
+    }
+    return value;
+}
+function createContext(partialContext) {
+    return {
+        origin: partialContext.origin,
+        sender: partialContext.sender,
+        to: partialContext.to ?? null,
+        address: partialContext.address ?? null,
+        value: partialContext.value ?? 0n,
+        pc: partialContext.pc ?? 0,
+        gas: partialContext.gas ?? 0n,
+        stack: partialContext.stack ?? [],
+        memory: partialContext.memory ?? null,
+        C_mem_prev: partialContext.C_mem_prev ?? 0n,
+        returndata: partialContext.returndata ?? null,
+        accountAccessSet: partialContext.accountAccessSet ?? new Set(),
+        storageAccessSet: partialContext.storageAccessSet ?? new Map(),
+        depth: partialContext.depth ?? 1,
+        calldata: partialContext.calldata ?? null,
+        subcontext: partialContext.subcontext ?? null,
+        blocked: partialContext.blocked ?? false,
+        reverted: partialContext.reverted ?? null,
+        states: partialContext.states ?? [{ accounts: null, transientStorage: null, storage: null }],
+        refund: partialContext.refund ?? 0n,
+        code: partialContext.code ?? null,
+        memoryWords: 0,
+        L: null
+    };
+}
+function deriveAddress(context) {
+    const account = getStateValue(context.states, null, "accounts", [context.sender]);
+    const addressBytes = Uint8Array.fromHex(context.sender.slice(2));
+    return `0x${keccak256(encode([addressBytes, account.nonce])).slice(12).toHex()}`;
+}
+function deriveAddress2(sender, salt, code) {
+    const bytes = new Uint8Array(1 + 20 + 32 + 32);
+    bytes[0] = 0xff;
+    bytes.set(Uint8Array.fromHex(sender.slice(2)), 1);
+    write(bytes.buffer, salt, 1 + 20, 0x20);
+    bytes.set(keccak256(new Uint8Array(code)), 1 + 20 + 0x20);
+    return `0x${keccak256(bytes).slice(12).toHex()}`;
+}
+function write(destination, value, offset, size) {
+    const array = new Uint8Array(destination);
+    for (let i = offset + size - 1; i >= offset; i--, value >>= 8n)
+        array[i] = Number(value & 0xffn);
+}
+export { byteSliceToBigInt_be, numberToHex, F, keccak256, pop, peek, copy, memoryExpand, getStateValue, write, createContext, deriveAddress, deriveAddress2 };

package/dist/machine.d.ts

@@ -0,0 +1,40 @@
+import type { Context } from "./types.js";
+declare let traceHelper: {
+    instruction: null | number;
+    pc: null | number;
+    op: null | string;
+    gas: null | number;
+    depth: null | number;
+    stack: null | Array<string>;
+    returnData: null | string;
+    memoryWords: null | Array<string>;
+    storage: null | {
+        [key: string]: string;
+    };
+    stop: null | boolean;
+};
+declare function buildTraceObject(context: Context): {
+    pc: number;
+    op: string;
+    gas: number;
+    gasCost: number;
+    depth: number;
+    stack: Array<string>;
+    returnData?: string;
+    memory?: Array<string>;
+    storage?: {
+        [key: string]: string;
+    };
+    refund?: number;
+};
+declare const traceObjects: Array<ReturnType<typeof buildTraceObject>>;
+declare const SingleContextMachine: new (context: Context) => {
+    context: Context;
+    continue(): boolean;
+    step(): void;
+    initialize(): void;
+    run(): void;
+    initializeAndRun(): void;
+};
+export { SingleContextMachine, traceObjects, traceHelper };
+//# sourceMappingURL=machine.d.ts.map

package/dist/machine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"machine.d.ts","sourceRoot":"","sources":["../src/machine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAY,MAAM,YAAY,CAAC;AA2EpD,QAAA,IAAI,WAAW,EAAC;IACZ,WAAW,EAAC,IAAI,GAAC,MAAM,CAAC;IACxB,EAAE,EAAC,IAAI,GAAC,MAAM,CAAC;IACf,EAAE,EAAC,IAAI,GAAC,MAAM,CAAC;IACf,GAAG,EAAC,IAAI,GAAC,MAAM,CAAA;IACf,KAAK,EAAC,IAAI,GAAC,MAAM,CAAC;IAClB,KAAK,EAAC,IAAI,GAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACzB,UAAU,EAAC,IAAI,GAAC,MAAM,CAAC;IACvB,WAAW,EAAC,IAAI,GAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAC/B,OAAO,EAAC,IAAI,GAAC;QAAE,CAAC,GAAG,EAAC,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IACtC,IAAI,EAAC,IAAI,GAAC,OAAO,CAAA;CACmH,CAAC;AAmDzI,iBAAS,gBAAgB,CAAC,OAAO,EAAC,OAAO;QAK9B,MAAM;QACN,MAAM;SACL,MAAM;aACF,MAAM;WACR,MAAM;WACN,KAAK,CAAC,MAAM,CAAC;iBACP,MAAM;aACV,KAAK,CAAC,MAAM,CAAC;cACZ;QAAE,CAAC,GAAG,EAAC,MAAM,GAAG,MAAM,CAAA;KAAE;aACzB,MAAM;EAcrB;AAED,QAAA,MAAM,YAAY,EAAC,KAAK,CAAC,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAM,CAAA;AA6BlE,QAAA,MAAM,oBAAoB;;;;;;;CAOzB,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,YAAY,EAAE,WAAW,EAAE,CAAC"}

package/dist/machine.js

@@ -0,0 +1,166 @@
+import { createMachine } from "@bradthomasbrown/machine/6873f5";
+import { byteSliceToBigInt_be, numberToHex, peek, copy, getStateValue, deriveAddress } from "./lib.js";
+import * as opset from "./opsets/9db704/opset.js";
+function continuePredicate(context) {
+    // if revert is known (true or false, not null), don't continue
+    if (context.reverted !== null)
+        return false;
+    // if there is no code, don't continue
+    if (context.code === null)
+        return false;
+    // if the program counter is beyond the code length, don't continue
+    if (context.pc >= context.code.byteLength)
+        return false;
+    // if there is an incomplete subcontext, don't continue
+    if (context.subcontext !== null && context.subcontext.reverted === null)
+        return false;
+    // otherwise, continue
+    return true;
+}
+function parseInstruction(context) {
+    const codeArray = new Uint8Array(context.code);
+    const instruction = codeArray[context.pc];
+    // PUSH handling
+    if (instruction >= 0x5f && instruction < 0x80) {
+        const variant = instruction - 0x5f;
+        const width = variant + 1;
+        const literal = byteSliceToBigInt_be(codeArray, context.pc + 1, variant, true);
+        return [0x60, { variant, width, literal }];
+    }
+    // DUP handling
+    if (instruction >= 0x80 && instruction < 0x90) {
+        const variant = instruction - 0x80;
+        const width = 1;
+        const literal = null;
+        return [0x80, { variant, width, literal }];
+    }
+    // SWAP handling
+    if (instruction >= 0x90 && instruction < 0xa0) {
+        const variant = instruction - 0x90;
+        const width = 1;
+        const literal = null;
+        return [0x90, { variant, width, literal }];
+    }
+    // LOG handling
+    if (instruction >= 0xa0 && instruction < 0xa5) {
+        const variant = instruction - 0xa0;
+        const width = 1;
+        const literal = null;
+        return [0xa0, { variant, width, literal }];
+    }
+    // default handling
+    const variant = null;
+    const width = 1;
+    const literal = null;
+    return [instruction, { variant, width, literal }];
+}
+const debug = true;
+const identifierToString = new Map();
+for (const opcode of Object.values(opset))
+    identifierToString.set(opcode.identifier, (instruction) => opcode.instructionToString(instruction));
+let traceHelper = { instruction: null, gas: null, pc: null, op: null, depth: null, stack: null, returnData: null, memoryWords: null, storage: null, stop: null };
+// NOTE: the entirety of this is just debug-related as of now
+function preExecute(context) {
+    if (debug === false)
+        return;
+    const instruction = new Uint8Array(context.code)[context.pc];
+    let identifier = instruction;
+    if (instruction >= 0x5f && instruction < 0x80)
+        identifier = 0x60; // PUSH
+    if (instruction >= 0x80 && instruction < 0x90)
+        identifier = 0x80; // DUP
+    if (instruction >= 0x90 && instruction < 0xa0)
+        identifier = 0x90; // SWAP
+    if (instruction >= 0xa0 && instruction < 0xa5)
+        identifier = 0xa0; // LOG
+    if (identifierToString.has(identifier) === false)
+        throw new Error(`missing identiferToString.get(${numberToHex(identifier, 2)})`);
+    traceHelper.instruction = instruction;
+    traceHelper.pc = context.pc;
+    traceHelper.op = identifierToString.get(identifier)(instruction);
+    traceHelper.gas = Number(context.gas);
+    traceHelper.depth = context.depth;
+    traceHelper.stack = context.stack.map(value => `0x${value.toString(16)}`);
+    if (context.subcontext !== null && context.subcontext.to !== null && context.subcontext.returndata !== null)
+        traceHelper.returnData = `0x${new Uint8Array(context.subcontext.returndata).toHex()}`;
+    else
+        traceHelper.returnData = null;
+    if (context.memory !== null) {
+        traceHelper.memoryWords = [];
+        for (let i = 0; i < context.memoryWords << 5; i += 0x20) {
+            const wordBytes = new ArrayBuffer(32);
+            copy(wordBytes, context.memory, 0, i, 0x20, true);
+            traceHelper.memoryWords.push(new Uint8Array(wordBytes).toHex());
+        }
+    }
+    if (instruction == 0x54) {
+        const [key] = peek(context.stack, 1);
+        const value = getStateValue(context.states, null, "storage", [context.address, key]) ?? 0n;
+        if (traceHelper.storage === null)
+            traceHelper.storage = {};
+        traceHelper.storage[numberToHex(key, 64)] = numberToHex(value, 64);
+    }
+    else if (instruction == 0x55) {
+        const [key, value] = peek(context.stack, 2);
+        if (traceHelper.storage === null)
+            traceHelper.storage = {};
+        traceHelper.storage[numberToHex(key, 64)] = numberToHex(value, 64);
+    }
+    traceHelper.stop = instruction == 0x00;
+}
+const dispatch = new Map();
+for (const opcode of Object.values(opset))
+    dispatch.set(opcode.identifier, opcode.executor);
+function getExecutor(identifier) {
+    if (dispatch.has(identifier))
+        return dispatch.get(identifier);
+    throw new Error(`no executor found for identifier ${numberToHex(identifier, 2)}`);
+}
+function buildTraceObject(context) {
+    let gasCost = null;
+    if ([0xf0, 0xf5].includes(traceHelper.instruction))
+        gasCost = traceHelper.gas - Number(context.gas) - Number(context.L);
+    else
+        gasCost = traceHelper.gas - Number(context.gas);
+    const traceObject = {
+        pc: traceHelper.pc,
+        op: traceHelper.op,
+        gas: traceHelper.gas,
+        gasCost,
+        depth: traceHelper.depth,
+        stack: traceHelper.stack
+    };
+    if (traceHelper.returnData !== null)
+        traceObject.returnData = traceHelper.returnData;
+    if (traceHelper.memoryWords !== null)
+        traceObject.memory = traceHelper.memoryWords;
+    if (traceHelper.op == "SLOAD" || traceHelper.op == "SSTORE")
+        traceObject.storage = traceHelper.storage;
+    if (context.refund != 0n)
+        traceObject.refund = Number(context.refund);
+    return traceObject;
+}
+const traceObjects = [];
+function postExecute(context) {
+    if (debug === true)
+        traceObjects.push(buildTraceObject(context));
+    if (context.pc < context.code.byteLength)
+        return;
+    if (context.reverted !== null)
+        return;
+    // if program counter is past code and we haven't yet decided on reverted
+    // reverted is false
+    // this detects end of execution if no STOP, REVERT, RETURN, etc. was provided in code
+    context.reverted = false;
+}
+function initialize(context) {
+    if (context.address === null && context.to !== null)
+        context.address = context.to;
+    // for EoA deployments, address is null, but we'll need it in execution
+    if (context.address === null && context.to === null) {
+        context.address = deriveAddress(context);
+        context.code = context.calldata;
+    }
+}
+const SingleContextMachine = createMachine(continuePredicate, parseInstruction, preExecute, getExecutor, postExecute, initialize);
+export { SingleContextMachine, traceObjects, traceHelper };

package/dist/opsets/9db704/opcodes/ADD.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from "../../../types.js";
+declare const _default: {
+    identifier: number;
+    executor(context: Context): void;
+    instructionToString(): string;
+};
+export default _default;
+//# sourceMappingURL=ADD.d.ts.map

package/dist/opsets/9db704/opcodes/ADD.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ADD.d.ts","sourceRoot":"","sources":["../../../../src/opsets/9db704/opcodes/ADD.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;;;sBAO5B,OAAO;;;AAJ5B,wBAeE"}

package/dist/opsets/9db704/opcodes/ADD.js

@@ -0,0 +1,13 @@
+import { pop, F } from "../../../lib.js";
+export default {
+    identifier: 0x01,
+    executor(context) {
+        const [a, b] = pop(context.stack, 2);
+        context.stack.push(F.add(a, b));
+        context.gas -= 3n;
+        context.pc++;
+    },
+    instructionToString() {
+        return "ADD";
+    }
+};

package/dist/opsets/9db704/opcodes/ADDRESS.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from "../../../types.js";
+declare const _default: {
+    identifier: number;
+    executor(context: Context): void;
+    instructionToString(): string;
+};
+export default _default;
+//# sourceMappingURL=ADDRESS.d.ts.map

package/dist/opsets/9db704/opcodes/ADDRESS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ADDRESS.d.ts","sourceRoot":"","sources":["../../../../src/opsets/9db704/opcodes/ADDRESS.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;;;sBAM5B,OAAO;;;AAJ5B,wBAcE"}

package/dist/opsets/9db704/opcodes/ADDRESS.js

@@ -0,0 +1,11 @@
+export default {
+    identifier: 0x30,
+    executor(context) {
+        context.stack.push(BigInt(context.address));
+        context.gas -= 2n;
+        context.pc++;
+    },
+    instructionToString() {
+        return "ADDRESS";
+    }
+};

package/dist/opsets/9db704/opcodes/AND.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from "../../../types.js";
+declare const _default: {
+    identifier: number;
+    executor(context: Context): void;
+    instructionToString(): string;
+};
+export default _default;
+//# sourceMappingURL=AND.d.ts.map

package/dist/opsets/9db704/opcodes/AND.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AND.d.ts","sourceRoot":"","sources":["../../../../src/opsets/9db704/opcodes/AND.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;;;sBAO5B,OAAO;;;AAJ5B,wBAeE"}

package/dist/opsets/9db704/opcodes/AND.js

@@ -0,0 +1,13 @@
+import { pop } from "../../../lib.js";
+export default {
+    identifier: 0x16,
+    executor(context) {
+        const [a, b] = pop(context.stack, 2);
+        context.stack.push(a & b);
+        context.gas -= 3n;
+        context.pc++;
+    },
+    instructionToString() {
+        return "AND";
+    }
+};

package/dist/opsets/9db704/opcodes/BYTE.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from "../../../types.js";
+declare const _default: {
+    identifier: number;
+    executor(context: Context): void;
+    instructionToString(): string;
+};
+export default _default;
+//# sourceMappingURL=BYTE.d.ts.map

package/dist/opsets/9db704/opcodes/BYTE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BYTE.d.ts","sourceRoot":"","sources":["../../../../src/opsets/9db704/opcodes/BYTE.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;;;sBAO5B,OAAO;;;AAJ5B,wBAeE"}

package/dist/opsets/9db704/opcodes/BYTE.js

@@ -0,0 +1,13 @@
+import { pop } from "../../../lib.js";
+export default {
+    identifier: 0x1a,
+    executor(context) {
+        const [i, x] = pop(context.stack, 2);
+        context.stack.push(x >> (0x1fn - i << 3n) & 0xffn);
+        context.gas -= 3n;
+        context.pc++;
+    },
+    instructionToString() {
+        return "BYTE";
+    }
+};

package/dist/opsets/9db704/opcodes/CALLDATACOPY.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from "../../../types.js";
+declare const _default: {
+    identifier: number;
+    executor(context: Context): void;
+    instructionToString(): string;
+};
+export default _default;
+//# sourceMappingURL=CALLDATACOPY.d.ts.map

package/dist/opsets/9db704/opcodes/CALLDATACOPY.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CALLDATACOPY.d.ts","sourceRoot":"","sources":["../../../../src/opsets/9db704/opcodes/CALLDATACOPY.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;;;sBAO5B,OAAO;;;AAJ5B,wBAgBE"}

package/dist/opsets/9db704/opcodes/CALLDATACOPY.js

@@ -0,0 +1,14 @@
+import { pop, copy, memoryExpand } from "../../../lib.js";
+export default {
+    identifier: 0x37,
+    executor(context) {
+        const [destOffset, offset, size] = pop(context.stack, 3);
+        context.gas -= 3n + 3n * (size + 0x1fn >> 5n);
+        memoryExpand(context, Number(destOffset) + Number(size));
+        copy(context.memory, context.calldata, Number(destOffset), Number(offset), Number(size), true);
+        context.pc++;
+    },
+    instructionToString() {
+        return "CALLDATACOPY";
+    }
+};

package/dist/opsets/9db704/opcodes/CALLDATALOAD.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from "../../../types.js";
+declare const _default: {
+    identifier: number;
+    executor(context: Context): void;
+    instructionToString(): string;
+};
+export default _default;
+//# sourceMappingURL=CALLDATALOAD.d.ts.map

package/dist/opsets/9db704/opcodes/CALLDATALOAD.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CALLDATALOAD.d.ts","sourceRoot":"","sources":["../../../../src/opsets/9db704/opcodes/CALLDATALOAD.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;;;sBAO5B,OAAO;;;AAJ5B,wBAmBE"}

package/dist/opsets/9db704/opcodes/CALLDATALOAD.js

@@ -0,0 +1,17 @@
+import { byteSliceToBigInt_be, pop } from "../../../lib.js";
+export default {
+    identifier: 0x35,
+    executor(context) {
+        const [i] = pop(context.stack, 1);
+        context.gas -= 3n;
+        if (context.calldata === null) {
+            context.stack.push(0n);
+            return;
+        }
+        context.stack.push(byteSliceToBigInt_be(new Uint8Array(context.calldata), Number(i), 0x20, true));
+        context.pc++;
+    },
+    instructionToString() {
+        return "CALLDATALOAD";
+    }
+};

package/dist/opsets/9db704/opcodes/CALLDATASIZE.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from "../../../types.js";
+declare const _default: {
+    identifier: number;
+    executor(context: Context): void;
+    instructionToString(): string;
+};
+export default _default;
+//# sourceMappingURL=CALLDATASIZE.d.ts.map

package/dist/opsets/9db704/opcodes/CALLDATASIZE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CALLDATASIZE.d.ts","sourceRoot":"","sources":["../../../../src/opsets/9db704/opcodes/CALLDATASIZE.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;;;sBAM5B,OAAO;;;AAJ5B,wBAcE"}