diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index a57bab8..9b0e8a3 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -29,8 +29,9 @@ jobs:
     - name: Test with Jest
       run: |
         export PROVIDER_URI=${{ secrets.PROVIDER_URI }}
-        export PROVIDER_URI_GOERLI=${{ secrets.PROVIDER_URI_GOERLI }}
         export PROVIDER_URI_SEPOLIA=${{ secrets.PROVIDER_URI_SEPOLIA }}
+        export PROVIDER_URI_10=${{ secrets.PROVIDER_URI_10 }}
+        export PROVIDER_URI_8453=${{ secrets.PROVIDER_URI_8453 }}
         export PINATA_JWT=${{ secrets.PINATA_JWT }}
         export QUICKNODE_API_KEY=${{ secrets.QUICKNODE_API_KEY }}
         export QUICKNODE_IPFS_URL=${{ secrets.QUICKNODE_IPFS_URL }}
diff --git a/src/codec/v2/types.ts b/src/codec/v2/types.ts
index ae71f37..e7bb22c 100644
--- a/src/codec/v2/types.ts
+++ b/src/codec/v2/types.ts
@@ -190,8 +190,9 @@ export enum ReceiptField {
 }
 
 export enum TxType {
-  Legacy,
-  Eip2930,
-  Eip1559,
-  Eip4844,
+  Legacy = 0,
+  Eip2930 = 1,
+  Eip1559 = 2,
+  Eip4844 = 3,
+  OpSystem = 126, // 0x7E
 }
diff --git a/src/rpc/subqueryField.ts b/src/rpc/subqueryField.ts
index a587073..05d4d4b 100644
--- a/src/rpc/subqueryField.ts
+++ b/src/rpc/subqueryField.ts
@@ -369,6 +369,9 @@ export async function getTxFieldValue(
   if (type === TxType.Eip4844) {
     logger.error(`EIP-4844 transactions are not yet supported`);
     return null;
+  } else if (type === TxType.OpSystem) {
+    logger.error(`OP stack System transactions are not yet supported`);
+    return null;
   }
   const value = getValue(tx, type);
 
@@ -487,6 +490,9 @@ export async function getReceiptFieldValue(
   if (Number(receipt?.type) === TxType.Eip4844) {
     logger.error(`EIP-4844 transaction receipts are not yet supported`);
     return null;
+  } else if (Number(receipt?.type) === TxType.OpSystem) {
+    logger.error(`OP stack System transaction receipts are not yet supported`);
+    return null;
   }
 
   const value = getValue(receipt);
diff --git a/test/ipfs/scenarios.test.ts b/test/ipfs/scenarios.test.ts
index ac7f014..9c205d7 100644
--- a/test/ipfs/scenarios.test.ts
+++ b/test/ipfs/scenarios.test.ts
@@ -50,7 +50,7 @@ describe("Additional IPFS scenarios to test", () => {
         };
       }
     }
-  }, 30000);
+  }, 50000);
 
   test(`Read all pinned data`, async () => {
     for await (const client of ipfsClients) {
@@ -64,7 +64,7 @@ describe("Additional IPFS scenarios to test", () => {
         }
       }
     }
-  }, 30000);
+  }, 50000);
 
   test(`Unpin all data`, async () => {
     for await (const client of ipfsClients) {
@@ -73,5 +73,5 @@ describe("Additional IPFS scenarios to test", () => {
         expect(unpin.value as boolean).toEqual(true);
       }
     }
-  }, 30000);
+  }, 50000);
 });
\ No newline at end of file
diff --git a/test/rpc/chainDataGoerli.test.ts b/test/rpc/chainDataGoerli.test.ts
deleted file mode 100644
index 90b9586..0000000
--- a/test/rpc/chainDataGoerli.test.ts
+++ /dev/null
@@ -1,282 +0,0 @@
-import { ethers } from "ethers";
-import {
-  getAccountData,
-  getAccountFieldValue,
-  getBlockNumberAndTxIdx,
-  getFieldIdxHeaderExtraDataLen,
-  getFieldIdxTxContractDataIdx,
-  getFieldIdxTxDataLength,
-  getFullBlock,
-  getHeaderFieldValue,
-  getRawReceipt,
-  getRawTransaction,
-  getReceiptFieldValue,
-  getSolidityNestedMappingValue,
-  getStorageFieldValue,
-  getTxFieldValue,
-  getTxHash,
-} from "../../src";
-import {
-  AccountField,
-  HeaderField,
-  ReceiptField,
-  TxField,
-  bytes32,
-} from "../../src";
-import {
-  getFieldIdxHeaderLogsBloomIdx,
-  getFieldIdxHeaderTxHash,
-  getFieldIdxHeaderTxSize,
-  getFieldIdxTxCalldataIdx,
-  getFieldIdxTxType,
-  getFieldIdxTxBlockNumber,
-  getFieldIdxTxIndex,
-  getFieldIdxTxFunctionSelector,
-  getFieldIdxTxCalldataHash,
-  getFieldIdxReceiptTxType,
-  getFieldIdxReceiptBlockNumber,
-  getFieldIdxReceiptTxIndex,
-  getFieldIdxReceiptLogIdx,
-  getFieldIdxReceiptDataIdx,
-  getFieldIdxReceiptLogAddress,
-} from "../../src";
-import fs from "fs";
-import { AxiomV2FieldConstant } from "../../src/constants";
-
-function getGoerliTestCases(subquery: string): any {
-  const testCases = fs.readFileSync("test/rpc/data/goerli/" + subquery + ".json", "utf8");
-  return JSON.parse(testCases);
-}
-
-export function getHeaderGoerliTestCases(): any {
-  return getGoerliTestCases("header");
-}
-export function getAccountGoerliTestCases(): any {
-  return getGoerliTestCases("account");
-}
-export function getStorageGoerliTestCases(): any {
-  return getGoerliTestCases("storage");
-}
-export function getTxGoerliTestCases(): any {
-  return getGoerliTestCases("tx");
-}
-export function getReceiptGoerliTestCases(): any {
-  return getGoerliTestCases("receipt");
-}
-
-describe("ChainData query tests", () => {
-  const MATIC_ADDR = "0xDA5F92B81B7095b5763a09BD4A668DcfE6F3b133";
-  const UNI_V3_FACTORY_ADDR = "0x1F98431c8aD98523631AE4a59f267346ea31F984";
-
-  const provider = new ethers.JsonRpcProvider(process.env.PROVIDER_URI_GOERLI as string);
-  const headerTestCases = getHeaderGoerliTestCases();
-  const accountTestCases = getAccountGoerliTestCases();
-  const storageTestCases = getStorageGoerliTestCases();
-  const txTestCases = getTxGoerliTestCases();
-  const receiptTestCases = getReceiptGoerliTestCases();
-
-  test("get header fields", async () => {
-    for (const { subquery, value } of headerTestCases["get header fields"]) {
-      const field_value = await getHeaderFieldValue(provider, subquery);
-      expect(field_value).toEqual(value);
-    }
-  }, 10000);
-
-  test("header field negative test cases", async () => {
-    // Shanghai upgrade for withdrawalsRoot was at block 1000000
-    const withdrawalsRoot = await getHeaderFieldValue(provider, { blockNumber: 1000000, fieldIdx: HeaderField.WithdrawalsRoot });
-    expect(withdrawalsRoot).toEqual(null);
-  }, 10000);
-
-  test("get special header fields", async () => {
-    for (const { subquery, value } of headerTestCases["get special header fields"]) {
-      const field_value = await getHeaderFieldValue(provider, subquery);
-      expect(field_value).toEqual(value);
-    }
-  }, 10000);
-
-  test("get header field logs bloom", async () => {
-    for (const { subquery, value } of headerTestCases["get header field logs bloom"]) {
-      const field_value = await getHeaderFieldValue(provider, subquery);
-      expect(field_value).toEqual(value);
-    }
-  }, 10000);
-
-  test("get account fields", async () => {
-    for (const { subquery, value } of accountTestCases["get account fields"]) {
-      const field_value = await getAccountFieldValue(provider, subquery);
-      expect(field_value).toEqual(value);
-    }
-  }, 10000);
-
-  test("get storage slot", async () => {
-    for (const { subquery, value } of storageTestCases["get storage slot"]) {
-      const field_value = await getStorageFieldValue(provider, subquery);
-      expect(field_value).toEqual(value);
-    }
-  }, 10000);
-
-  test("get tx field value", async () => {
-    for (const { subquery, value } of txTestCases["get tx field value"]) {
-      const field_value = await getTxFieldValue(provider, subquery);
-      expect(field_value).toEqual(value);
-    }
-  }, 10000);
-
-  test("get problem tx field value", async () => {
-    for (const { subquery, value } of txTestCases["get problem tx field value"]) {
-      const field_value = await getTxFieldValue(provider, subquery);
-      expect(field_value).toEqual(value);
-    }
-  }, 10000);
-
-  test("get problem receipt field value (log data size too large)", async () => {
-    for (const { subquery, value } of receiptTestCases["get problem receipt field value (log data size too large)"]) {
-      const field_value = await getReceiptFieldValue(provider, subquery);
-      expect(field_value).toEqual(value);
-    }
-  }, 10000);
-
-  // test("get tx calldataIdx value", async () => {
-  //   // for txHash = "0xe64c1d17a69ee91d41f054fd981f4ad073d9f807e1ddfad78b4a696a4a79f921";
-  //   const blockNumber = 9800000;
-  //   const txIdx = 5;
-  //   let calldataValue = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxCalldataIdx(0) });
-  //   expect(calldataValue).toEqual("0x0000000000000000000000000000000000000000000000000000000000000100");
-  //   calldataValue = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxCalldataIdx(1) });
-  //   expect(calldataValue).toEqual("0x000000000000000000000000b392448932f6ef430555631f765df0dfae34eff3");
-  //   calldataValue = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxCalldataIdx(2) });
-  //   expect(calldataValue).toEqual("0x0000000000000000000000000000000000000000000000000000000001e13380");
-  //   calldataValue = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxCalldataIdx(3) });
-  //   expect(calldataValue).toEqual("0x9923eb9400000003082a0a4936bd94a9078de18bea9fb1e023ecfb31b44c5f9d");
-  //   calldataValue = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxCalldataIdx(4) });
-  //   expect(calldataValue).toEqual("0x000000000000000000000000231b0ee14048e9dccd1d247744d114a4eb5e8e63");
-  //   calldataValue = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxCalldataIdx(5) });
-  //   expect(calldataValue).toEqual("0x0000000000000000000000000000000000000000000000000000000000000140");
-  //   calldataValue = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxCalldataIdx(6) });
-  //   expect(calldataValue).toEqual("0x0000000000000000000000000000000000000000000000000000000000000001");
-  //   calldataValue = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxCalldataIdx(7) });
-  //   expect(calldataValue).toEqual("0x0000000000000000000000000000000000000000000000000000000000000000");
-  //   calldataValue = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxCalldataIdx(8) });
-  //   expect(calldataValue).toEqual("0x0000000000000000000000000000000000000000000000000000000000000006");
-  //   calldataValue = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxCalldataIdx(9) });
-  //   expect(calldataValue).toEqual("0x7a65726f6b700000000000000000000000000000000000000000000000000000");
-  //   calldataValue = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxCalldataIdx(10) });
-  //   expect(calldataValue).toEqual("0x0000000000000000000000000000000000000000000000000000000000000001");
-  //   calldataValue = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxCalldataIdx(11) });
-  //   expect(calldataValue).toEqual("0x0000000000000000000000000000000000000000000000000000000000000020");
-  //   calldataValue = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxCalldataIdx(12) });
-  //   expect(calldataValue).toEqual("0x00000000000000000000000000000000000000000000000000000000000000a4");
-  //   calldataValue = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxCalldataIdx(13) });
-  //   expect(calldataValue).toEqual("0x8b95dd717610115e31b8be283a240f1b8ea09ca53abfdfaa17c79175efd8cfef");
-  //   calldataValue = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxCalldataIdx(14) });
-  //   expect(calldataValue).toEqual("0x62b37ab900000000000000000000000000000000000000000000000000000000");
-  //   calldataValue = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxCalldataIdx(15) });
-  //   expect(calldataValue).toEqual("0x0000003c00000000000000000000000000000000000000000000000000000000");
-  //   calldataValue = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxCalldataIdx(16) });
-  //   expect(calldataValue).toEqual("0x0000006000000000000000000000000000000000000000000000000000000000");
-  //   calldataValue = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxCalldataIdx(17) });
-  //   expect(calldataValue).toEqual("0x00000014b392448932f6ef430555631f765df0dfae34eff30000000000000000");
-  //   calldataValue = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxCalldataIdx(18) });
-  //   expect(calldataValue).toEqual("0x0000000000000000000000000000000000000000000000000000000000000000");
-  // }, 10000);
-
-  // test("get tx contract data field values", async () => {
-  //   // Contract creation
-  //   const contractCreateTxHash = "0x5a532ae8eb36dad0058b78f00ee459c42d58157dc11cc290e939b8aa91aa59d4";
-  //   const { blockNumber, txIdx } = await getBlockNumberAndTxIdx(provider, contractCreateTxHash) as { blockNumber: number, txIdx: number };
-  //   let value = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxContractDataIdx(0) });
-  //   expect(value).toEqual("0x6060604052341561000c57fe5b5b60018054600160a060020a033316600160a0");
-  //   value = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxContractDataIdx(284) });
-  //   expect(value).toEqual("0xf517e648a165627a7a72305820c3039feace276128a8a24bc387d61714eecae7");
-  //   value = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxContractDataIdx(285) });
-  //   expect(value).toEqual("0x40de955c6578526a4a4027bebc00290000000000000000000000000000000000");
-  // }, 10000);
-
-  test("get tx special field values", async () => {
-    for (const { subquery, value } of txTestCases["get tx special field values"]) {
-      const field_value = await getTxFieldValue(provider, subquery);
-      expect(field_value).toEqual(value);
-    }
-
-    // // Contract creation 
-    // NOTE: Incomplete for Goerli
-    // const contractCreateTxHash = "0x5a532ae8eb36dad0058b78f00ee459c42d58157dc11cc290e939b8aa91aa59d4";
-    // const { blockNumber: contractCreateBlockNumber, txIdx: contractCreateTxIdx } = await getBlockNumberAndTxIdx(provider, contractCreateTxHash) as { blockNumber: number, txIdx: number };
-    // value = await getTxFieldValue(provider, { blockNumber: contractCreateBlockNumber, txIdx: contractCreateTxIdx, fieldOrCalldataIdx: getFieldIdxTxFunctionSelector() });
-    // expect(value).toEqual(bytes32(AxiomV2FieldConstant.Tx.ContractDeploySelectorValue));
-
-    // // EOA transfer
-    // const eoaTransferTxHash = "0xb1257d8484c43929d7bae46b2aecd509e5d9278273063c9bac2a2d9cb4f1c9f1";
-    // const { blockNumber: eoaTransferBlockNumber, txIdx: eoaTransferTxIdx } = await getBlockNumberAndTxIdx(provider, eoaTransferTxHash) as { blockNumber: number, txIdx: number };
-    // value = await getTxFieldValue(provider, { blockNumber: eoaTransferBlockNumber, txIdx: eoaTransferTxIdx, fieldOrCalldataIdx: getFieldIdxTxFunctionSelector() });
-    // expect(value).toEqual(bytes32(AxiomV2FieldConstant.Tx.NoCalldataSelectorValue));
-
-    // value = await getTxFieldValue(provider, { blockNumber, txIdx, fieldOrCalldataIdx: getFieldIdxTxDataLength() });
-    // expect(value).toEqual("0x0000000000000000000000000000000000000000000000000000000000011104");
-  }, 10000);
-
-  test("get receipt field value", async () => {
-    for (const { subquery, value } of receiptTestCases["get receipt field value"]) {
-      const field_value = await getReceiptFieldValue(provider, subquery);
-      expect(field_value).toEqual(value);
-    }
-  }, 10000);
-
-  test("get receipt logsBloom field value", async () => {
-    for (const { subquery, value } of receiptTestCases["get receipt logsBloom field value"]) {
-      const field_value = await getReceiptFieldValue(provider, subquery);
-      expect(field_value).toEqual(value);
-    }
-  }, 10000);
-
-  // test("get receipt special field value", async () => {
-  //   const txHash = "0x190414997454151f9bd4bc9c60fbae709bd2301f4d36adbe246b27157dde83ac"; // rug tx?
-  //   const { blockNumber, txIdx } = await getBlockNumberAndTxIdx(provider, txHash) as { blockNumber: number, txIdx: number };
-  //   let value = await getReceiptFieldValue(provider, { blockNumber, txIdx, fieldOrLogIdx: getFieldIdxReceiptTxType(), eventSchema: ethers.ZeroHash, topicOrDataOrAddressIdx: 0 });
-  //   expect(value).toEqual(bytes32(2));
-  //   value = await getReceiptFieldValue(provider, { blockNumber, txIdx, fieldOrLogIdx: getFieldIdxReceiptBlockNumber(), eventSchema: ethers.ZeroHash, topicOrDataOrAddressIdx: 0 });
-  //   expect(value).toEqual(bytes32(17500000));
-  //   value = await getReceiptFieldValue(provider, { blockNumber, txIdx, fieldOrLogIdx: getFieldIdxReceiptTxIndex(), eventSchema: ethers.ZeroHash, topicOrDataOrAddressIdx: 0 });
-  //   expect(value).toEqual(bytes32(119));
-  // }, 10000);
-
-  // test("get receipt logIdx value", async () => {
-  //   const txHash = "0xe64c1d17a69ee91d41f054fd981f4ad073d9f807e1ddfad78b4a696a4a79f921";
-  //   const { blockNumber, txIdx } = await getBlockNumberAndTxIdx(provider, txHash) as { blockNumber: number, txIdx: number };
-
-  //   const eventSchema = "0x65412581168e88a1e60c6459d7f44ae83ad0832e670826c05a4e2476b57af752";
-  //   let receiptValue = await getReceiptFieldValue(provider, { blockNumber, txIdx, fieldOrLogIdx: getFieldIdxReceiptLogIdx(7), eventSchema, topicOrDataOrAddressIdx: 0 });
-  //   expect(receiptValue).toEqual("0x65412581168e88a1e60c6459d7f44ae83ad0832e670826c05a4e2476b57af752");
-  //   receiptValue = await getReceiptFieldValue(provider, { blockNumber, txIdx, fieldOrLogIdx: getFieldIdxReceiptLogIdx(7), eventSchema, topicOrDataOrAddressIdx: 1 });
-  //   expect(receiptValue).toEqual("0x7610115e31b8be283a240f1b8ea09ca53abfdfaa17c79175efd8cfef62b37ab9");
-  //   receiptValue = await getReceiptFieldValue(provider, { blockNumber, txIdx, fieldOrLogIdx: getFieldIdxReceiptLogIdx(7), eventSchema, topicOrDataOrAddressIdx: 2 });
-  //   // Expect invalid topic index
-  //   expect(receiptValue).toEqual(null);
-  //   receiptValue = await getReceiptFieldValue(provider, { blockNumber, txIdx, fieldOrLogIdx: getFieldIdxReceiptLogIdx(7), eventSchema, topicOrDataOrAddressIdx: getFieldIdxReceiptDataIdx(0) });
-  //   expect(receiptValue).toEqual("0x000000000000000000000000000000000000000000000000000000000000003c");
-  //   receiptValue = await getReceiptFieldValue(provider, { blockNumber, txIdx, fieldOrLogIdx: getFieldIdxReceiptLogIdx(7), eventSchema, topicOrDataOrAddressIdx: getFieldIdxReceiptDataIdx(1) });
-  //   expect(receiptValue).toEqual("0x0000000000000000000000000000000000000000000000000000000000000040");
-  //   receiptValue = await getReceiptFieldValue(provider, { blockNumber, txIdx, fieldOrLogIdx: getFieldIdxReceiptLogIdx(7), eventSchema, topicOrDataOrAddressIdx: getFieldIdxReceiptDataIdx(2) });
-  //   expect(receiptValue).toEqual("0x0000000000000000000000000000000000000000000000000000000000000014");
-  //   receiptValue = await getReceiptFieldValue(provider, { blockNumber, txIdx, fieldOrLogIdx: getFieldIdxReceiptLogIdx(7), eventSchema, topicOrDataOrAddressIdx: getFieldIdxReceiptDataIdx(3) });
-  //   expect(receiptValue).toEqual("0xb392448932f6ef430555631f765df0dfae34eff3000000000000000000000000");
-  //   receiptValue = await getReceiptFieldValue(provider, { blockNumber, txIdx, fieldOrLogIdx: getFieldIdxReceiptLogIdx(7), eventSchema, topicOrDataOrAddressIdx: getFieldIdxReceiptLogAddress() });
-  //   expect(receiptValue).toEqual(bytes32('0x231b0Ee14048e9dCcD1d247744d114a4EB5E8E63'));
-  // }, 10000);
-
-  // test("Get solidity nested mapping value", async () => {
-  //   const blockNumber = 9000000;
-  //   const addr = UNI_V3_FACTORY_ADDR;
-  //   const mappingSlot = "5";
-  //   const mappingDepth = 3;
-  //   const keys: [string, string, string, string] = [
-  //     bytes32("0x0000000000085d4780b73119b644ae5ecd22b376"),
-  //     bytes32("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"),
-  //     bytes32(3000),
-  //     "",
-  //   ];
-  //   const value = await getSolidityNestedMappingValue(provider, { blockNumber, addr, mappingSlot, mappingDepth, keys });
-  //   expect(value).toEqual(bytes32("0xf5148fbdae394c553d019b4caeffc5f845dcd12c"));
-  // }, 10000);
-});
diff --git a/test/rpc/chainDataOpstack.test.ts b/test/rpc/chainDataOpstack.test.ts
new file mode 100644
index 0000000..673e933
--- /dev/null
+++ b/test/rpc/chainDataOpstack.test.ts
@@ -0,0 +1,96 @@
+import { ethers } from "ethers";
+import { getBlockNumberAndTxIdx, getTxFieldValue, TxField } from "../../src";
+
+const optimismTx = [
+  "0x25214e8c125f7c9749614d8f81e162e4cca5c86a94d532628edc70c3016163e2",
+  "0x58f48d2419d09a1797de977e1c4fdffc49b32a799c8d493479a5882201309469",
+  "0x0c369868122e1af5d10d43e67bc970e1b62444be4ea8886e1fad6234b86b431f",
+]
+
+const optimismSystem = [
+  "0xbd5ac52db73613d6586832ce34762ba6a1e1f241d8d9e6e6412acbab32054a41",
+  "0x1406a2d4cde0551c8b5837bb51233f18e375fdf303ce6ace10fca9dc8fed9c71",
+  "0x65189cfa8f7678b058e88de47dbb8c74635598bc7e441dc8d180803d357605d4",
+];
+
+const baseTx = [
+  "0x3ed6efd80791ab4108c2ea9e696100b79e83e82f0ae4d6087e189b90bb1b22e8",
+  "0xa4f3f097bae6aab76a035440effa0b752cb56d9098c25f709624315c7ffd19a9",
+  "0x012c8d77174aa6ab8e63933a2f74f69fe9820915ab44c5d844da9c7276a51ff0",
+];
+
+const baseSystem = [
+  "0xcbbe74fd041d136b4bccab96f50a32e41326afb464ae69727b19cdf78e6ff03b",
+  "0x5eb5119f26565c90ff816ae74869459b9338694196cedd0f26ca04831643d413",
+  "0xe990e2c2531707144a6d60d4a74f0d19f8e905b9065678988e3f1a70d20db05a",
+];
+
+describe("Chaindata OpStack", () => {
+  const providerOptimism = new ethers.JsonRpcProvider(
+    process.env.PROVIDER_URI_10 as string,
+  );
+
+  const providerBase = new ethers.JsonRpcProvider(
+    process.env.PROVIDER_URI_8453 as string,
+  );
+
+  test("Optimism: Check that we allow tx types < 0x03", async () => {
+    for await (const txHash of optimismTx) {
+      const { blockNumber, txIdx } = await getBlockNumberAndTxIdx(providerOptimism, txHash);
+      if (blockNumber === null || txIdx === null) {
+        throw new Error("Error getting block number and tx idx");
+      }
+      const val = await getTxFieldValue(providerOptimism, {
+        blockNumber,
+        txIdx,
+        fieldOrCalldataIdx: TxField.To,
+      });
+      expect(val).not.toBeNull();
+    }
+  });
+
+  test("Optimism: Check that we block tx type 0x7E", async () => {
+    for await (const txHash of optimismSystem) {
+      const { blockNumber, txIdx } = await getBlockNumberAndTxIdx(providerOptimism, txHash);
+      if (blockNumber === null || txIdx === null) {
+        throw new Error("Error getting block number and tx idx");
+      }
+      const val = await getTxFieldValue(providerOptimism, {
+        blockNumber,
+        txIdx,
+        fieldOrCalldataIdx: TxField.To,
+      });
+      expect(val).toBeNull();
+    }
+  });
+
+  test("Base: Check that we allow tx types < 0x03", async () => {
+    for await (const txHash of baseTx) {
+      const { blockNumber, txIdx } = await getBlockNumberAndTxIdx(providerBase, txHash);
+      if (blockNumber === null || txIdx === null) {
+        throw new Error("Error getting block number and tx idx");
+      }
+      const val = await getTxFieldValue(providerBase, {
+        blockNumber,
+        txIdx,
+        fieldOrCalldataIdx: TxField.To,
+      });
+      expect(val).not.toBeNull();
+    }
+  });
+
+  test("Base: Check that we block tx type 0x7E", async () => {
+    for await (const txHash of baseSystem) {
+      const { blockNumber, txIdx } = await getBlockNumberAndTxIdx(providerBase, txHash);
+      if (blockNumber === null || txIdx === null) {
+        throw new Error("Error getting block number and tx idx");
+      }
+      const val = await getTxFieldValue(providerBase, {
+        blockNumber,
+        txIdx,
+        fieldOrCalldataIdx: TxField.To,
+      });
+      expect(val).toBeNull();
+    }
+  });
+});