IExpressionDeployerV1

Git Source

Companion to IInterpreterV1 responsible for onchain static code analysis and deploying expressions. Each IExpressionDeployerV1 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

deployExpression

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 IExpressionDeployerV1 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 IExpressionDeployerV1 MUST do any additional processing required by its paired interpreter. For example, the IExpressionDeployerV1 MAY NEED to replace the indexed opcodes in the ExpressionConfig sources with real function pointers from the corresponding interpreter.

function deployExpression(bytes[] memory sources, uint256[] memory constants, uint256[] memory minOutputs)
    external
    returns (IInterpreterV1 interpreter, IInterpreterStoreV1 store, address expression);

Parameters

Returns

Events

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.

event DISpair(address sender, address deployer, address interpreter, address store, bytes opMeta);

Parameters