Cryo Explorer Ethereum Mainnet

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

abstract contract PreventTampering {
    modifier revertOnCodeHashChange() {
        bytes32 hashBefore;
        assembly {
            hashBefore := extcodehash(address())
        }
        _;
        bytes32 hashPostExecution;
        assembly {
            hashPostExecution := extcodehash(address())
        }
        require(hashPostExecution == hashBefore, "PreventTampering: Code has changed");
    }
}

// SPDX-License-Identifier: BlueOak-1.0.0
pragma solidity 0.8.26;
import { DataTag } from "./weiroll/CommandBuilder.sol";
import { PreventTampering } from "./PreventTampering.sol";

import { VM, VMOutput, VMState } from "./weiroll/VM.sol";

/** Unpermissioned VM implementation:
  * Do not leave funds here as anyone can grab them.
  */ 
contract Runtime is VM, PreventTampering {
    fallback() external payable {
        fallbackHook();
    }

    function execute(
        bytes32[] memory commands,
        bytes[] memory state,
        uint256 flags
    ) revertOnCodeHashChange()
        public
        payable
        returns (VMOutput memory out)
    {

        VMState memory vmstate = VMState(
            new DataTag[](state.length),
            state,
            flags
        );
        
        out = _execute(
            vmstate,
            commands
        );
    }

    receive() external payable {}
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.26;

import { VMState, DataTag } from "./VMState.sol";

library CommandBuilder {
    uint256 constant IDX_VARIABLE_LENGTH = 0x80;
    uint256 constant IDX_VALUE_MASK = 0x7f;
    uint256 constant IDX_END_OF_ARGS = 0xff;
    uint256 constant IDX_USE_STATE = 0xfe;
    
    function buildInputs(
        VMState memory state,
        bytes4 selector,
        bytes32 indices
    ) internal view returns (bytes memory ret) {
        uint256 count; // Number of bytes in whole ABI encoded message
        uint256 free; // Pointer to first free byte in tail part of message
        bytes memory stateData; // Optionally encode the current state if the call requires it

        uint256 idx;

        // Determine the length of the encoded data
        for (uint256 i; i < 32;) {
            idx = uint8(indices[i]);

            if (idx == IDX_END_OF_ARGS) break;

            if (state.meta[idx & IDX_VALUE_MASK] == DataTag.TUPLE) {
                uint256 len = state.data[idx & IDX_VALUE_MASK].length;
                if (idx & IDX_VARIABLE_LENGTH != 0) {
                    count += len + 32;
                    free += 32;
                    i++;
                } else {
                    count += len;
                    free += len;
                    i++;
                }
                continue;
            }

            if (idx & IDX_VARIABLE_LENGTH != 0) {
                if (idx == IDX_USE_STATE) {
                    if (stateData.length == 0) {
                        stateData = abi.encode(state);
                    }
                    count += stateData.length;
                } else {
                    // Add the size of the value, rounded up to the next word boundary, plus space for pointer and length
                    uint256 arglen = state.data[idx & IDX_VALUE_MASK].length;
                    require(
                        arglen % 32 == 0,
                        "Dynamic state variables must be a multiple of 32 bytes"
                    );
                    count += arglen + 32;
                }
            } else {
                count += state.data[idx & IDX_VALUE_MASK].length;
            }
            free += 32;
            i++;
        }


        // Encode it
        ret = new bytes(count + 4);
        assembly {
            mstore(add(ret, 32), selector)
        }
        count = 0;
        for (uint256 i; i < 32;) {
            idx = uint8(indices[i]);
            
            if (idx == IDX_END_OF_ARGS) break;
            if (state.meta[idx & IDX_VALUE_MASK] == DataTag.TUPLE) {
                if (idx & IDX_VARIABLE_LENGTH != 0) {
                    uint256 len = state.data[idx & IDX_VALUE_MASK].length;
                    // Write the pointer to the data
                    assembly {
                        mstore(add(add(ret, 36), count), free)
                    }
                    memcpy(
                        state.data[idx & IDX_VALUE_MASK],
                        0,
                        ret,
                        free + 4,
                        len
                    );
                    free += len;
                    count += 32;
                    i++;
                } else {
                    uint256 len = state.data[idx & IDX_VALUE_MASK].length;

                    memcpy(
                        state.data[idx & IDX_VALUE_MASK],
                        0,
                        ret,
                        count + 4,
                        len
                    );
                    i++;
                    count += len;
                }
                continue;
            }

            if (idx & IDX_VARIABLE_LENGTH != 0) {
                if (idx == IDX_USE_STATE) {
                    assembly {
                        mstore(add(add(ret, 36), count), free)
                    }
                    memcpy(stateData, 32, ret, free + 4, stateData.length - 32);
                    free += stateData.length - 32;
                } else {

                    uint256 arglen = state.data[idx & IDX_VALUE_MASK].length;
                    
                    // Variable length data; put a pointer in the slot and write the data at the end
                    assembly {
                        mstore(add(add(ret, 36), count), free)
                    }
                    
                    
                    memcpy(
                        state.data[idx & IDX_VALUE_MASK],
                        0,
                        ret,
                        free + 4,
                        arglen
                    );
                    free += arglen;
                    
                }
            } else {
                // Fixed length data; write it directly
                bytes memory buff = state.data[idx & IDX_VALUE_MASK];
                assembly {
                    mstore(add(add(ret, 36), count), mload(add(buff, 32)))
                }
            }
            count += 32;
            i++;
        }
    }

    function writeOutputs(
        VMState memory state,
        bytes1 index,
        bytes memory output
    ) internal pure returns (VMState memory) {
        uint256 idx = uint8(index);
        if (idx == IDX_END_OF_ARGS) return state;

        if (idx & IDX_VARIABLE_LENGTH != 0) {
            if (idx == IDX_USE_STATE) {
                state = abi.decode(output, (VMState));
            } else {
                // Check the first field is 0x20 (because we have only a single return value)
                uint256 argptr;
                assembly {
                    argptr := mload(add(output, 32))
                }
                require(
                    argptr == 32,
                    "Only one return value permitted (variable)"
                );

                bytes[] memory data = state.data;

                assembly {
                    // Overwrite the first word of the return data with the length - 32
                    mstore(add(output, 32), sub(mload(output), 32))
                    // Insert a pointer to the return data, starting at the second word, into state
                    mstore(
                        add(add(data, 32), mul(and(idx, IDX_VALUE_MASK), 32)),
                        add(output, 32)
                    )
                }
            }
        } else {
            // Single word

            if (output.length > 32) {
                bytes memory newOut = new bytes(32);
                assembly {
                    mstore(add(newOut, 32), mload(add(output, 32)))
                }
                state.data[idx & IDX_VALUE_MASK] = newOut;
            } else {
                state.data[idx & IDX_VALUE_MASK] = output;
            }
            
            
        }

        state.meta[idx & IDX_VALUE_MASK] = DataTag.DEFAULT;

        return state;
    }

    function writeTuple(
        VMState memory state,
        bytes1 index,
        bytes memory output
    ) internal view {
        uint256 idx = uint256(uint8(index));
        if (idx == IDX_END_OF_ARGS) return;

        bytes memory entry = state.data[idx & IDX_VALUE_MASK] = new bytes(output.length + 32);
        state.meta[idx & IDX_VALUE_MASK] = DataTag.TUPLE;
        memcpy(output, 0, entry, 32, output.length);
        assembly {
            let l := mload(output)
            mstore(add(entry, 32), l)
        }
    }

    function memcpy(
        bytes memory src,
        uint256 srcidx,
        bytes memory dest,
        uint256 destidx,
        uint256 len
    ) internal view {
        assembly {
            pop(
                staticcall(
                    gas(),
                    4,
                    add(add(src, 32), srcidx),
                    len,
                    add(add(dest, 32), destidx),
                    len
                )
            )
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

library MathOpCodes {
    function binaryOp(
        uint256 op,
        uint256 a,
        uint256 b
    ) internal pure returns (uint256 c) {
        assembly {
            switch and(op, 0xff)
            case 0 { // c = a + b
                c := add(a, b) 
            }
            case 1 { // c = a - b
                c := sub(a, b)
            }
            case 2 { // c = a * b
                c := mul(a, b)
            }
            case 3 { // c = a / b
                c := div(a, b)
            }
            case 4 { // c = a ** b
                c := exp(a, b)
            }
            case 5 { // c = a == b
                c := eq(a, b)
            }
            case 6 { // c = a < b
                c := lt(a, b)
            }
            case 7 { // c = a > b
                c := gt(a, b)
            }
            case 8 { // c = a <= b
                c := iszero(gt(a, b))
            }
            case 9 { // c = a >= b
                c := iszero(lt(a, b))
            }
            case 10 { // c = a != b
                c := iszero(eq(a, b))
            }
            case 11 { // c = a % b
                c := mod(a, b)
            }
            case 12 { // c = a & b
                c := and(a, b)
            }
            case 13 { // c = a | b
                c := or(a, b)
            }
            case 14 { // c = a ^ b
                c := xor(a, b)
            }
            case 15 { // c = a << b
                c := shl(b, a)
            }
            case 16 { // c = a >> b
                c := shr(b, a)
            }
            case 17 { // c = a && b
                c := and(iszero(iszero(a)), iszero(iszero(b)))
            }
            case 18 { // c = a || b
                c := or(iszero(iszero(a)), iszero(iszero(b)))
            }
            // case 17 { // (x + y) % m
            //     c := addmod(a, b, mload(add(din, 32)))
            // }
            // case 18 { // c = x * y) % m 
            //     c := mulmod(a, b, mload(add(din, 32)))
            // }
            // op | 32 for signed sdiv, smod, slt, sgt, sar

            // signed ops
            case 35 {
                c := sdiv(a, b)
            }
            case 38 {
                c := sgt(a, b)
            }
            case 39 {
                c := sgt(a, b)
            }
            case 40 { // c = a <= b
                c := iszero(sgt(a, b))
            }
            case 41 { // c = a >= b
                c := iszero(slt(a, b))
            }
            case 43 {
                c := smod(a, b)
            }
            default {
                revert(0, 0)
            }
        }
    }

    function unaryOp(
        uint256 op,
        uint256 a
    ) internal pure returns (uint256 b) {
        assembly {
            switch and(op, 0xff)
            case 0 { // -a
                b := sub(0, a)
            }
            case 1 { // ~a
                b := not(a)
            }
            case 2 { // !a
                b := iszero(a)
            }
            default {
                revert(0, 0)
            }
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import { VMState } from "./VMState.sol";
import { CommandBuilder } from "./CommandBuilder.sol";

library Memory {
    using Memory for VMState;
    using CommandBuilder for VMState;

    function readBuffer(
        VMState memory state,
        uint256 idx
    ) internal pure returns (bytes memory out) {
        out = state.data[idx];
    }
    function readValue(
        VMState memory state, uint256 idx
    ) internal pure returns (bytes32 out) {
        bytes memory data = state.data[idx];
        assembly {
            out := mload(add(data, 32))
        }
    }

    function getBufferForSlot(VMState memory state, uint256 idx, uint256 minLength) internal pure returns (bytes memory out) {
        out = state.data[idx];
        if (out.length < minLength) {
            out = new bytes(minLength);
            state.data[idx] = out;
        }
    }
    function readUint256(
        VMState memory state, uint256 idx
    ) internal pure returns (uint256 out) {
       out = uint256(state.readValue(idx));
    }
    function followPath(bytes memory root, bytes32 path) internal pure returns (
        uint256 rootOffset,
        uint256 size,
        uint256 entries
    ) {
        unchecked{
            rootOffset = 32;
            size = 32;
            entries = 0;
            for(uint256 i; i < 32;) {
                if (path[i] == 0xff) break;
                uint256 elementOffset = uint256(uint8(path[i])) * 32;
                uint256 s = uint256(uint8(path[i + 1]));
                if (s == 0xff) { // Read size of array
                    assembly {
                        entries := mload(add(root, rootOffset))
                    }
                    rootOffset += 32;
                } else if (s == 0xfe) { // Read length of array and set size to 1
                    assembly {
                        entries := mload(add(root, rootOffset))
                    }
                    rootOffset += 32;
                    size = 1;
                    break;
                } else if (s == 0xfd) { // Discard length of array
                    rootOffset += 32;
                } else if ((s & 128) != 0) {
                    rootOffset = rootOffset + elementOffset;
                    size = (s & 127) * 32;
                } else if (s == 0) {
                    uint256 elementIndex = rootOffset + elementOffset;
                    assembly {
                        elementOffset := mload(add(root, elementIndex))
                    }
                    rootOffset += elementOffset;
                    size = 32;
                } else {
                    elementOffset *= s;
                    rootOffset = rootOffset + elementOffset;
                    size = s * 32;
                }
                i += 2;
            }
            return ( rootOffset, size, entries );
        }
    }
    
    function opCalldataRead(
        VMState memory state,
        bytes32 path,
        uint256 outf
    ) internal pure returns (bytes memory) {
        unchecked{
            uint256 rootOffset = 4;
            uint256 size = 32;
            uint256 entries = 0;
            for(uint256 i; i < 32;) {
                if (path[i] == 0xff) break;
                uint256 elementOffset = uint256(uint8(path[i])) * 32;
                uint256 s = uint256(uint8(path[i + 1]));

                // console.log("root == %s ; element = %s ; s = %s", rootOffset, elementOffset, s);
                // Load array size if 0xff
                if (s == 0xff) { // Read size of array
                    assembly {
                        entries := calldataload(rootOffset)
                    }
                    rootOffset += 32;
                    size = elementOffset;
                } else if (s == 0xfe) { // Read length of array and set size to 1
                    assembly {
                        entries := calldataload(rootOffset)
                    }
                    size = 1;
                    rootOffset += 32;
                    break;
                } else if (s == 0xfd) { // Discard length of array
                    rootOffset += 32;
                } else if ((s & 128) != 0) {
                    rootOffset = rootOffset + elementOffset;
                    size = (s & 127) * 32;
                } else if (s == 0) {
                    uint256 elementIndex = rootOffset + elementOffset;
                    // console.log("Reading from %s", elementIndex);
                    assembly {
                        elementOffset := calldataload(elementIndex)
                    }
                    // console.log("read offset %s", elementOffset);
                    rootOffset += elementOffset;
                    // console.log("new root %s", rootOffset);
                    size = 32;
                } else {
                    elementOffset *= s;
                    rootOffset = rootOffset + elementOffset;
                    size = s * 32;
                }
                i += 2;
            }
            if (size == 32 && entries == 0) {
                
                bytes memory out = state.data[outf & CommandBuilder.IDX_VALUE_MASK];
                assembly {
                    mstore(add(out,32), calldataload(rootOffset))
                    mstore(out, 32)
                }
                return out;
            } else {
                size = entries == 0 ? size : entries * size + 32;
                bytes memory out;
                uint256 j = 32;

                if (outf & CommandBuilder.IDX_VARIABLE_LENGTH != 0) {
                    size += 32;
                    out = new bytes(size);
                    assembly {
                        mstore(add(out, j), 32)
                    }
                    j += 32;
                } else {
                    out = new bytes(size);
                }
                
                if (entries != 0) {
                    assembly {
                        mstore(add(out, j), entries)
                    }
                    j += 32;
                }

                for (; j <= size;) {
                    assembly {
                        mstore(add(out, j), calldataload(rootOffset))
                        j := add(j, 32)
                        rootOffset := add(rootOffset, 32)
                    }
                }
                return out;
            }
        }
    }



    function makeTuple(
        VMState memory state,
        bytes32 indices
    ) internal view returns (bytes memory) {
        unchecked{
            bytes memory o = CommandBuilder.buildInputs(
                state,
                bytes4(0),
                indices
            );

            bytes memory out = new bytes(o.length - 4);
            
            CommandBuilder.memcpy(
                o,
                4,
                out,
                0,
                out.length
            );
            return out;
        }
    }


    function writeWord(VMState memory state, uint256 slot, uint256 value) internal pure {
        if (slot == 127) {
            return;
        }
        bytes memory buff = state.data[slot];
        assembly {
            mstore(add(buff, 32), value)
        }
    }

    function opMStore(
        VMState memory state,
        bytes32 indices,
        uint256 outf
    ) internal pure returns (bytes memory) {
        if (outf == 127) {
            return bytes("");
        }
        unchecked {
            bytes32 path = state.readValue(
                uint8(indices[0]) & CommandBuilder.IDX_VALUE_MASK
            );
            bytes memory root = state.readBuffer(
                uint8(indices[1]) & CommandBuilder.IDX_VALUE_MASK
            );
            bytes32 value = state.readValue(
                uint8(indices[2]) & CommandBuilder.IDX_VALUE_MASK
            );
            (uint256 rootOffset,,) = followPath(root, path);

            rootOffset += uint8(path[31]) * 32;
            assembly {
                mstore(add(root, rootOffset), value)
            }
             
            state.data[outf] = root;
            state.meta[outf] = state.meta[uint8(indices[1]) & CommandBuilder.IDX_VALUE_MASK];
            // console.logBytes(root);
            return root;
        }
    }

    function followPathRead(
        bytes memory root,
        bytes32 path
    ) internal view returns (bytes memory out) {
        (uint256 rootOffset, uint256 size, uint256 entries) = followPath(root, path);

        if (size == 32 && entries == 0) {
            assembly {
                rootOffset := mload(add(root, rootOffset))
            }
            bytes memory output = abi.encode(rootOffset);
            return output;
        } else {
            bytes memory output = new bytes(entries == 0 ? size + 32 : 32 + entries * size);
            bytes memory source = root;
            rootOffset -= 32;
            if (entries > 0) {
                rootOffset -= 32;
            }
            assembly {
                source := add(root, rootOffset)
            }

            CommandBuilder.memcpy(source, 0, output, 0, output.length);
            
            return output;
        }
    }

    function readMemory(
        VMState memory state,
        bytes32 indices
    ) internal view returns (bytes memory) {
        unchecked{
            bytes32 path = state.readValue(
                uint8(indices[0]) & CommandBuilder.IDX_VALUE_MASK
            );
            bytes memory root = state.readBuffer(
                uint8(indices[1]) & CommandBuilder.IDX_VALUE_MASK
            );

            return followPathRead(root, path);
        }
    }

}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

library TransientStorage {
    function tread(uint256 key) internal view returns (uint256 value) {
        assembly {
            value := tload(key)
        }
    }
    function twrite(uint256 key, uint256 value) internal {
        assembly {
            tstore(key, value)
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.26;
import { VMState, VMOutput, DataTag } from "./VMState.sol";

import { CommandBuilder } from "./CommandBuilder.sol";
import { Memory } from "./Memory.sol";
import { MathOpCodes } from "./MathOpCodes.sol";
import { TransientStorage } from "./TransientStorage.sol";

event VMException(uint256 cmdIndex, bytes msg);
event VMCall(uint256 cmdIndex, bytes32 cmd, address to, bytes data, uint256 callType);
event VMCallReturn(uint256 cmdIndex, bytes32 cmd, bool success, bytes data);
event VMInternalCall(uint256 cmdIndex, bytes32 cmd);
event VMReturn(bool success, bytes data);

event LogStatement(
    uint256 indexed statementId,
    bytes encoded
);

error ExecutionFailed(
    uint256 command_index,
    address target,
    string message
);



library VMOpcodes {
    using CommandBuilder for VMState;
    using Memory for VMState;
    using VMOpcodes for VMState;

    // Transient storage slots used by the VM
    uint256 internal constant EXPECTED_CALLBACK_SLOT = 0;
    uint256 internal constant CALLDATA_DATA_SLOT = 1;


    function getExpectedCallbackAddress() internal returns (address) {
        return address(uint160(uint256(TransientStorage.tread(EXPECTED_CALLBACK_SLOT))));
    }
    function getCalldataOffset() internal returns (uint256) {
        return uint256(TransientStorage.tread(CALLDATA_DATA_SLOT));
    }


    uint256 constant FLAG_CT_DELEGATECALL = 0x00;
    uint256 constant FLAG_CT_CALL = 0x01;
    uint256 constant FLAG_CT_STATICCALL = 0x02;
    uint256 constant FLAG_CT_VALUECALL = 0x03;
    uint256 constant FLAG_CT_MASK = 0x03;
    uint256 constant FLAG_EXTENDED_COMMAND = 0x80;
    uint256 constant FLAG_TUPLE_RETURN = 0x40;
    uint256 constant FLAG_INTERNAL_CMD = 0x20;
    uint256 constant SHORT_COMMAND_FILL = 0x000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;

    uint256 constant FLAG_INTERPRET = 0x1;

    uint256 constant TX_FLAGS_MASK = 0xff;
    uint256 constant TX_LEVEL_MASK = 0xff00;
    

    function opEncodeCallback(
        VMState memory vmstate,
        bytes32 indices,
        uint256 outputSlot
    ) internal {
        TransientStorage.twrite(EXPECTED_CALLBACK_SLOT, vmstate.readUint256(uint8(indices[2])));
        TransientStorage.twrite(CALLDATA_DATA_SLOT, vmstate.readUint256(uint8(indices[3])));
        bytes memory rawBuff = vmstate.data[
            uint8(indices[0]) & CommandBuilder.IDX_VALUE_MASK
        ];

        bytes32[] memory commands;
        assembly {
            commands := add(rawBuff, 32)
        }
        vmstate.meta[outputSlot] = DataTag.DEFAULT;
        
        
        uint256 newFlags = ((1 + (vmstate.flags >> 8)) << 8) | (vmstate.flags & TX_FLAGS_MASK);
        bytes memory encoded = abi.encode(0, newFlags, commands, vmstate.meta, vmstate.data);
        assembly {
            mstore(add(encoded, 32), sub(mload(encoded), 32))

            // adjust offsets as we inserted a 32 byte length field
            mstore(add(encoded, 96), sub(mload(add(encoded, 96)), 32))
            mstore(add(encoded, 128), sub(mload(add(encoded, 128)), 32))
            mstore(add(encoded, 160), sub(mload(add(encoded, 160)), 32))
        }
        vmstate.data[outputSlot] = encoded;
    }
    function opAssert(
        VMState memory state,
        bytes32 indices
    ) internal pure returns (bool success, bytes memory outdata) {
        if (state.readUint256(uint8(indices[0]) & CommandBuilder.IDX_VALUE_MASK) == 1) {
            return (true, "");
        }

        string memory data = indices[1] != 0xff ? string(state.readBuffer(
            uint8(indices[1]) & CommandBuilder.IDX_VALUE_MASK
        )) : "Assertion failed";

        return (false, bytes(data));
    }

    function opUnary(
        VMState memory state,
        bytes32 indices,
        uint256 out,
        uint256 op
    ) internal pure {
        uint256 a = state.readUint256(uint8(indices[0]) & CommandBuilder.IDX_VALUE_MASK); 
        uint256 b = MathOpCodes.unaryOp(op, a);
        state.writeWord(out, b);
    }

    function opBinary(
        VMState memory state,
        bytes32 indices,
        uint256 out,
        uint256 op
    ) internal pure {
        uint256 a = Memory.readUint256(state, uint8(indices[0]) & CommandBuilder.IDX_VALUE_MASK);
        uint256 b = Memory.readUint256(state, uint8(indices[1]) & CommandBuilder.IDX_VALUE_MASK);
        uint256 c = MathOpCodes.binaryOp(op, a, b);
        state.writeWord(out, c);
    }

    function opLog(
        VMState memory state,
        bytes32 indices,
        uint256 logStatement
    ) internal {
        bytes32 format = state.readValue(
            uint8(indices[0])
        );
        uint256 args = 0;
        uint256 buffers = 0;
        for(uint256 i = 1; i < 32; i++) {
            if (uint8(indices[i]) == 0xff) break;
            args += 1;
            uint8 vformat = uint8(format[i - 1]);
            if ((vformat & 8) != 0) {
                buffers += 1;
            }
        }
        bytes32[] memory values = new bytes32[](args);
        bytes[] memory outBuffers = new bytes[](buffers);
        buffers = 0;
        for(uint256 i = 0; i < 32; i++) {
            
            uint8 vformat = uint8(format[i]);
            uint8 idx = uint8(indices[i + 1]);
            
            if (vformat == 0xff||idx == 0xff) break;
            if (vformat == 0) {
                values[i] = bytes32(state.readUint256(
                    idx & CommandBuilder.IDX_VALUE_MASK
                ));
                continue;
            }
            if ((vformat & 8) == 0) {
                values[i] = bytes32(uint256(idx));
                continue;
            }
            values[i] = bytes32(buffers);
            bytes memory buff = state.readBuffer(
                idx & CommandBuilder.IDX_VALUE_MASK
            );
            outBuffers[buffers] = buff;
            
            buffers += 1;
        }
        emit LogStatement(
            logStatement & 0xffffffff,
            abi.encode(values, outBuffers)
        );
    }


    function opEvent(
        VMState memory state,
        bytes32 indices,
        uint256 topics
    ) internal {
        if (topics == 0) {
            bytes memory data = state.makeTuple(indices);
            assembly {
                log0(add(data, 32), mload(data))
            }
        } else if (topics == 1) {
            bytes32 topic = state.readValue(uint8(indices[0]));
            bytes memory data = state.makeTuple(bytes32((uint256(indices) << 8)|0xff));
            assembly {
                log1(add(data, 32), mload(data), topic)
            }
        } else if (topics == 2) {
            bytes32 topic1 = state.readValue(uint8(indices[0]));
            bytes32 topic2 = state.readValue(uint8(indices[1]));
            bytes memory data = state.makeTuple(bytes32((uint256(indices) << 16) | 0xffff));
            assembly {
                log2(add(data, 32), mload(data), topic1, topic2)
            }
        } else if (topics == 3) {
            bytes32 topic1 = state.readValue(uint8(indices[0]));
            bytes32 topic2 = state.readValue(uint8(indices[1]));
            bytes32 topic3 = state.readValue(uint8(indices[2]));
            bytes memory data = state.makeTuple(bytes32((uint256(indices) << 24) | 0xffffff));
            assembly {
                log3(add(data, 32), mload(data), topic1, topic2, topic3)
            }
        } else if (topics == 4) {
            bytes32 topic1 = state.readValue(uint8(indices[0]));
            bytes32 topic2 = state.readValue(uint8(indices[1]));
            bytes32 topic3 = state.readValue(uint8(indices[2]));
            bytes32 topic4 = state.readValue(uint8(indices[3]));
            bytes memory data = state.makeTuple(bytes32((uint256(indices) << 32) | 0xffffffff));
            assembly {
                log4(add(data, 32), mload(data), topic1, topic2, topic3, topic4)
            }
        } else {
            revert("Invalid number of topics");
        }
    }

    function opReturn(
        VMState memory vmstate,
        bytes32 indices
    ) internal {
        bytes memory returnData = vmstate.readBuffer(
            uint8(indices[0]) & CommandBuilder.IDX_VALUE_MASK
        );
        if ((vmstate.flags & FLAG_INTERPRET) == FLAG_INTERPRET) {
            emit VMReturn(true, returnData);
        }
        assembly {
            return(add(returnData, 32), mload(returnData))
        }
    }

    function opMemoryLoad(
        VMState memory vmstate,
        bytes32 indices,
        bytes32 command,
        uint256 outputSlot,
        uint256 flags
    ) internal {
        if (outputSlot == 127) {
            return;
        }
        bytes memory outData = vmstate.readMemory(
            indices
        );
        if (uint8(bytes1(command << 88)) & CommandBuilder.IDX_VARIABLE_LENGTH == 0) {
            bytes memory outSlot = vmstate.getBufferForSlot(outputSlot, 32);
            assembly {
                mstore(outSlot, 32)
                mstore(add(outSlot, 32), mload(add(outData, 32)))
            }
            vmstate.meta[outputSlot] = DataTag.DEFAULT;
        } else {
            if (flags & FLAG_TUPLE_RETURN != 0) {
                vmstate.meta[outputSlot] = DataTag.TUPLE;
            } else {
                vmstate.meta[outputSlot] = DataTag.DEFAULT;
            }
            vmstate.data[outputSlot] = outData;
        }
    }
    

    function evaluateInternalOp(
        VMState memory vmstate,
        VMOutput memory out,
        bytes32 command,
        uint256 flags,
        bytes32 indices,
        uint256 i
    ) internal returns (bool writeOutputs) {
        uint256 outputSlot = uint8(bytes1(command << 88)) & CommandBuilder.IDX_VALUE_MASK;
        if ((vmstate.flags & FLAG_INTERPRET) == FLAG_INTERPRET) {
            emit VMInternalCall((vmstate.flags & TX_LEVEL_MASK) | i, command);
        }
        
        uint256 cmd;
        assembly {
            // shift the 4 most significant bytes to the right
            cmd := shr(224, command)
        }
        
        if (cmd == 0) { // read calldata opcode
            if (outputSlot == 127) {
                return true;
            }
            out.outdata = vmstate.opCalldataRead(
                indices,
                uint8(bytes1(command << 88))
            );
            out.success = out.outdata.length != 0;
            if (out.outdata.length == 32) {
                return true;
            }
            return false;
        } else if (cmd == 1) { // tuple opcode
            out.outdata = vmstate.makeTuple(
                indices
            );
            out.success = out.outdata.length != 0 ? true : false;
            return false;
        } else if (cmd == 2) {
            vmstate.opMemoryLoad(indices, command, outputSlot, flags);
        } else if (cmd == 3) {
            vmstate.opBinary(
                indices,
                outputSlot,
                uint256(command)
            );
        } else if (cmd == 4) {
            (out.success, out.outdata) = opAssert(
                vmstate,
                indices
            );
            return false;
        } else if (cmd == 5) {
            vmstate.opLog(
                indices,
                uint256(command)
            );
        } else if (cmd == 7) {
            vmstate.opUnary(
                indices,
                outputSlot,
                uint256(command)
            );
        } else if (cmd == 8) {
            vmstate.opEvent(
                indices,
                uint256(command) & 0xff
            );
        } else if (cmd == 9) {
            vmstate.opReturn(indices);
        } else if (cmd == 10) {
            if (outputSlot == 127) {
                return true;
            }
            vmstate.data[outputSlot] = vmstate.data[uint8(indices[0]) & CommandBuilder.IDX_VALUE_MASK];
            if (flags & FLAG_TUPLE_RETURN != 0) {
                vmstate.meta[outputSlot] = DataTag.TUPLE;
            } else {
                vmstate.meta[outputSlot] = DataTag.DEFAULT;
            }
        } else if (cmd == 11) { // encode callback
            vmstate.opEncodeCallback(indices, outputSlot);
        } else if (cmd == 12) { // mstore
            vmstate.opMStore(
                indices,
                outputSlot
            );
        } else if (cmd == 16) { // LEN
            vmstate.writeWord(outputSlot, vmstate.readUint256((uint8(indices[0]) & CommandBuilder.IDX_VALUE_MASK)));
        } else if (cmd >= 31) {
            bytes memory outputslot = vmstate.getBufferForSlot(outputSlot, 32);
            cmd = cmd & 31;
            bytes32 firstArg = indices[0] != 0xff ? vmstate.readValue(
                uint8(indices[0])
            ) : bytes32(0);
            
            assembly {
                switch cmd
                case 0 { mstore(add(outputslot, 32), number()) }
                case 1 { mstore(add(outputslot, 32), address()) }
                case 2 { mstore(add(outputslot, 32), caller()) }
                case 3 { mstore(add(outputslot, 32), gas()) }
                case 4 { mstore(add(outputslot, 32), selfbalance()) }
                case 5 { mstore(add(outputslot, 32), balance(firstArg)) }
                case 6 { mstore(add(outputslot, 32), chainid()) }
                case 7 { mstore(add(outputslot, 32), callvalue()) }
                case 8 { mstore(add(outputslot, 32), timestamp()) }
                case 9 { mstore(add(outputslot, 32), origin()) }
                case 10 { mstore(add(outputslot, 32), coinbase()) }
                default { revert(0, 0) }
            }
        } else {
            out.success = false;
            out.outdata = abi.encodePacked("Invalid internal command");
            return false;
        }
        return true;
    }
}

abstract contract VM {
    using CommandBuilder for VMState;
    using Memory for VMState;
    using VMOpcodes for VMState;


    // Transient storage slots used by the VM
    

    uint256 constant FLAG_CT_DELEGATECALL = 0x00;
    uint256 constant FLAG_CT_CALL = 0x01;
    uint256 constant FLAG_CT_STATICCALL = 0x02;
    uint256 constant FLAG_CT_VALUECALL = 0x03;
    uint256 constant FLAG_CT_MASK = 0x03;
    uint256 constant FLAG_EXTENDED_COMMAND = 0x80;
    uint256 constant FLAG_TUPLE_RETURN = 0x40;
    uint256 constant FLAG_INTERNAL_CMD = 0x20;
    uint256 constant SHORT_COMMAND_FILL = 0x000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;

    uint256 constant FLAG_INTERPRET = 0x1;

    uint256 constant TX_FLAGS_MASK = 0xff;
    uint256 constant TX_LEVEL_MASK = 0xff00;


    /** Must be added to implementation contract fallback to enable generic callbacks */
    function fallbackHook() internal {
        address constraint = VMOpcodes.getExpectedCallbackAddress();
        require(msg.sender == constraint, "Invalid callback");
        uint256 calldataOffset = VMOpcodes.getCalldataOffset();
        uint256 calldataSize = 0;
        assembly {
            calldataOffset := add(calldataload(calldataOffset), 4)
            calldataSize := calldataload(calldataOffset)
        }
        bytes memory data = new bytes(calldataSize);
        assembly {
            calldatacopy(add(data, 32), add(calldataOffset, 32), calldataSize)   
        }

        (
            uint256 flags,
            bytes32[] memory commands,
            DataTag[] memory meta,
            bytes[] memory state
        ) = abi.decode(data, (uint256, bytes32[], DataTag[], bytes[]));

        VMState memory vmstate = VMState(
            meta,
            state,
            flags
        );

        _execute(
            vmstate,
            commands
        );
    }
    
    function _execute(
        VMState memory vmstate,
        bytes32[] memory commands
    ) internal returns (VMOutput memory out) {
        uint256 commandsLength = commands.length;
        for (uint256 i; i < commandsLength;) {
            bytes32 command = commands[i];
            uint256 flags = uint256(uint8(bytes1(command << 32)));
            bytes32 indices;
            if (flags & FLAG_EXTENDED_COMMAND != 0) {
                indices = commands[++i];
            } else {
                indices = bytes32(uint256(command << 40) | SHORT_COMMAND_FILL);
            }

            if (flags & FLAG_INTERNAL_CMD != 0) {
                if (vmstate.evaluateInternalOp(out, command, flags, indices, i)) {
                    i++;
                    continue;
                }
            } else {

                bytes memory inputs = vmstate.buildInputs(
                    bytes4(command),
                    indices
                );

                if ((vmstate.flags & FLAG_INTERPRET) == FLAG_INTERPRET) {
                    emit VMCall(
                        (vmstate.flags & TX_LEVEL_MASK) | i,
                        commands[i],
                        address(uint160(uint256(command))),
                        inputs,
                        flags & FLAG_CT_MASK
                    );
                }

                if ((uint256(command) & 0x00ffffffffffffffffffffffffffffffffffffffff) < 127) {
                    bytes memory statevar = vmstate.data[uint256(command) & 0xff];
                    assembly {
                        command := or(and(command, 0xffffffffffffffffffffffff0000000000000000000000000000000000000000), mload(add(statevar, 32)))
                    }
                }
                
                if (flags & FLAG_CT_MASK == FLAG_CT_DELEGATECALL) {
                    (out.success, out.outdata) = address(uint160(uint256(command))).delegatecall( // target
                        // inputs
                        inputs
                    );
                } else if (flags & FLAG_CT_MASK == FLAG_CT_CALL) {
                    (out.success, out.outdata) = address(uint160(uint256(command))).call( // target
                        // inputs
                        inputs
                        );
                } else if (flags & FLAG_CT_MASK == FLAG_CT_STATICCALL) {
                    (out.success, out.outdata) = address(uint160(uint256(command))).staticcall( // target
                        // inputs
                        inputs
                    );
                } else if (flags & FLAG_CT_MASK == FLAG_CT_VALUECALL) {
                    uint256 calleth;
                    bytes memory v = vmstate.data[uint8(bytes1(indices))];
                    require(v.length == 32, "_execute: value call has no value indicated.");
                    assembly {
                        calleth := mload(add(v, 0x20))
                    }
                    (out.success, out.outdata) = address(uint160(uint256(command))).call{ // target
                        value: calleth
                    }(
                        // inputs
                        vmstate.buildInputs(
                            //selector
                            bytes4(command),
                            bytes32(uint256(indices << 8) | CommandBuilder.IDX_END_OF_ARGS)
                        )
                    );
                } else {
                    revert("Invalid calltype");
                }

                if ((vmstate.flags & FLAG_INTERPRET) == FLAG_INTERPRET) {
                    emit VMCallReturn((vmstate.flags & TX_LEVEL_MASK) | i, commands[i], out.success, out.outdata);
                }
            }
            
            if (!out.success) {
                
                if ((vmstate.flags & FLAG_INTERPRET) == FLAG_INTERPRET) {
                    emit VMException(
                        (vmstate.flags & TX_LEVEL_MASK) | i,
                        out.outdata
                    );
                    
                    return out;
                }
                if (out.outdata.length > 0) {
                    bytes memory outdata = out.outdata;
                    assembly {
                        outdata := add(outdata, 68)
                    }
                }
                revert(out.outdata.length > 0 ? string(out.outdata) : "Unknown");
            }

            if (flags & FLAG_TUPLE_RETURN != 0) {
                vmstate.writeTuple(bytes1(command << 88), out.outdata);
            } else {
                vmstate = vmstate.writeOutputs(bytes1(command << 88), out.outdata);
            }
            i++;
        }
        if ((vmstate.flags & FLAG_INTERPRET) == FLAG_INTERPRET) {
            emit VMReturn(out.success, out.outdata);
        }
        return out;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.26;

enum DataTag {
    DEFAULT,
    TUPLE
}

struct VMState {
    DataTag[] meta;
    bytes[] data;
    uint256 flags;
}

struct VMOutput {
    bool success;
    bytes outdata;
}