CallWithTrieNodes in progress

contracts/Challenge.sol

 // SPDX-License-Identifier: MIT
 pragma solidity ^0.7.3;
+pragma experimental ABIEncoderV2;
 
 import "./lib/Lib_RLPReader.sol";
 import "hardhat/console.sol";
@@ -10,6 +11,7 @@ interface IMIPS {
 }
 
 interface IMIPSMemory {
+  function AddTrieNode(bytes calldata anything) external;
   function ReadMemory(bytes32 stateHash, uint32 addr) external view returns (uint32);
   function ReadBytes32(bytes32 stateHash, uint32 addr) external view returns (bytes32);
   function WriteMemory(bytes32 stateHash, uint32 addr, uint32 val) external returns (bytes32);
@@ -74,6 +76,22 @@ contract Challenge {
     return challengeId;
   }
 
+  // helper function to determine what nodes we need
+  function CallWithTrieNodes(bytes calldata dat, bytes[] calldata nodes) public {
+    for (uint i = 0; i < nodes.length; i++) {
+      mem.AddTrieNode(nodes[i]);
+    }
+    (bool success, bytes memory revertData) = address(this).call(dat);
+    // TODO: better way to revert?
+    if (!success) {
+      uint256 revertDataLength = revertData.length;
+      assembly {
+          let revertDataStart := add(revertData, 32)
+          revert(revertDataStart, revertDataLength)
+      }
+    }
+  }
+
   function InitiateChallenge(uint blockNumberN, bytes calldata blockHeaderNp1,
         bytes32 assertionRoot, bytes32 finalSystemState, uint256 stepCount) external returns (uint256) {
     bytes32 computedBlockHash = keccak256(blockHeaderNp1);

contracts/lib/Lib_MerkleTrie.sol

@@ -111,13 +111,7 @@ library Lib_MerkleTrie {
                     node[i] = bytes1(uint8(node[i]) + uint8(0x61-10));
                 }
             }
-            // Error(string)
-            bytes memory revertData = abi.encodeWithSelector(0x08c379a0, string(node));
-            uint256 revertDataLength = revertData.length;
-            assembly {
-                let revertDataStart := add(revertData, 32)
-                revert(revertDataStart, revertDataLength)
-            }
+            revert(string(node));
         }
         require(keccak256(encoded) == nodeId, "bad hash in trie lookup");
         return getRawNode(encoded);

test/challenge_test.js

@@ -26,23 +26,23 @@ describe("Challenge contract", function () {
 
     const assertionRoot = "0x9e0261efe4509912b8862f3d45a0cb8404b99b239247df9c55871bd3844cebbd"
     let startTrie = JSON.parse(fs.readFileSync("/tmp/cannon/golden.json"))
-    let finalTrie = JSON.parse(fs.readFileSync("/tmp/cannon/0_13284469/checkpoint_85059435.json"))
+    let finalTrie = JSON.parse(fs.readFileSync("/tmp/cannon/0_13284469/checkpoint_final.json"))
+    let preimages = Object.assign({}, startTrie['preimages'], finalTrie['preimages']);
     const finalSystemState = finalTrie['root']
 
+    let cdat = c.interface.encodeFunctionData("InitiateChallenge", [blockNumberN, blockNp1Rlp, assertionRoot, finalSystemState, 1])
+
     while (1) {
       try {
         // TODO: make this eth call?
-        // needs something like InitiateChallengeWithTrieNodes
-        await c.InitiateChallenge(blockNumberN, blockNp1Rlp, assertionRoot, finalSystemState, 1)
+        // needs something like InitiateChallengeWithTrieNodesj
+        await c.CallWithTrieNodes(cdat, [])
         break
       } catch(e) {
         const missing = e.toString().split("'")[1]
         if (missing.length == 64) {
           console.log("requested node", missing)
-          let node = startTrie['preimages']["0x"+missing]
-          if (node === undefined) {
-            node = finalTrie['preimages']["0x"+missing]
-          }
+          let node = preimages["0x"+missing]
           expect(node).to.not.be.an('undefined')
           const bin = Uint8Array.from(Buffer.from(node, 'base64').toString('binary'), c => c.charCodeAt(0))
           await mm.AddTrieNode(bin)