IExpressionDeployerV3

Git Source

Companion to IInterpreterV2 responsible for onchain static code analysis and deploying expressions. Each IExpressionDeployerV3 is tightly coupled at the bytecode level to some interpreter that it knows how to analyse and deploy expressions for. The expression deployer can perform an integrity check "dry run" of candidate source code for the intepreter. The critical analysis/transformation includes:

• Enforcement of no out of bounds memory reads/writes
• Calculation of memory required to eval the stack with a single allocation
• Replacing index based opcodes with absolute interpreter function pointers
• Enforcement that all opcodes and operands used exist and are valid This analysis is highly sensitive to the specific implementation and position of all opcodes and function pointers as compiled into the interpreter. This is what makes the coupling between an interpreter and expression deployer so tight. Ideally all responsibilities would be handled by a single contract but this introduces code size issues quickly by roughly doubling the compiled logic of each opcode (half for the integrity check and half for evaluation). Interpreters MUST assume that expression deployers are malicious and fail gracefully if the integrity check is corrupt/bypassed and/or function pointers are incorrect, etc. i.e. the interpreter MUST always return a stack from eval in a read only way or error. I.e. it is the expression deployer's responsibility to do everything it can to prevent undefined behaviour in the interpreter, and the interpreter's responsibility to handle the expression deployer completely failing to do so.

Functions

deployExpression2

Expressions are expected to be deployed onchain as immutable contract code with a first class address like any other contract or account. Technically this is optional in the sense that all the tools required to eval some expression and define all its opcodes are available as libraries. In practise there are enough advantages to deploying the sources directly onchain as contract data and loading them from the interpreter at eval:

• Loading and storing binary data is gas efficient as immutable contract data
• Expressions need to be immutable between their deploy time integrity check and runtime evaluation
• Passing the address of an expression through calldata to an interpreter is cheaper than passing an entire expression through calldata
• Conceptually a very simple approach, even if implementations like SSTORE2 are subtle under the hood The expression deployer MUST perform an integrity check of the source code before it puts the expression onchain at a known address. The integrity check MUST at a minimum (it is free to do additional static analysis) calculate the memory required to be allocated for the stack in total, and that no out of bounds memory reads/writes occur within this stack. A simple example of an invalid source would be one that pushes one value to the stack then attempts to pops two values, clearly we cannot remove more values than we added. The IExpressionDeployerV3 MUST revert in the case of any integrity failure, all integrity checks MUST pass in order for the deployment to complete. Once the integrity check is complete the IExpressionDeployerV3 MUST do any additional processing required by its paired interpreter. For example, the IExpressionDeployerV3 MAY NEED to replace the indexed opcodes in the ExpressionConfig sources with real function pointers from the corresponding interpreter. The caller MUST check the io returned by this function to determine the number of inputs and outputs for each source are within the bounds of the caller's expectations.

function deployExpression2(bytes calldata bytecode, uint256[] calldata constants)
    external
    returns (IInterpreterV2 interpreter, IInterpreterStoreV1 store, address expression, bytes calldata io);

Parameters

Returns

Events

NewExpression

The config of the deployed expression including uncompiled sources. MUST be emitted after the config passes the integrity check.

event NewExpression(address sender, bytes bytecode, uint256[] constants);

Parameters

DeployedExpression

The address of the deployed expression. MUST be emitted once the expression can be loaded and deserialized into an evaluable interpreter state.

event DeployedExpression(
    address sender, IInterpreterV2 interpreter, IInterpreterStoreV1 store, address expression, bytes io
);

Parameters

DISPair

This is the literal InterpreterOpMeta bytes to be used offchain to make sense of the opcodes in this interpreter deployment, as a human. For formats like json that make heavy use of boilerplate, repetition and whitespace, some kind of compression is recommended. The DISPair is a pairing of:

• Deployer (this contract)
• Interpreter
• Store
• Parser

event DISPair(address sender, address interpreter, address store, address parser, bytes meta);

Parameters