Add Scroll integration

arb-gateway/src/ArbProofService.ts

@@ -1,5 +1,5 @@
 /* eslint-disable prettier/prettier */
-import { EVMProofHelper, type IProofService } from '@ensdomains/evm-gateway';
+import { EVMProofHelper, convertIntoMerkleTrieProof, type IProofService } from '@ensdomains/evm-gateway';
 import { AbiCoder, Contract, EventLog, ethers, toBeHex, type AddressLike, toNumber } from 'ethers';
 import rollupAbi from "./abi/rollupABI.js";
 import type { IBlockCache } from './blockCache/IBlockCache.js';
@@ -63,7 +63,7 @@ export class ArbProofService implements IProofService<ArbProvableBlock> {
         return AbiCoder.defaultAbiCoder().encode(
             [
                 'tuple(bytes32 version, bytes32 sendRoot, uint64 nodeIndex,bytes rlpEncodedBlock)',
-                'tuple(bytes[] stateTrieWitness, bytes[][] storageProofs)',
+                'tuple(bytes stateTrieWitness, bytes[] storageProofs)',
             ],
             [
                 {
@@ -73,7 +73,7 @@ export class ArbProofService implements IProofService<ArbProvableBlock> {
                     nodeIndex: block.nodeIndex,
                     rlpEncodedBlock: block.rlpEncodedBlock
                 },
-                proof,
+                convertIntoMerkleTrieProof(proof)
             ]
         );
     }

arb-gateway/src/worker.ts

@@ -57,7 +57,7 @@ async function fetch(request: CFWRequest, env: Env) {
   await tracker.trackEvent(request, 'request', { props }, true);
   return app
     .handle(request)
-    .then(tracker.logResult.bind(null, propsDecoder, request));
+    .then(tracker.logResult.bind(tracker, propsDecoder, request));
 }
 
 export default {

arb-verifier/contracts/ArbVerifier.sol

@@ -4,6 +4,7 @@ import {StateProof, EVMProofHelper} from '@ensdomains/evm-verifier/contracts/EVM
 import {IEVMVerifier} from '@ensdomains/evm-verifier/contracts/IEVMVerifier.sol';
 import {Node, IRollupCore} from '@arbitrum/nitro-contracts/src/rollup/IRollupCore.sol';
 import {RLPReader} from '@eth-optimism/contracts-bedrock/src/libraries/rlp/RLPReader.sol';
+import {MerkleTrieProofHelper} from '@ensdomains/evm-verifier/contracts/MerkleTrieProofHelper.sol';
 
 struct ArbWitnessData {
     bytes32 version;
@@ -63,14 +64,8 @@ contract ArbVerifier is IEVMVerifier {
 
         //Now that we know that the block is valid, we can get the state root from the block.
         bytes32 stateRoot = getStateRootFromBlock(arbData.rlpEncodedBlock);
-
-        values = EVMProofHelper.getStorageValues(
-            target,
-            commands,
-            constants,
-            stateRoot,
-            stateProof
-        );
+        bytes32 storageRoot = MerkleTrieProofHelper.getStorageRoot(stateRoot, target, stateProof.stateTrieWitness);
+        return EVMProofHelper.getStorageValues(target, MerkleTrieProofHelper.getTrieProof, commands, constants, storageRoot, stateProof.storageProofs);
     }
 
     /*

arb-verifier/test/testArbVerifier.ts

@@ -4,6 +4,8 @@ import { HardhatEthersProvider } from '@nomicfoundation/hardhat-ethers/internal/
 import type { HardhatEthersHelpers } from '@nomicfoundation/hardhat-ethers/types';
 import { expect } from 'chai';
 import {
+  AbiCoder,
+  concat,
   Contract,
   FetchRequest,
   Provider,
@@ -28,6 +30,23 @@ declare module 'hardhat/types/runtime' {
     ethers: ethersObj;
   }
 }
+const estimateCCIPReadCallbackGas = async (provider, cb) => {
+  try{
+    await cb()
+  }catch(e){
+    const [sender, urls, data, callbackFunction, extraData ] = e.revert.args
+    const url = `http://localhost:8080/${sender}/${data}.json`
+    const responseData:any = await (await fetch(url)).json()
+    const encoder = new AbiCoder()
+    const encoded = encoder.encode([ "bytes", "bytes" ], [responseData.data, extraData]);
+    const newdata = concat([ callbackFunction, encoded ])
+    const result2 = await provider.estimateGas({
+      to: sender,
+      data:newdata
+    });
+    console.log(`Gas estimate ${result2}`)
+  }
+}
 
 describe('ArbVerifier', () => {
   let provider: Provider;
@@ -87,54 +106,86 @@ describe('ArbVerifier', () => {
   it('simple proofs for fixed values', async () => {
     const result = await target.getLatest({ enableCcipRead: true });
     expect(Number(result)).to.equal(42);
+    await estimateCCIPReadCallbackGas(provider, ()=>{
+      return target.getLatest({ enableCcipRead: false });
+    })
   });
 
   it('simple proofs for dynamic values', async () => {
     const result = await target.getName({ enableCcipRead: true });
     expect(result).to.equal('Satoshi');
+    await estimateCCIPReadCallbackGas(provider, ()=>{
+      return target.getName({ enableCcipRead: false });
+    })
   });
 
   it('nested proofs for dynamic values', async () => {
     const result = await target.getHighscorer(42, { enableCcipRead: true });
     expect(result).to.equal('Hal Finney');
+    await estimateCCIPReadCallbackGas(provider, ()=>{
+      return target.getHighscorer(42, { enableCcipRead: false });
+    })
   });
 
   it('nested proofs for long dynamic values', async () => {
     const result = await target.getHighscorer(1, { enableCcipRead: true });
     expect(result).to.equal(
       'Hubert Blaine Wolfeschlegelsteinhausenbergerdorff Sr.'
     );
+    await estimateCCIPReadCallbackGas(provider, ()=>{
+      return target.getHighscorer(1, { enableCcipRead: false });
+    })
   });
 
   it('nested proofs with lookbehind', async () => {
     const result = await target.getLatestHighscore({ enableCcipRead: true });
     expect(Number(result)).to.equal(12345);
+    await estimateCCIPReadCallbackGas(provider, ()=>{
+      return target.getLatestHighscore({ enableCcipRead: false });
+    })
   });
 
   it('nested proofs with lookbehind for dynamic values', async () => {
     const result = await target.getLatestHighscorer({ enableCcipRead: true });
     expect(result).to.equal('Hal Finney');
+    await estimateCCIPReadCallbackGas(provider, ()=>{
+      return target.getLatestHighscorer({ enableCcipRead: false });
+    })
   });
 
   it('mappings with variable-length keys', async () => {
     const result = await target.getNickname('Money Skeleton', {
       enableCcipRead: true,
     });
     expect(result).to.equal('Vitalik Buterin');
+    await estimateCCIPReadCallbackGas(provider, ()=>{
+      return target.getNickname('Money Skeleton', {
+        enableCcipRead: false,
+      });
+    })
   });
 
   it('nested proofs of mappings with variable-length keys', async () => {
     const result = await target.getPrimaryNickname({ enableCcipRead: true });
     expect(result).to.equal('Hal Finney');
+    await estimateCCIPReadCallbackGas(provider, ()=>{
+      return target.getPrimaryNickname({ enableCcipRead: false });
+    })
   });
 
   it('treats uninitialized storage elements as zeroes', async () => {
     const result = await target.getZero({ enableCcipRead: true });
     expect(Number(result)).to.equal(0);
+    await estimateCCIPReadCallbackGas(provider, ()=>{
+      return target.getZero({ enableCcipRead: false });
+    })
   });
 
   it('treats uninitialized dynamic values as empty strings', async () => {
     const result = await target.getNickname('Santa', { enableCcipRead: true });
     expect(result).to.equal("");
+    await estimateCCIPReadCallbackGas(provider, ()=>{
+      return target.getNickname('Santa', { enableCcipRead: false });
+    })
   })
 });

evm-gateway/package.json

@@ -63,4 +63,4 @@
   "type": "module",
   "types": "./_types/index.d.ts",
   "typings": "./_types/index.d.ts"
-}
+}

evm-gateway/src/EVMProofHelper.ts

@@ -4,21 +4,21 @@ import { toBeHex, type AddressLike, type JsonRpcProvider } from 'ethers';
  * Response of the eth_getProof RPC method.
  */
 interface EthGetProofResponse {
-  accountProof: string[];
+  accountProof: string;
   balance: string;
   codeHash: string;
   nonce: string;
   storageHash: string;
   storageProof: {
     key: string;
     value: string;
-    proof: string[];
+    proof: string;
   }[];
 }
 
 export interface StateProof {
-  stateTrieWitness: string[];
-  storageProofs: string[][];
+  stateTrieWitness: string;
+  storageProofs: string[];
   stateRoot: string;
 }
 

evm-gateway/src/index.ts

@@ -1,4 +1,8 @@
 export { EVMGateway, StorageLayout } from './EVMGateway.js';
 export { EVMProofHelper, type StateProof } from './EVMProofHelper.js';
 export type { IProofService, ProvableBlock } from './IProofService.js';
-export { propsDecoder, type Router } from './utils.js';
+export {
+  propsDecoder,
+  convertIntoMerkleTrieProof,
+  type Router,
+} from './utils.js';

evm-gateway/src/utils.ts

@@ -1,5 +1,7 @@
 import { type Request as CFWRequest } from '@cloudflare/workers-types';
 import { type PropsDecoder } from '@ensdomains/server-analytics';
+import { AbiCoder } from 'ethers';
+import { type StateProof } from './EVMProofHelper.js';
 export interface Router {
   handle: (request: CFWRequest) => Promise<Response>;
 }
@@ -22,3 +24,14 @@ export const propsDecoder: PropsDecoder<CFWRequest> = (
     return {};
   }
 };
+
+const flatten = (data: string) => {
+  return AbiCoder.defaultAbiCoder().encode(['bytes[]'], [data]);
+};
+
+export const convertIntoMerkleTrieProof = (proof: StateProof) => {
+  return {
+    stateTrieWitness: flatten(proof.stateTrieWitness),
+    storageProofs: proof.storageProofs.map(flatten),
+  };
+};

evm-verifier/contracts/EVMProofHelper.sol

@@ -6,8 +6,8 @@ import {Bytes} from "@eth-optimism/contracts-bedrock/src/libraries/Bytes.sol";
 import {SecureMerkleTrie} from "./SecureMerkleTrie.sol";
 
 struct StateProof {
-    bytes[] stateTrieWitness;         // Witness proving the `storageRoot` against a state root.
-    bytes[][] storageProofs;          // An array of proofs of individual storage elements 
+    bytes stateTrieWitness;         // Witness proving the `storageRoot` against a state root.
+    bytes[] storageProofs;          // An array of proofs of individual storage elements 
 }
 
 uint8 constant OP_CONSTANT = 0x00;
@@ -17,52 +17,39 @@ uint8 constant FLAG_DYNAMIC = 0x01;
 library EVMProofHelper {
     using Bytes for bytes;
 
-    error AccountNotFound(address);
     error UnknownOpcode(uint8);
     error InvalidSlotSize(uint256 size);
 
-    /**
-     * @notice Get the storage root for the provided merkle proof
-     * @param stateRoot The state root the witness was generated against
-     * @param target The address we are fetching a storage root for
-     * @param witness A witness proving the value of the storage root for `target`.
-     * @return The storage root retrieved from the provided state root
-     */
-    function getStorageRoot(bytes32 stateRoot, address target, bytes[] memory witness) private pure returns (bytes32) {
-        (bool exists, bytes memory encodedResolverAccount) = SecureMerkleTrie.get(
-            abi.encodePacked(target),
-            witness,
-            stateRoot
-        );
-        if(!exists) {
-            revert AccountNotFound(target);
-        }
-        RLPReader.RLPItem[] memory accountState = RLPReader.readList(encodedResolverAccount);
-        return bytes32(RLPReader.readBytes(accountState[2]));
-    }
-
     /**
      * @notice Prove whether the provided storage slot is part of the storageRoot
+     * @param target address to verify against
+     * @param getter function to verify the storage proof
      * @param storageRoot the storage root for the account that contains the storage slot
      * @param slot The storage key we are fetching the value of
      * @param witness the StorageProof struct containing the necessary proof data
      * @return The retrieved storage proof value or 0x if the storage slot is empty
      */
-    function getSingleStorageProof(bytes32 storageRoot, uint256 slot, bytes[] memory witness) private pure returns (bytes memory) {
-        (bool exists, bytes memory retrievedValue) = SecureMerkleTrie.get(
-            abi.encodePacked(slot),
+    function getSingleStorageProof(
+        address target,
+        function(address,uint256,bytes memory, bytes32) internal view returns(bytes memory) getter,
+        bytes32 storageRoot,
+        uint256 slot,
+        bytes memory witness
+    ) private view returns (bytes memory) {
+        return getter(
+            target,
+            slot,
             witness,
             storageRoot
         );
-        if(!exists) {
-            // Nonexistent values are treated as zero.
-            return "";
-        }
-        return RLPReader.readBytes(retrievedValue);
     }
 
-    function getFixedValue(bytes32 storageRoot, uint256 slot, bytes[] memory witness) private pure returns(bytes32) {
-        bytes memory value = getSingleStorageProof(storageRoot, slot, witness);
+    function getFixedValue(
+        address target,
+        function(address,uint256,bytes memory, bytes32) internal view returns(bytes memory) getter,
+        bytes32 storageRoot, uint256 slot, bytes memory witness
+    ) private view returns(bytes32) {
+        bytes memory value = getSingleStorageProof(target, getter, storageRoot, slot, witness);
         // RLP encoded storage slots are stored without leading 0 bytes.
         // Casting to bytes32 appends trailing 0 bytes, so we have to bit shift to get the 
         // original fixed-length representation back.
@@ -82,7 +69,7 @@ library EVMProofHelper {
         }
     }
 
-    function computeFirstSlot(bytes32 command, bytes[] memory constants, bytes[] memory values) private pure returns(bool isDynamic, uint256 slot) {
+    function computeFirstSlot(bytes32 command, bytes[] memory constants, bytes[] memory values) internal pure returns(bool isDynamic, uint256 slot) {
         uint8 flags = uint8(command[0]);
         isDynamic = (flags & FLAG_DYNAMIC) != 0;
 
@@ -96,8 +83,12 @@ library EVMProofHelper {
         }
     }
 
-    function getDynamicValue(bytes32 storageRoot, uint256 slot, StateProof memory proof, uint256 proofIdx) private pure returns(bytes memory value, uint256 newProofIdx) {
-        uint256 firstValue = uint256(getFixedValue(storageRoot, slot, proof.storageProofs[proofIdx++]));
+    function getDynamicValue(
+        address target,
+        function(address,uint256,bytes memory, bytes32) internal view returns(bytes memory) getter,
+        bytes32 storageRoot, uint256 slot, bytes[] memory proof, uint256 proofIdx) private view returns(bytes memory value, uint256 newProofIdx
+    ) {
+        uint256 firstValue = uint256(getFixedValue(target, getter,storageRoot, slot, proof[proofIdx++]));
         if(firstValue & 0x01 == 0x01) {
             // Long value: first slot is `length * 2 + 1`, following slots are data.
             uint256 length = (firstValue - 1) / 2;
@@ -107,10 +98,10 @@ library EVMProofHelper {
             // all at once, but we're trying to avoid writing new library code.
             while(length > 0) {
                 if(length < 32) {
-                    value = bytes.concat(value, getSingleStorageProof(storageRoot, slot++, proof.storageProofs[proofIdx++]).slice(0, length));
+                    value = bytes.concat(value, getSingleStorageProof(target, getter, storageRoot, slot++, proof[proofIdx++]).slice(0, length));
                     length = 0;
                 } else {
-                    value = bytes.concat(value, getSingleStorageProof(storageRoot, slot++, proof.storageProofs[proofIdx++]));
+                    value = bytes.concat(value, getSingleStorageProof(target, getter, storageRoot, slot++, proof[proofIdx++]));
                     length -= 32;
                 }
             }
@@ -122,20 +113,23 @@ library EVMProofHelper {
         }
     }
 
-    function getStorageValues(address target, bytes32[] memory commands, bytes[] memory constants, bytes32 stateRoot, StateProof memory proof) internal pure returns(bytes[] memory values) {
-        bytes32 storageRoot = getStorageRoot(stateRoot, target, proof.stateTrieWitness);
+    function getStorageValues(
+        address target,
+        function(address,uint256,bytes memory, bytes32) internal view returns(bytes memory) getter,
+        bytes32[] memory commands, bytes[] memory constants, bytes32 storageRoot, bytes[] memory proof) internal view returns(bytes[] memory values
+    ) {
         uint256 proofIdx = 0;
         values = new bytes[](commands.length);
         for(uint256 i = 0; i < commands.length; i++) {
             bytes32 command = commands[i];
             (bool isDynamic, uint256 slot) = computeFirstSlot(command, constants, values);
             if(!isDynamic) {
-                values[i] = abi.encode(getFixedValue(storageRoot, slot, proof.storageProofs[proofIdx++]));
+                values[i] = abi.encode(getFixedValue(target, getter, storageRoot, slot, proof[proofIdx++]));
                 if(values[i].length > 32) {
                     revert InvalidSlotSize(values[i].length);
                 }
             } else {
-                (values[i], proofIdx) = getDynamicValue(storageRoot, slot, proof, proofIdx);
+                (values[i], proofIdx) = getDynamicValue(target, getter, storageRoot, slot, proof, proofIdx);
             }
         }
     }