@aztec/aztec-node 0.1.0-alpha20 → 0.1.0-alpha22

package/src/aztec-node/http-node.test.ts

@@ -0,0 +1,428 @@
+import { AztecAddress, CircuitsWasm, Fr } from '@aztec/circuits.js';
+import { randomBytes } from '@aztec/foundation/crypto';
+import { Pedersen, SiblingPath } from '@aztec/merkle-tree';
+import {
+  ContractData,
+  ContractPublicData,
+  L1ToL2Message,
+  L2Block,
+  L2BlockL2Logs,
+  LogType,
+  MerkleTreeId,
+  mockTx,
+  TxHash,
+} from '@aztec/types';
+import { jest } from '@jest/globals';
+import { HttpNode } from './http-node.js';
+
+const TEST_URL = 'http://aztec-node-url.com/';
+
+const setFetchMock = (response: any, status = 200): void => {
+  global.fetch = jest
+    .fn<typeof global.fetch>()
+    .mockImplementation((_input: RequestInfo | URL, _init?: RequestInit | undefined) => {
+      return Promise.resolve({
+        status,
+        ok: true,
+        json: () => response,
+        arrayBuffer: () => response,
+      } as Response);
+    });
+};
+
+describe('HttpNode', () => {
+  let httpNode: HttpNode;
+  let pedersen: Pedersen;
+
+  beforeAll(async () => {
+    httpNode = new HttpNode(TEST_URL);
+    pedersen = new Pedersen(await CircuitsWasm.get());
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('isReady', () => {
+    it.each([true, false])('should return %s when the node is ready', async () => {
+      const response = { isReady: true };
+      setFetchMock(response);
+
+      const result = await httpNode.isReady();
+
+      expect(fetch).toHaveBeenCalledWith(TEST_URL);
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('getBlocks', () => {
+    it('should fetch and parse blocks', async () => {
+      const block1 = L2Block.random(1);
+      const block2 = L2Block.random(2);
+      const response = {
+        blocks: [block1.encode(), block2.encode()],
+      };
+      setFetchMock(response);
+
+      const result = await httpNode.getBlocks(0, 3);
+
+      expect(fetch).toHaveBeenCalledWith(`${TEST_URL}get-blocks?from=0&take=3`);
+      expect(result).toEqual([block1, block2]);
+    });
+
+    it('should return an empty array if blocks are not available', async () => {
+      const response = { blocks: [] };
+      setFetchMock(response);
+
+      const result = await httpNode.getBlocks(0, 2);
+
+      expect(fetch).toHaveBeenCalledWith(`${TEST_URL}get-blocks?from=0&take=2`);
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('getBlockHeight', () => {
+    it('should fetch and return the block height', async () => {
+      const response = { blockHeight: 100 };
+      setFetchMock(response);
+
+      const result = await httpNode.getBlockHeight();
+
+      expect(fetch).toHaveBeenCalledWith(`${TEST_URL}get-block-height`);
+      expect(result).toBe(100);
+    });
+  });
+
+  describe('getVersion', () => {
+    it('should fetch and return the version', async () => {
+      const response = { version: 5 };
+      setFetchMock(response);
+
+      const result = await httpNode.getVersion();
+
+      expect(fetch).toHaveBeenCalledWith(`${TEST_URL}get-version`);
+      expect(result).toBe(5);
+    });
+  });
+
+  describe('getChainId', () => {
+    it('should fetch and return the chain ID', async () => {
+      const response = { chainId: 1234 };
+      setFetchMock(response);
+
+      const result = await httpNode.getChainId();
+
+      expect(fetch).toHaveBeenCalledWith(`${TEST_URL}get-chain-id`);
+      expect(result).toBe(1234);
+    });
+  });
+
+  describe('getContractData', () => {
+    it('should fetch and return contract public data', async () => {
+      const contractData = ContractPublicData.random();
+      const response = {
+        contractData: contractData.toBuffer(),
+      };
+
+      setFetchMock(response);
+
+      const result = await httpNode.getContractData(contractData.contractData.contractAddress);
+
+      expect(fetch).toHaveBeenCalledWith(
+        `${TEST_URL}contract-data?address=${contractData.contractData.contractAddress.toString()}`,
+      );
+      expect(result).toEqual(contractData);
+    });
+
+    it('should return undefined if contract data is not available', async () => {
+      const response = {
+        contractData: undefined,
+      };
+      setFetchMock(response);
+
+      const randomAddress = AztecAddress.random();
+
+      const result = await httpNode.getContractData(randomAddress);
+
+      expect(fetch).toHaveBeenCalledWith(`${TEST_URL}contract-data?address=${randomAddress.toString()}`);
+      expect(result).toEqual(undefined);
+    });
+  });
+
+  describe('getLogs', () => {
+    it.each(['encrypted', 'unencrypted'])('should fetch and return %s logs', async logType => {
+      const processedLogType = logType === 'encrypted' ? LogType.ENCRYPTED : LogType.UNENCRYPTED;
+
+      const from = 0;
+      const take = 3;
+      const log1 = L2BlockL2Logs.random(2, 3, 4);
+      const log2 = L2BlockL2Logs.random(1, 5, 2);
+      const response = {
+        logs: [log1.toBuffer(), log2.toBuffer()],
+      };
+      setFetchMock(response);
+
+      const result = await httpNode.getLogs(from, take, processedLogType);
+
+      expect(fetch).toHaveBeenCalledWith(`${TEST_URL}get-logs?from=${from}&take=${take}&logType=${processedLogType}`);
+      expect(result).toEqual([log1, log2]);
+    });
+
+    it.each(['encrypted', 'unencrypted'])(
+      'should return an empty array if %s logs are not available',
+      async logType => {
+        const processedLogType = logType === 'encrypted' ? LogType.ENCRYPTED : LogType.UNENCRYPTED;
+
+        const from = 0;
+        const take = 2;
+        const response = {};
+        setFetchMock(response);
+
+        const result = await httpNode.getLogs(from, take, processedLogType);
+
+        expect(fetch).toHaveBeenCalledWith(`${TEST_URL}get-logs?from=${from}&take=${take}&logType=${processedLogType}`);
+        expect(result).toEqual([]);
+      },
+    );
+  });
+
+  describe('getContractInfo', () => {
+    it('should fetch and return contract data', async () => {
+      const contractInfo = ContractData.random();
+      const response = {
+        contractInfo: contractInfo.toBuffer(),
+      };
+      setFetchMock(response);
+
+      const result = await httpNode.getContractInfo(contractInfo.contractAddress);
+
+      expect(fetch).toHaveBeenCalledWith(`${TEST_URL}contract-info?address=${contractInfo.contractAddress.toString()}`);
+      expect(result).toEqual(contractInfo);
+    });
+
+    it('should return undefined if contract data is not available', async () => {
+      const response = {
+        contractInfo: undefined,
+      };
+      setFetchMock(response);
+
+      const randomAddress = AztecAddress.random();
+
+      const result = await httpNode.getContractInfo(randomAddress);
+
+      expect(fetch).toHaveBeenCalledWith(`${TEST_URL}contract-info?address=${randomAddress.toString()}`);
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('sendTx', () => {
+    it('should submit a transaction to the p2p pool', async () => {
+      const tx = mockTx();
+      const irrelevantResponse = {};
+      setFetchMock(irrelevantResponse);
+
+      await httpNode.sendTx(tx);
+
+      const init: RequestInit = {
+        method: 'POST',
+        body: tx.toBuffer(),
+      };
+      const call = (fetch as jest.Mock).mock.calls[0] as any[];
+      expect(call[0].href).toBe(`${TEST_URL}tx`);
+      expect(call[1]).toStrictEqual(init);
+    });
+  });
+
+  describe('getPendingTxByHash', () => {
+    it('should fetch and return a pending tx', async () => {
+      const txHash = new TxHash(randomBytes(TxHash.SIZE));
+      const tx = mockTx();
+      const response = tx.toBuffer();
+      setFetchMock(response);
+
+      const result = await httpNode.getPendingTxByHash(txHash);
+
+      expect(fetch).toHaveBeenCalledWith(`${TEST_URL}get-pending-tx?hash=${txHash}`);
+      expect(result).toEqual(tx);
+    });
+
+    it('should return undefined if the pending tx does not exist', async () => {
+      const txHash = new TxHash(randomBytes(TxHash.SIZE));
+      const response = undefined;
+      setFetchMock(response, 404);
+
+      const result = await httpNode.getPendingTxByHash(txHash);
+
+      expect(fetch).toHaveBeenCalledWith(`${TEST_URL}get-pending-tx?hash=${txHash}`);
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('findContractIndex', () => {
+    it('should fetch and return the index of the given contract', async () => {
+      const leafValue = Buffer.from('abc123', 'hex');
+      const index = '123456';
+      const response = { index };
+      setFetchMock(response);
+
+      const result = await httpNode.findContractIndex(leafValue);
+
+      expect(fetch).toHaveBeenCalledWith(`${TEST_URL}contract-index?leaf=${leafValue.toString('hex')}`);
+      expect(result).toBe(BigInt(index));
+    });
+
+    it('should return undefined if the contract index is not found', async () => {
+      const leafValue = Buffer.from('def456', 'hex');
+      const response = {};
+      setFetchMock(response);
+
+      const result = await httpNode.findContractIndex(leafValue);
+
+      expect(fetch).toHaveBeenCalledWith(`${TEST_URL}contract-index?leaf=${leafValue.toString('hex')}`);
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('getContractPath', () => {
+    it('should fetch and return the sibling path for the given leaf index', async () => {
+      const leafIndex = BigInt(123456);
+      const siblingPath = SiblingPath.ZERO(3, Buffer.alloc(32), pedersen);
+      const response = { path: siblingPath.toBuffer().toString('hex') };
+      setFetchMock(response);
+
+      const result = await httpNode.getContractPath(leafIndex);
+
+      expect(fetch).toHaveBeenCalledWith(`${TEST_URL}contract-path?leaf=${leafIndex.toString()}`);
+      expect(result).toEqual(siblingPath);
+    });
+  });
+
+  describe('findCommitmentIndex', () => {
+    it('should fetch and return the index of the given leaf', async () => {
+      const leafValue = Buffer.from('0123456789', 'hex');
+      const expectedIndex = BigInt(123);
+      const response = { index: expectedIndex.toString() };
+      setFetchMock(response);
+
+      const result = await httpNode.findCommitmentIndex(leafValue);
+
+      expect(fetch).toHaveBeenCalledWith(`${TEST_URL}commitment-index?leaf=${leafValue.toString('hex')}`);
+      expect(result).toBe(expectedIndex);
+    });
+
+    it('should return undefined if the commitment index is not found', async () => {
+      const leafValue = Buffer.from('def456', 'hex');
+      const response = {};
+      setFetchMock(response);
+
+      const result = await httpNode.findCommitmentIndex(leafValue);
+
+      expect(fetch).toHaveBeenCalledWith(`${TEST_URL}commitment-index?leaf=${leafValue.toString('hex')}`);
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('getDataTreePath', () => {
+    it('should fetch and return the sibling path for the given leaf index', async () => {
+      const leafIndex = BigInt(123456);
+      const siblingPath = SiblingPath.ZERO(3, Buffer.alloc(32), pedersen);
+      const response = { path: siblingPath.toBuffer().toString('hex') };
+      setFetchMock(response);
+
+      const result = await httpNode.getDataTreePath(leafIndex);
+
+      expect(fetch).toHaveBeenCalledWith(`${TEST_URL}data-path?leaf=${leafIndex.toString()}`);
+      expect(result).toEqual(siblingPath);
+    });
+  });
+
+  describe('getL1ToL2MessageAndIndex', () => {
+    it('should fetch and return the L1 to L2 message and index for the given message key', async () => {
+      const messageKey = new Fr(789);
+      const expectedMessage = L1ToL2Message.random();
+      const expectedIndex = BigInt(123);
+      const response = { message: expectedMessage.toBuffer().toString('hex'), index: expectedIndex.toString() };
+      setFetchMock(response);
+
+      const result = await httpNode.getL1ToL2MessageAndIndex(messageKey);
+
+      expect(fetch).toHaveBeenCalledWith(`${TEST_URL}l1-l2-message?messageKey=${messageKey.toString()}`);
+      expect(result).toEqual({
+        message: expectedMessage,
+        index: expectedIndex,
+      });
+    });
+  });
+
+  describe('getL1ToL2MessagesTreePath', () => {
+    it('should fetch and return the sibling path for the given leaf index', async () => {
+      const leafIndex = BigInt(123456);
+      const siblingPath = SiblingPath.ZERO(3, Buffer.alloc(32), pedersen);
+      const response = { path: siblingPath.toBuffer().toString('hex') };
+      setFetchMock(response);
+
+      const result = await httpNode.getL1ToL2MessagesTreePath(leafIndex);
+
+      const url = `${TEST_URL}l1-l2-path?leaf=${leafIndex.toString()}`;
+      expect(fetch).toHaveBeenCalledWith(url);
+      expect(result).toEqual(siblingPath);
+    });
+  });
+
+  describe('getStorageAt', () => {
+    it('should fetch and return the storage value at the given contract slot', async () => {
+      const contractAddress = AztecAddress.random();
+      const slot = BigInt(789);
+      const storageValue = Buffer.from('0123456789', 'hex');
+      const response = { value: storageValue.toString('hex') };
+      setFetchMock(response);
+
+      const result = await httpNode.getStorageAt(contractAddress, slot);
+
+      const url = `${TEST_URL}storage-at?address=${contractAddress}&slot=${slot.toString()}`;
+      expect(fetch).toHaveBeenCalledWith(url);
+      expect(result).toEqual(storageValue);
+    });
+
+    it('should return undefined if the storage value is not found', async () => {
+      const contractAddress = AztecAddress.random();
+      const slot = BigInt(987);
+      const response = {};
+      setFetchMock(response);
+
+      const result = await httpNode.getStorageAt(contractAddress, slot);
+
+      const url = `${TEST_URL}storage-at?address=${contractAddress}&slot=${slot.toString()}`;
+      expect(fetch).toHaveBeenCalledWith(url);
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('getTreeRoots', () => {
+    it('should fetch and return the current committed roots for the data trees', async () => {
+      const roots: Record<MerkleTreeId, Fr> = {
+        [MerkleTreeId.CONTRACT_TREE]: Fr.random(),
+        [MerkleTreeId.PRIVATE_DATA_TREE]: Fr.random(),
+        [MerkleTreeId.NULLIFIER_TREE]: Fr.random(),
+        [MerkleTreeId.PUBLIC_DATA_TREE]: Fr.random(),
+        [MerkleTreeId.L1_TO_L2_MESSAGES_TREE]: Fr.random(),
+        [MerkleTreeId.L1_TO_L2_MESSAGES_ROOTS_TREE]: Fr.random(),
+        [MerkleTreeId.CONTRACT_TREE_ROOTS_TREE]: Fr.random(),
+        [MerkleTreeId.PRIVATE_DATA_TREE_ROOTS_TREE]: Fr.random(),
+      };
+
+      const rootsInResponse: Record<MerkleTreeId, string> = Object.fromEntries(
+        Object.entries(roots).map(([key, value]) => [key, value.toString()]),
+      ) as Record<MerkleTreeId, string>;
+      const response = { roots: rootsInResponse };
+
+      setFetchMock(response);
+
+      const result = await httpNode.getTreeRoots();
+
+      const url = `${TEST_URL}tree-roots`;
+      expect(fetch).toHaveBeenCalledWith(url);
+      expect(result).toEqual(roots);
+    });
+  });
+});

package/src/aztec-node/http-node.ts

@@ -3,76 +3,34 @@ import {
   AztecAddress,
   CONTRACT_TREE_HEIGHT,
   Fr,
-  KernelCircuitPublicInputs,
-  L1_TO_L2_MESSAGES_TREE_HEIGHT,
+  L1_TO_L2_MSG_TREE_HEIGHT,
   PRIVATE_DATA_TREE_HEIGHT,
-  Proof,
-  PublicCallRequest,
 } from '@aztec/circuits.js';
+import { Logger, createLogger } from '@aztec/foundation/log';
 import { SiblingPath } from '@aztec/merkle-tree';
 import {
   ContractData,
   ContractPublicData,
-  EncodedContractFunction,
   L1ToL2Message,
   L1ToL2MessageAndIndex,
   L2Block,
   L2BlockL2Logs,
+  LogType,
   MerkleTreeId,
   Tx,
   TxHash,
-  TxL2Logs,
 } from '@aztec/types';
 
-/**
- * Serialises a transaction to JSON representation.
- * @param tx - The transaction to serialise.
- * @returns The serialsied transaction.
- */
-export function txToJson(tx: Tx) {
-  return {
-    data: tx.data?.toBuffer().toString('hex'),
-    encryptedLogs: tx.encryptedLogs?.toBuffer().toString('hex'),
-    unencryptedLogs: tx.unencryptedLogs?.toBuffer().toString('hex'),
-    proof: tx.proof?.toBuffer().toString('hex'),
-    newContractPublicFunctions: tx.newContractPublicFunctions?.map(f => f.toBuffer().toString('hex')) ?? [],
-    enqueuedPublicFunctions: tx.enqueuedPublicFunctionCalls?.map(f => f.toBuffer().toString('hex')) ?? [],
-  };
-}
-
-/**
- * Deserialises a transaction from JSON.
- * @param json - The JSON representation of the transaction.
- * @returns The deserialised transaction.
- */
-export function txFromJson(json: any) {
-  const publicInputs = KernelCircuitPublicInputs.fromBuffer(Buffer.from(json.data, 'hex'));
-  const encryptedLogs = TxL2Logs.fromBuffer(Buffer.from(json.encryptedLogs, 'hex'));
-  const unencryptedLogs = TxL2Logs.fromBuffer(Buffer.from(json.unencryptedLogs, 'hex'));
-  const proof = Buffer.from(json.proof, 'hex');
-  const newContractPublicFunctions = json.newContractPublicFunctions?.length
-    ? json.newContractPublicFunctions.map((x: string) => EncodedContractFunction.fromBuffer(Buffer.from(x, 'hex')))
-    : [];
-  const enqueuedPublicFunctions = json.enqueuedPublicFunctions?.length
-    ? json.enqueuedPublicFunctions.map((x: string) => PublicCallRequest.fromBuffer(Buffer.from(x, 'hex')))
-    : [];
-  return new Tx(
-    publicInputs,
-    Proof.fromBuffer(proof),
-    encryptedLogs,
-    unencryptedLogs,
-    newContractPublicFunctions,
-    enqueuedPublicFunctions,
-  );
-}
-
 /**
  * A Http client based implementation of Aztec Node.
  */
 export class HttpNode implements AztecNode {
   private baseUrl: string;
-  constructor(baseUrl: string) {
+  private log: Logger;
+
+  constructor(baseUrl: string, log = createLogger('aztec:http-node')) {
     this.baseUrl = baseUrl.toString().replace(/\/$/, '');
+    this.log = log;
   }
   /**
    * Method to determine if the node is ready to accept transactions.
@@ -120,7 +78,7 @@ export class HttpNode implements AztecNode {
    * Method to fetch the version of the rollup the node is connected to.
    * @returns The rollup version.
    */
-  public async getVersion(): Promise<Fr> {
+  public async getVersion(): Promise<number> {
     const url = new URL(`${this.baseUrl}/get-version`);
     const response = await fetch(url.toString());
     const respJson = await response.json();
@@ -131,7 +89,7 @@ export class HttpNode implements AztecNode {
    * Method to fetch the chain id of the base-layer for the rollup.
    * @returns The chain id.
    */
-  public async getChainId(): Promise<Fr> {
+  public async getChainId(): Promise<number> {
     const url = new URL(`${this.baseUrl}/get-chain-id`);
     const response = await fetch(url.toString());
     const respJson = await response.json();
@@ -148,55 +106,39 @@ export class HttpNode implements AztecNode {
     const url = new URL(`${this.baseUrl}/contract-data`);
     url.searchParams.append('address', contractAddress.toString());
     const response = await (await fetch(url.toString())).json();
+    if (!response || !response.contractData) {
+      return undefined;
+    }
     const contract = response.contractData as string;
     return Promise.resolve(ContractPublicData.fromBuffer(Buffer.from(contract, 'hex')));
   }
 
   /**
-   * Gets the `take` amount of encrypted logs starting from `from`.
-   * @param from - Number of the L2 block to which corresponds the first encrypted logs to be returned.
-   * @param take - The number of encrypted logs to return.
-   * @returns The requested encrypted logs.
+   * Gets the `take` amount of logs starting from `from`.
+   * @param from - Number of the L2 block to which corresponds the first logs to be returned.
+   * @param take - The number of logs to return.
+   * @param logType - Specifies whether to return encrypted or unencrypted logs.
+   * @returns The requested logs.
    */
-  public async getEncryptedLogs(from: number, take: number): Promise<L2BlockL2Logs[]> {
-    const url = new URL(`${this.baseUrl}/get-encrypted-logs`);
-    url.searchParams.append('from', from.toString());
-    if (take !== undefined) {
-      url.searchParams.append('take', take.toString());
-    }
-    const response = await (await fetch(url.toString())).json();
-    const encryptedLogs = response.encryptedLogs as string[];
+  public async getLogs(from: number, take: number, logType: LogType): Promise<L2BlockL2Logs[]> {
+    const url = new URL(`${this.baseUrl}/get-logs`);
 
-    if (!encryptedLogs) {
-      return Promise.resolve([]);
-    }
-    return Promise.resolve(encryptedLogs.map(x => L2BlockL2Logs.fromBuffer(Buffer.from(x, 'hex'))));
-  }
-
-  /**
-   * Gets the `take` amount of unencrypted logs starting from `from`.
-   * @param from - Number of the L2 block to which corresponds the first unencrypted logs to be returned.
-   * @param take - The number of unencrypted logs to return.
-   * @returns The requested unencrypted logs.
-   */
-  public async getUnencryptedLogs(from: number, take: number): Promise<L2BlockL2Logs[]> {
-    const url = new URL(`${this.baseUrl}/get-unencrypted-logs`);
     url.searchParams.append('from', from.toString());
-    if (take !== undefined) {
-      url.searchParams.append('take', take.toString());
-    }
+    url.searchParams.append('take', take.toString());
+    url.searchParams.append('logType', logType.toString());
+
     const response = await (await fetch(url.toString())).json();
-    const unencryptedLogs = response.unencryptedLogs as string[];
+    const logs = response.logs as string[];
 
-    if (!unencryptedLogs) {
+    if (!logs) {
       return Promise.resolve([]);
     }
-    return Promise.resolve(unencryptedLogs.map(x => L2BlockL2Logs.fromBuffer(Buffer.from(x, 'hex'))));
+    return Promise.resolve(logs.map(x => L2BlockL2Logs.fromBuffer(Buffer.from(x, 'hex'))));
   }
 
   /**
    * Lookup the L2 contract info for this contract.
-   * Contains the ethereum portal address .
+   * Contains the ethereum portal address.
    * @param contractAddress - The contract data address.
    * @returns The contract's address & portal address.
    */
@@ -204,6 +146,9 @@ export class HttpNode implements AztecNode {
     const url = new URL(`${this.baseUrl}/contract-info`);
     url.searchParams.append('address', contractAddress.toString());
     const response = await (await fetch(url.toString())).json();
+    if (!response || !response.contractInfo) {
+      return undefined;
+    }
     const contract = response.contractInfo as string;
     return Promise.resolve(ContractData.fromBuffer(Buffer.from(contract, 'hex')));
   }
@@ -214,10 +159,9 @@ export class HttpNode implements AztecNode {
    */
   async sendTx(tx: Tx): Promise<void> {
     const url = new URL(`${this.baseUrl}/tx`);
-    const json = txToJson(tx);
     const init: RequestInit = {};
     init['method'] = 'POST';
-    init['body'] = JSON.stringify(json);
+    init['body'] = tx.toBuffer();
     await fetch(url, init);
   }
 
@@ -237,8 +181,14 @@ export class HttpNode implements AztecNode {
   async getPendingTxByHash(txHash: TxHash): Promise<Tx | undefined> {
     const url = new URL(`${this.baseUrl}/get-pending-tx`);
     url.searchParams.append('hash', txHash.toString());
-    const response = await (await fetch(url.toString())).json();
-    return Promise.resolve(txFromJson(response));
+    const response = await fetch(url.toString());
+    if (response.status === 404) {
+      this.log(`Tx ${txHash.toString()} not found`);
+      return undefined;
+    }
+    const txBuffer = Buffer.from(await (await fetch(url.toString())).arrayBuffer());
+    const tx = Tx.fromBuffer(txBuffer);
+    return Promise.resolve(tx);
   }
 
   /**
@@ -250,6 +200,9 @@ export class HttpNode implements AztecNode {
     const url = new URL(`${this.baseUrl}/contract-index`);
     url.searchParams.append('leaf', leafValue.toString('hex'));
     const response = await (await fetch(url.toString())).json();
+    if (!response || !response.index) {
+      return undefined;
+    }
     const index = response.index as string;
     return Promise.resolve(BigInt(index));
   }
@@ -276,6 +229,9 @@ export class HttpNode implements AztecNode {
     const url = new URL(`${this.baseUrl}/commitment-index`);
     url.searchParams.append('leaf', leafValue.toString('hex'));
     const response = await (await fetch(url.toString())).json();
+    if (!response || !response.index) {
+      return undefined;
+    }
     const index = response.index as string;
     return Promise.resolve(BigInt(index));
   }
@@ -313,7 +269,7 @@ export class HttpNode implements AztecNode {
    * @param leafIndex - Index of the leaf in the tree.
    * @returns The sibling path.
    */
-  async getL1ToL2MessagesTreePath(leafIndex: bigint): Promise<SiblingPath<typeof L1_TO_L2_MESSAGES_TREE_HEIGHT>> {
+  async getL1ToL2MessagesTreePath(leafIndex: bigint): Promise<SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>> {
     const url = new URL(`${this.baseUrl}/l1-l2-path`);
     url.searchParams.append('leaf', leafIndex.toString());
     const response = await (await fetch(url.toString())).json();
@@ -333,6 +289,9 @@ export class HttpNode implements AztecNode {
     url.searchParams.append('address', contract.toString());
     url.searchParams.append('slot', slot.toString());
     const response = await (await fetch(url.toString())).json();
+    if (!response || !response.value) {
+      return undefined;
+    }
     const value = response.value as string;
     return Promise.resolve(Buffer.from(value, 'hex'));
   }
@@ -345,7 +304,11 @@ export class HttpNode implements AztecNode {
     const url = new URL(`${this.baseUrl}/tree-roots`);
     const response = await (await fetch(url.toString())).json();
 
-    const extractRoot = (treeId: MerkleTreeId) => Fr.fromBuffer(Buffer.from(response.roots[`${treeId}`], 'hex'));
+    const extractRoot = (treeId: MerkleTreeId) => {
+      // Buffer.from(...) returns an empty buffer when a hex string is prefixed with "0x"
+      const rootHexString = response.roots[treeId].replace(/^0x/, '');
+      return Fr.fromBuffer(Buffer.from(rootHexString, 'hex'));
+    };
 
     return {
       [MerkleTreeId.CONTRACT_TREE]: extractRoot(MerkleTreeId.CONTRACT_TREE),