Add Queries Section

.snippets/code/build/build-multichain-applications/queries/hands-on-with-queries/eth-call-initial-request.txt

@@ -0,0 +1 @@
+curl https://ethereum.publicnode.com -X POST --data '{"jsonrpc":"2.0","method":"eth_call","params":[{"to":"0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2","data":"0x18160ddd"},"latest"],"id":1}'

.snippets/code/build/build-multichain-applications/queries/hands-on-with-queries/eth-call-initial-response.txt

@@ -0,0 +1,5 @@
+{
+  "jsonrpc":"2.0",
+  "id":1,
+  "result":"0x000000000000000000000000000000000000000000029fd3d129b582d7949e71"
+}

.snippets/code/build/build-multichain-applications/queries/hands-on-with-queries/query-demo.sol

@@ -0,0 +1,137 @@
+// contracts/query/QueryDemo.sol
+// SPDX-License-Identifier: Apache 2
+
+pragma solidity ^0.8.0;
+
+import "wormhole-solidity-sdk/libraries/BytesParsing.sol";
+import "wormhole-solidity-sdk/interfaces/IWormhole.sol";
+import "wormhole-solidity-sdk/QueryResponse.sol";
+
+error InvalidOwner();
+// @dev for the onlyOwner modifier
+error InvalidCaller();
+error InvalidCalldata();
+error InvalidForeignChainID();
+error ObsoleteUpdate();
+error StaleUpdate();
+error UnexpectedResultLength();
+error UnexpectedResultMismatch();
+
+/// @dev QueryDemo is an example of using the QueryResponse library to parse and verify Cross Chain Query (CCQ) responses.
+contract QueryDemo is QueryResponse {
+    using BytesParsing for bytes;
+
+    struct ChainEntry {
+        uint16 chainID;
+        address contractAddress;
+        uint256 counter;
+        uint256 blockNum;
+        uint256 blockTime;
+    }
+
+    address private immutable owner;
+    uint16 private immutable myChainID;
+    mapping(uint16 => ChainEntry) private counters;
+    uint16[] private foreignChainIDs;
+
+    bytes4 public GetMyCounter = bytes4(hex"916d5743");
+
+    constructor(address _owner, address _wormhole, uint16 _myChainID) QueryResponse(_wormhole) {
+        if (_owner == address(0)) {
+            revert InvalidOwner();
+        }
+        owner = _owner;
+
+        myChainID = _myChainID;
+        counters[_myChainID] = ChainEntry(_myChainID, address(this), 0, 0, 0);
+    }
+
+    // updateRegistration should be used to add the other chains and to set / update contract addresses.
+    function updateRegistration(uint16 _chainID, address _contractAddress) public onlyOwner {
+        if (counters[_chainID].chainID == 0) {
+            foreignChainIDs.push(_chainID);
+            counters[_chainID].chainID = _chainID;
+        }
+
+        counters[_chainID].contractAddress = _contractAddress;
+    }
+
+    // getMyCounter (call signature 916d5743) returns the counter value for this chain. It is meant to be used in a cross chain query.
+    function getMyCounter() public view returns (uint256) {
+        return counters[myChainID].counter;
+    }
+
+    // getState() returns this chain's view of all the counters. It is meant to be used in the front end.
+    function getState() public view returns (ChainEntry[] memory) {
+        ChainEntry[] memory ret = new ChainEntry[](foreignChainIDs.length + 1);
+        ret[0] = counters[myChainID];
+        uint256 length = foreignChainIDs.length;
+
+        for (uint256 i = 0; i < length;) {
+            ret[i + 1] = counters[foreignChainIDs[i]];
+            unchecked {
+                ++i;
+            }
+        }
+
+        return ret;
+    }
+
+    // @notice Takes the cross chain query response for the other counters, stores the results for the other chains, and updates the counter for this chain.
+    function updateCounters(bytes memory response, IWormhole.Signature[] memory signatures) public {
+        ParsedQueryResponse memory r = parseAndVerifyQueryResponse(response, signatures);
+        uint256 numResponses = r.responses.length;
+        if (numResponses != foreignChainIDs.length) {
+            revert UnexpectedResultLength();
+        }
+
+        for (uint256 i = 0; i < numResponses;) {
+            // Create a storage pointer for frequently read and updated data stored on the blockchain
+            ChainEntry storage chainEntry = counters[r.responses[i].chainId];
+            if (chainEntry.chainID != foreignChainIDs[i]) {
+                revert InvalidForeignChainID();
+            }
+
+            EthCallQueryResponse memory eqr = parseEthCallQueryResponse(r.responses[i]);
+
+            // Validate that update is not obsolete
+            validateBlockNum(eqr.blockNum, chainEntry.blockNum);
+
+            // Validate that update is not stale
+            validateBlockTime(eqr.blockTime, block.timestamp - 300);
+
+            if (eqr.result.length != 1) {
+                revert UnexpectedResultMismatch();
+            }
+
+            // Validate addresses and function signatures
+            address[] memory validAddresses = new address[](1);
+            bytes4[] memory validFunctionSignatures = new bytes4[](1);
+            validAddresses[0] = chainEntry.contractAddress;
+            validFunctionSignatures[0] = GetMyCounter;
+
+            validateMultipleEthCallData(eqr.result, validAddresses, validFunctionSignatures);
+
+            require(eqr.result[0].result.length == 32, "result is not a uint256");
+
+            chainEntry.blockNum = eqr.blockNum;
+            chainEntry.blockTime = eqr.blockTime / 1_000_000;
+            chainEntry.counter = abi.decode(eqr.result[0].result, (uint256));
+
+            unchecked {
+                ++i;
+            }
+        }
+
+        counters[myChainID].blockNum = block.number;
+        counters[myChainID].blockTime = block.timestamp;
+        counters[myChainID].counter += 1;
+    }
+
+    modifier onlyOwner() {
+        if (owner != msg.sender) {
+            revert InvalidOwner();
+        }
+        _;
+    }
+}

.snippets/code/build/build-multichain-applications/queries/hands-on-with-queries/query-proxy-query-response.jsx

@@ -0,0 +1,4 @@
+const tx = await contract.updateCounters(
+  `0x${response.data.bytes}`,
+  signaturesToEvmStruct(response.data.signatures)
+);

.snippets/code/build/build-multichain-applications/queries/hands-on-with-queries/query-request-with-api-key.jsx

@@ -0,0 +1,8 @@
+const serialized = request.serialize();
+const proxyResponse = (await axios.post)<QueryProxyQueryResponse>(
+  QUERY_URL,
+  {
+    bytes: Buffer.from(serialized).toString('hex'),
+  },
+  { headers: { 'X-API-Key': YOUR_API_KEY } }
+);

.snippets/code/build/build-multichain-applications/queries/hands-on-with-queries/test-full.jsx

@@ -0,0 +1,65 @@
+import {
+  EthCallData,
+  EthCallQueryRequest,
+  EthCallQueryResponse,
+  PerChainQueryRequest,
+  QueryProxyMock,
+  QueryRequest,
+  QueryResponse,
+} from '@wormhole-foundation/wormhole-query-sdk';
+import axios from 'axios';
+
+const rpc = 'https://ethereum.publicnode.com';
+const callData: EthCallData = {
+  to: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', // WETH
+  data: '0x18160ddd', // web3.eth.abi.encodeFunctionSignature("totalSupply()")
+};
+
+(async () => {
+  const latestBlock: string = (
+    await axios.post(rpc, {
+      method: 'eth_getBlockByNumber',
+      params: ['latest', false],
+      id: 1,
+      jsonrpc: '2.0',
+    })
+  ).data?.result?.number;
+  if (!latestBlock) {
+    console.error(`❌ Invalid block returned`);
+    return;
+  }
+  console.log('Latest Block:     ', latestBlock, `(${BigInt(latestBlock)})`);
+  const targetResponse = await axios.post(rpc, {
+    method: 'eth_call',
+    params: [callData, latestBlock],
+    id: 1,
+    jsonrpc: '2.0',
+  });
+  // console.log(finalizedResponse.data);
+  if (targetResponse.data.error) {
+    console.error(`❌ ${targetResponse.data.error.message}`);
+  }
+  const targetResult = targetResponse.data?.result;
+  console.log('Target Result:    ', targetResult, `(${BigInt(targetResult)})`);
+  // Form the query request
+  const request = new QueryRequest(
+    0, // Nonce
+    [
+      new PerChainQueryRequest(
+        2, // Ethereum Wormhole Chain ID
+        new EthCallQueryRequest(latestBlock, [callData])
+      ),
+    ]
+  );
+  console.log(JSON.stringify(request, undefined, 2));
+  const mock = new QueryProxyMock({ 2: rpc });
+  const mockData = await mock.mock(request);
+  console.log(mockData);
+  const mockQueryResponse = QueryResponse.from(mockData.bytes);
+  const mockQueryResult = (
+    mockQueryResponse.responses[0].response as EthCallQueryResponse
+  ).results[0];
+  console.log(
+    `Mock Query Result: ${mockQueryResult} (${BigInt(mockQueryResult)})`
+  );
+})();