RainterpreterExpressionDeployerNPE2

Inherits: IExpressionDeployerV3, ERC165

State Variables

iInterpreter

The interpreter with known bytecode that this deployer is constructed for.

IInterpreterV2 public immutable iInterpreter;

iStore

The store with known bytecode that this deployer is constructed for.

IInterpreterStoreV1 public immutable iStore;

iParser

IParserV1 public immutable iParser;

Functions

constructor

constructor(RainterpreterExpressionDeployerNPE2ConstructionConfig memory config);

supportsInterface

This IS a security check. This prevents someone making an exact bytecode copy of the interpreter and shipping different meta for the copy to lie about what each op does in the interpreter.

Interface identification is specified in ERC-165. This function uses less than 30,000 gas.

function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool);

Parameters

Name	Type	Description
`interfaceId`	`bytes4`

Returns

Name	Type	Description
`<none>`	`bool`	`true` if the contract implements `interfaceID` and `interfaceID` is not 0xffffffff, `false` otherwise

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 memory bytecode, uint256[] memory constants)
    external
    virtual
    returns (IInterpreterV2, IInterpreterStoreV1, address, bytes memory);

Parameters

Name	Type	Description
`bytecode`	`bytes`	Bytecode verbatim. Exactly how the bytecode is structured is up to the deployer and interpreter. The deployer MUST NOT modify the bytecode in any way. The interpreter MUST NOT assume anything about the bytecode other than that it is valid according to the interpreter's integrity checks. It is assumed that the bytecode will be produced from a human friendly string via. `IParserV1.parse` but this is not required if the caller has some other means to prooduce valid bytecode.
`constants`	`uint256[]`	Constants verbatim. Constants are provided alongside sources rather than inline as it allows us to avoid variable length opcodes and can be more memory efficient if the same constant is referenced several times from the sources.

Returns

Name	Type	Description
`<none>`	`IInterpreterV2`	interpreter The interpreter the deployer believes it is qualified to perform integrity checks on behalf of.
`<none>`	`IInterpreterStoreV1`	store The interpreter store the deployer believes is compatible with the interpreter.
`<none>`	`address`	expression The address of the deployed onchain expression. MUST be valid according to all integrity checks the deployer is aware of.
`<none>`	`bytes`	io Binary data where each 2 bytes input and output counts for each source of the bytecode. MAY simply be copied verbatim from the relevant bytes in the bytecode if they exist and integrity checks guarantee that the bytecode is valid.

integrityFunctionPointers

Defines all the function pointers to integrity checks. This is the expression deployer's equivalent of the opcode function pointers and follows a near identical dispatch process. These are never compiled into source and are instead indexed into directly by the integrity check. The indexing into integrity pointers (which has an out of bounds check) is a proxy for enforcing that all opcode pointers exist at runtime, so the length of the integrity pointers MUST match the length of opcode function pointers. This function is virtual so that it can be overridden pairwise with overrides to functionPointers on Rainterpreter.

function integrityFunctionPointers() external view virtual returns (bytes memory);

Returns

Name	Type	Description
`<none>`	`bytes`	The list of integrity function pointers.

expectedConstructionMetaHash

Virtual function to return the expected construction meta hash. Public so that external tooling can read it, although this should be considered deprecated. The intended workflow is that tooling uses a real evm to deploy the full dispair and reads the hashes from errors using a trail/error approach until a full dispair is deployed.

function expectedConstructionMetaHash() public pure virtual returns (bytes32);

expectedInterpreterBytecodeHash

Virtual function to return the expected interpreter bytecode hash.

function expectedInterpreterBytecodeHash() internal pure virtual returns (bytes32);

expectedStoreBytecodeHash

Virtual function to return the expected store bytecode hash.

function expectedStoreBytecodeHash() internal pure virtual returns (bytes32);

expectedParserBytecodeHash

Virtual function to return the expected parser bytecode hash.

function expectedParserBytecodeHash() internal pure virtual returns (bytes32);