[pallet-revive] EVM backend: Implement tx, block system and call stack instructions

prdoc/pr_9414.prdoc

@@ -0,0 +1,13 @@
+title: '[pallet-revive] EVM backend: Implement tx, block system and call stack instructions'
+doc:
+- audience: Runtime Dev
+  description: |-
+    This PR is part of the road to EVM.
+    - Implement call and create frames, allowing to call and instantiate other contracts.
+    - Implement support for tx info, block info, system and contract opcodes.
+    - The `InstructionResult` <-> `ExecError` conversion functions.
+crates:
+- name: pallet-revive
+  bump: major
+- name: pallet-revive-fixtures
+  bump: minor

substrate/frame/revive/fixtures/contracts/BlockInfo.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract BlockInfo {
+    function blockNumber() public view returns (uint) {
+        return block.number;
+    }
+
+    function coinbase() public view returns (address) {
+        return block.coinbase;
+    }
+
+    function timestamp() public view returns (uint) {
+        return block.timestamp;
+    }
+
+    function difficulty() public view returns (uint) {
+        return block.difficulty;
+    }
+
+    function gaslimit() public view returns (uint) {
+        return block.gaslimit;
+    }
+
+    function chainid() public view returns (uint) {
+        return block.chainid;
+    }
+
+    function basefee() public view returns (uint) {
+        return block.basefee;
+    }
+}

substrate/frame/revive/fixtures/contracts/Callee.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.0;
+
+contract Callee {
+    uint public stored;
+
+    function echo(uint _data) external pure returns (uint data) {
+        data = _data;
+    }
+
+    function whoSender() external view returns (address) {
+        return msg.sender;
+    }
+
+    function store(uint _data) external {
+        stored = _data;
+    }
+
+    function revert() public pure returns (uint256) {
+        require(false, "This is a revert");
+        return 42; // never reached
+    }
+
+    function invalid() public pure returns (uint256 result) {
+        assembly {
+            invalid() // 0xFE opcode
+        }
+    }
+
+    function stop() public pure returns (uint256 result) {
+        assembly {
+            stop()
+        }
+    }
+}

substrate/frame/revive/fixtures/contracts/Caller.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.0;
+
+contract Caller {
+    function normal(
+        address _callee,
+        uint _value,
+        bytes memory _data,
+        uint _gas
+    ) external returns (bool success, bytes memory output) {
+        (success, output) = _callee.call{value: _value, gas: _gas}(_data);
+    }
+
+    function delegate(
+        address _callee,
+        bytes memory _data,
+        uint _gas
+    ) external returns (bool success, bytes memory output) {
+        (success, output) = _callee.delegatecall{gas: _gas}(_data);
+    }
+
+    function staticCall(
+        // Don't rename to `static` (it's a Rust keyword).
+        address _callee,
+        bytes memory _data,
+        uint _gas
+    ) external view returns (bool success, bytes memory output) {
+        (success, output) = _callee.staticcall{gas: _gas}(_data);
+    }
+
+    function create(
+        bytes memory initcode
+    ) external payable returns (address addr) {
+        assembly {
+            // CREATE with no value
+            addr := create(0, add(initcode, 0x20), mload(initcode))
+            if iszero(addr) {
+                // bubble failure
+				let returnDataSize := returndatasize()
+				returndatacopy(0, 0, returnDataSize)
+                revert(0, returnDataSize)
+            }
+        }
+    }
+
+    function create2(
+        bytes memory initcode,
+        bytes32 salt
+    ) external payable returns (address addr) {
+        assembly {
+            // CREATE2 with no value
+            addr := create2(0, add(initcode, 0x20), mload(initcode), salt)
+            if iszero(addr) {
+                // bubble failure
+				let returnDataSize := returndatasize()
+				returndatacopy(0, 0, returnDataSize)
+                revert(0, returnDataSize)
+            }
+        }
+    }
+}

substrate/frame/revive/fixtures/contracts/Dummy.sol

@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8;
+
+contract Dummy {}

substrate/frame/revive/fixtures/contracts/Host.sol

@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract Host {
+    function balance(address account) public view returns (uint256) {
+        return account.balance;
+    }
+
+    function extcodesize(address account) public view returns (uint256) {
+        uint256 size;
+        assembly {
+            size := extcodesize(account)
+        }
+        return size;
+    }
+
+    function extcodecopy(
+        address /* account */,
+        uint256 /* destOffset */,
+        uint256 /* offset */,
+        uint256 size
+    ) public pure returns (bytes memory) {
+        bytes memory code = new bytes(size);
+        return code;
+    }
+
+    function extcodehash(address account) public view returns (bytes32) {
+        bytes32 hash;
+        assembly {
+            hash := extcodehash(account)
+        }
+        return hash;
+    }
+
+    function blockhash(uint256 blockNumber) public view returns (bytes32) {
+        return blockhash(blockNumber);
+    }
+
+    function sload(uint256 slot) public view returns (uint256) {
+        uint256 value;
+        assembly {
+            value := sload(slot)
+        }
+        return value;
+    }
+
+    function sstore(uint256 slot, uint256 value) public returns (uint256) {
+        assembly {
+            sstore(slot, value)
+        }
+        return value;
+    }
+
+    function tload(uint256 slot) public view returns (uint256) {
+        uint256 value;
+        assembly {
+            value := tload(slot)
+        }
+        return value;
+    }
+
+    function tstore(uint256 slot, uint256 value) public returns (uint256) {
+        assembly {
+            tstore(slot, value)
+        }
+        return value;
+    }
+
+    function log0(bytes32 data) public {
+        assembly {
+            log0(data, 0x20)
+        }
+    }
+
+    function log1(bytes32 data, bytes32 topic1) public {
+        assembly {
+            log1(data, 0x20, topic1)
+        }
+    }
+
+    function log2(bytes32 data, bytes32 topic1, bytes32 topic2) public {
+        assembly {
+            log2(data, 0x20, topic1, topic2)
+        }
+    }
+
+    function log3(
+        bytes32 data,
+        bytes32 topic1,
+        bytes32 topic2,
+        bytes32 topic3
+    ) public {
+        assembly {
+            log3(data, 0x20, topic1, topic2, topic3)
+        }
+    }
+
+    function log4(
+        bytes32 data,
+        bytes32 topic1,
+        bytes32 topic2,
+        bytes32 topic3,
+        bytes32 topic4
+    ) public {
+        assembly {
+            log4(data, 0x20, topic1, topic2, topic3, topic4)
+        }
+    }
+
+    function selfdestruct(address payable recipient) public {
+        selfdestruct(recipient);
+    }
+
+    function selfbalance() public view returns (uint256) {
+        return address(this).balance;
+    }
+}

substrate/frame/revive/fixtures/contracts/System.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+contract System {
+    function keccak256Func(bytes memory data) public pure returns (bytes32) {
+        return keccak256(data);
+    }
+
+    function addressFunc() public view returns (address) {
+        return address(this);
+    }
+
+    function caller() public view returns (address) {
+        return msg.sender;
+    }
+
+    function callvalue() public payable returns (uint256) {
+        return msg.value;
+    }
+
+    function calldataload(uint256 offset) public pure returns (bytes32) {
+        bytes32 data;
+        assembly {
+            data := calldataload(offset)
+        }
+        return data;
+    }
+
+    function calldatasize() public pure returns (uint256) {
+        return msg.data.length;
+    }
+
+    function calldatacopy(
+        uint256 destOffset,
+        uint256 offset,
+        uint256 size
+    ) public pure returns (bytes memory) {
+        bytes memory data = new bytes(size);
+        assembly {
+            calldatacopy(add(data, 0x20), offset, size)
+        }
+        return data;
+    }
+
+    function codesize() public pure returns (uint256) {
+        uint256 size;
+        assembly {
+            size := codesize()
+        }
+        return size;
+    }
+
+    function codecopy(
+        uint256 /* destOffset */,
+        uint256 /* offset */,
+        uint256 size
+    ) public pure returns (bytes memory) {
+        bytes memory code = new bytes(size);
+        return code;
+    }
+
+    function returndatasize(
+        address _callee,
+        bytes memory _data,
+        uint _gas
+    ) public returns (uint256) {
+        uint256 size;
+        _callee.staticcall{gas: _gas}(_data);
+        assembly {
+            size := returndatasize()
+        }
+        return size;
+    }
+
+    function returndatacopy(
+        address _callee,
+        bytes memory _data,
+        uint _gas,
+        uint256 destOffset,
+        uint256 offset,
+        uint256 size
+    ) public returns (bytes memory) {
+        bytes memory data = new bytes(size);
+        _callee.staticcall{gas: _gas}(_data);
+        assembly {
+            returndatacopy(add(data, 0x20), offset, size)
+        }
+        return data;
+    }
+
+    function gas() public view returns (uint256) {
+        return gasleft();
+    }
+}

substrate/frame/revive/fixtures/contracts/TransactionInfo.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract TransactionInfo {
+    function origin() public view returns (address) {
+        return tx.origin;
+    }
+
+    function gasprice() public view returns (uint256) {
+        return tx.gasprice;
+    }
+
+    function blobhash(uint256 index) public view returns (bytes32) {
+        return blobhash(index);
+    }
+}