@matterlabs/zksync-js 0.0.6 → 0.0.8

package/dist/core/index.cjs

@@ -25,10 +25,15 @@ __export(abi_exports, {
   IBaseTokenABI: () => IBaseToken_default,
   IBridgehubABI: () => IBridgehub_default,
   IERC20ABI: () => IERC20_default,
+  IERC7786AttributesABI: () => IERC7786Attributes_default,
+  IInteropHandlerABI: () => IInteropHandler_default,
   IL1AssetRouterABI: () => IL1AssetRouter_default,
   IL1NullifierABI: () => IL1Nullifier_default,
   IL2AssetRouterABI: () => IL2AssetRouter_default,
+  InteropCenterABI: () => InteropCenter_default,
+  InteropRootStorageABI: () => InteropRootStorage_default,
   L1NativeTokenVaultABI: () => L1NativeTokenVault_default,
+  L2MessageVerificationABI: () => L2MessageVerification_default,
   L2NativeTokenVaultABI: () => L2NativeTokenVault_default,
   MailboxABI: () => Mailbox_default
 });
@@ -4145,6 +4150,63 @@ var IERC20ABI = [
 ];
 var IERC20_default = IERC20ABI;
 
+// src/core/internal/abis/IERC7786Attributes.ts
+var IERC7786AttributesABI = [
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "_executionAddress",
+        type: "bytes"
+      }
+    ],
+    name: "executionAddress",
+    outputs: [],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_indirectCallMessageValue",
+        type: "uint256"
+      }
+    ],
+    name: "indirectCall",
+    outputs: [],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_interopCallValue",
+        type: "uint256"
+      }
+    ],
+    name: "interopCallValue",
+    outputs: [],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "_unbundlerAddress",
+        type: "bytes"
+      }
+    ],
+    name: "unbundlerAddress",
+    outputs: [],
+    stateMutability: "pure",
+    type: "function"
+  }
+];
+var IERC7786Attributes_default = IERC7786AttributesABI;
+
 // src/core/internal/abis/Mailbox.ts
 var MailboxABI = [
   {
@@ -4434,92 +4496,1449 @@ var MailboxABI = [
       { name: "txId", type: "uint256", indexed: true, internalType: "uint256" },
       { name: "txHash", type: "bytes32", indexed: true, internalType: "bytes32" }
     ],
-    anonymous: false
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "NewRelayedPriorityTransaction",
+    inputs: [
+      { name: "txId", type: "uint256", indexed: false, internalType: "uint256" },
+      { name: "txHash", type: "bytes32", indexed: false, internalType: "bytes32" },
+      {
+        name: "expirationTimestamp",
+        type: "uint64",
+        indexed: false,
+        internalType: "uint64"
+      }
+    ],
+    anonymous: false
+  },
+  { type: "error", name: "BaseTokenGasPriceDenominatorNotSet", inputs: [] },
+  {
+    type: "error",
+    name: "BatchNotExecuted",
+    inputs: [{ name: "batchNumber", type: "uint256", internalType: "uint256" }]
+  },
+  { type: "error", name: "GasPerPubdataMismatch", inputs: [] },
+  { type: "error", name: "HashedLogIsDefault", inputs: [] },
+  { type: "error", name: "InvalidChainId", inputs: [] },
+  { type: "error", name: "InvalidProofLengthForFinalNode", inputs: [] },
+  {
+    type: "error",
+    name: "LengthIsNotDivisibleBy32",
+    inputs: [{ name: "length", type: "uint256", internalType: "uint256" }]
+  },
+  { type: "error", name: "LocalRootIsZero", inputs: [] },
+  { type: "error", name: "LocalRootMustBeZero", inputs: [] },
+  {
+    type: "error",
+    name: "MalformedBytecode",
+    inputs: [{ name: "", type: "uint8", internalType: "enum BytecodeError" }]
+  },
+  { type: "error", name: "MerkleIndexOutOfBounds", inputs: [] },
+  { type: "error", name: "MerklePathEmpty", inputs: [] },
+  { type: "error", name: "MerklePathOutOfBounds", inputs: [] },
+  {
+    type: "error",
+    name: "MsgValueTooLow",
+    inputs: [
+      { name: "required", type: "uint256", internalType: "uint256" },
+      { name: "provided", type: "uint256", internalType: "uint256" }
+    ]
+  },
+  { type: "error", name: "NotHyperchain", inputs: [] },
+  { type: "error", name: "NotInitializedReentrancyGuard", inputs: [] },
+  {
+    type: "error",
+    name: "NotL1",
+    inputs: [{ name: "blockChainId", type: "uint256", internalType: "uint256" }]
+  },
+  { type: "error", name: "NotSettlementLayer", inputs: [] },
+  { type: "error", name: "OnlyEraSupported", inputs: [] },
+  {
+    type: "error",
+    name: "PubdataGreaterThanLimit",
+    inputs: [
+      { name: "limit", type: "uint256", internalType: "uint256" },
+      { name: "length", type: "uint256", internalType: "uint256" }
+    ]
+  },
+  { type: "error", name: "Reentrancy", inputs: [] },
+  { type: "error", name: "TooManyFactoryDeps", inputs: [] },
+  { type: "error", name: "TooMuchGas", inputs: [] },
+  { type: "error", name: "TransactionNotAllowed", inputs: [] },
+  { type: "error", name: "TxnBodyGasLimitNotEnoughGas", inputs: [] },
+  {
+    type: "error",
+    name: "Unauthorized",
+    inputs: [{ name: "caller", type: "address", internalType: "address" }]
+  },
+  {
+    type: "error",
+    name: "UnsupportedProofMetadataVersion",
+    inputs: [{ name: "metadataVersion", type: "uint256", internalType: "uint256" }]
+  },
+  { type: "error", name: "ValidateTxnNotEnoughGas", inputs: [] },
+  { type: "error", name: "ZeroGasPriceL1TxZKSyncOS", inputs: [] }
+];
+var Mailbox_default = MailboxABI;
+
+// src/core/internal/abis/InteropCenter.ts
+var InteropCenterABI = [
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "selector",
+        type: "bytes4"
+      }
+    ],
+    name: "AttributeAlreadySet",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "selector",
+        type: "bytes4"
+      },
+      {
+        internalType: "uint256",
+        name: "restriction",
+        type: "uint256"
+      }
+    ],
+    name: "AttributeViolatesRestriction",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "expected",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "actual",
+        type: "uint256"
+      }
+    ],
+    name: "IndirectCallValueMismatch",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "interoperableAddress",
+        type: "bytes"
+      }
+    ],
+    name: "InteroperableAddressChainReferenceNotEmpty",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "interoperableAddress",
+        type: "bytes"
+      }
+    ],
+    name: "InteroperableAddressNotEmpty",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    name: "InteroperableAddressParsingError",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "expectedMsgValue",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "providedMsgValue",
+        type: "uint256"
+      }
+    ],
+    name: "MsgValueMismatch",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "NotInGatewayMode",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "sourceChainId",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "destinationChainId",
+        type: "uint256"
+      }
+    ],
+    name: "NotL2ToL2",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "SlotOccupied",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "caller",
+        type: "address"
+      }
+    ],
+    name: "Unauthorized",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "selector",
+        type: "bytes4"
+      }
+    ],
+    name: "UnsupportedAttribute",
+    type: "error"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint8",
+        name: "version",
+        type: "uint8"
+      }
+    ],
+    name: "Initialized",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "bytes32",
+        name: "l2l1MsgHash",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes32",
+        name: "interopBundleHash",
+        type: "bytes32"
+      },
+      {
+        components: [
+          {
+            internalType: "bytes1",
+            name: "version",
+            type: "bytes1"
+          },
+          {
+            internalType: "uint256",
+            name: "sourceChainId",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "destinationChainId",
+            type: "uint256"
+          },
+          {
+            internalType: "bytes32",
+            name: "interopBundleSalt",
+            type: "bytes32"
+          },
+          {
+            components: [
+              {
+                internalType: "bytes1",
+                name: "version",
+                type: "bytes1"
+              },
+              {
+                internalType: "bool",
+                name: "shadowAccount",
+                type: "bool"
+              },
+              {
+                internalType: "address",
+                name: "to",
+                type: "address"
+              },
+              {
+                internalType: "address",
+                name: "from",
+                type: "address"
+              },
+              {
+                internalType: "uint256",
+                name: "value",
+                type: "uint256"
+              },
+              {
+                internalType: "bytes",
+                name: "data",
+                type: "bytes"
+              }
+            ],
+            internalType: "struct InteropCall[]",
+            name: "calls",
+            type: "tuple[]"
+          },
+          {
+            components: [
+              {
+                internalType: "bytes",
+                name: "executionAddress",
+                type: "bytes"
+              },
+              {
+                internalType: "bytes",
+                name: "unbundlerAddress",
+                type: "bytes"
+              }
+            ],
+            internalType: "struct BundleAttributes",
+            name: "bundleAttributes",
+            type: "tuple"
+          }
+        ],
+        indexed: false,
+        internalType: "struct InteropBundle",
+        name: "interopBundle",
+        type: "tuple"
+      }
+    ],
+    name: "InteropBundleSent",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "sendId",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "sender",
+        type: "bytes"
+      },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "recipient",
+        type: "bytes"
+      },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "payload",
+        type: "bytes"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "bytes[]",
+        name: "attributes",
+        type: "bytes[]"
+      }
+    ],
+    name: "MessageSent",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "oldAssetRouter",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newAssetRouter",
+        type: "address"
+      }
+    ],
+    name: "NewAssetRouter",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "oldAssetTracker",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newAssetTracker",
+        type: "address"
+      }
+    ],
+    name: "NewAssetTracker",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "previousOwner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newOwner",
+        type: "address"
+      }
+    ],
+    name: "OwnershipTransferStarted",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "previousOwner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newOwner",
+        type: "address"
+      }
+    ],
+    name: "OwnershipTransferred",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "account",
+        type: "address"
+      }
+    ],
+    name: "Paused",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "account",
+        type: "address"
+      }
+    ],
+    name: "Unpaused",
+    type: "event"
+  },
+  {
+    inputs: [],
+    name: "L1_CHAIN_ID",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "acceptOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_chainId",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes32",
+        name: "_canonicalTxHash",
+        type: "bytes32"
+      },
+      {
+        internalType: "uint64",
+        name: "_expirationTimestamp",
+        type: "uint64"
+      },
+      {
+        components: [
+          {
+            internalType: "bytes1",
+            name: "version",
+            type: "bytes1"
+          },
+          {
+            internalType: "address",
+            name: "originToken",
+            type: "address"
+          },
+          {
+            internalType: "bytes32",
+            name: "baseTokenAssetId",
+            type: "bytes32"
+          },
+          {
+            internalType: "uint256",
+            name: "baseTokenAmount",
+            type: "uint256"
+          },
+          {
+            internalType: "bytes32",
+            name: "assetId",
+            type: "bytes32"
+          },
+          {
+            internalType: "uint256",
+            name: "amount",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "tokenOriginChainId",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct BalanceChange",
+        name: "_balanceChange",
+        type: "tuple"
+      }
+    ],
+    name: "forwardTransactionOnGatewayWithBalanceChange",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_l1ChainId",
+        type: "uint256"
+      },
+      {
+        internalType: "address",
+        name: "_owner",
+        type: "address"
+      }
+    ],
+    name: "initL2",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "sender",
+        type: "address"
+      }
+    ],
+    name: "interopBundleNonce",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "numberOfBundlesSent",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "owner",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes[]",
+        name: "_attributes",
+        type: "bytes[]"
+      },
+      {
+        internalType: "enum IInteropCenter.AttributeParsingRestrictions",
+        name: "_restriction",
+        type: "uint8"
+      }
+    ],
+    name: "parseAttributes",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "interopCallValue",
+            type: "uint256"
+          },
+          {
+            internalType: "bool",
+            name: "indirectCall",
+            type: "bool"
+          },
+          {
+            internalType: "uint256",
+            name: "indirectCallMessageValue",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct CallAttributes",
+        name: "callAttributes",
+        type: "tuple"
+      },
+      {
+        components: [
+          {
+            internalType: "bytes",
+            name: "executionAddress",
+            type: "bytes"
+          },
+          {
+            internalType: "bytes",
+            name: "unbundlerAddress",
+            type: "bytes"
+          }
+        ],
+        internalType: "struct BundleAttributes",
+        name: "bundleAttributes",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pause",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "paused",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pendingOwner",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "renounceOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "_destinationChainId",
+        type: "bytes"
+      },
+      {
+        components: [
+          {
+            internalType: "bytes",
+            name: "to",
+            type: "bytes"
+          },
+          {
+            internalType: "bytes",
+            name: "data",
+            type: "bytes"
+          },
+          {
+            internalType: "bytes[]",
+            name: "callAttributes",
+            type: "bytes[]"
+          }
+        ],
+        internalType: "struct InteropCallStarter[]",
+        name: "_callStarters",
+        type: "tuple[]"
+      },
+      {
+        internalType: "bytes[]",
+        name: "_bundleAttributes",
+        type: "bytes[]"
+      }
+    ],
+    name: "sendBundle",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "bundleHash",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "recipient",
+        type: "bytes"
+      },
+      {
+        internalType: "bytes",
+        name: "payload",
+        type: "bytes"
+      },
+      {
+        internalType: "bytes[]",
+        name: "attributes",
+        type: "bytes[]"
+      }
+    ],
+    name: "sendMessage",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "sendId",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "_attributeSelector",
+        type: "bytes4"
+      }
+    ],
+    name: "supportsAttribute",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "newOwner",
+        type: "address"
+      }
+    ],
+    name: "transferOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "unpause",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var InteropCenter_default = InteropCenterABI;
+
+// src/core/internal/abis/IInteropHandler.ts
+var IInteropHandlerABI = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "bundleHash",
+        type: "bytes32"
+      }
+    ],
+    name: "BundleExecuted",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "bundleHash",
+        type: "bytes32"
+      }
+    ],
+    name: "BundleUnbundled",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "bundleHash",
+        type: "bytes32"
+      }
+    ],
+    name: "BundleVerified",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "bundleHash",
+        type: "bytes32"
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "callIndex",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "enum CallStatus",
+        name: "status",
+        type: "uint8"
+      }
+    ],
+    name: "CallProcessed",
+    type: "event"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "_bundle",
+        type: "bytes"
+      },
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "chainId",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "l1BatchNumber",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "l2MessageIndex",
+            type: "uint256"
+          },
+          {
+            components: [
+              {
+                internalType: "uint16",
+                name: "txNumberInBatch",
+                type: "uint16"
+              },
+              {
+                internalType: "address",
+                name: "sender",
+                type: "address"
+              },
+              {
+                internalType: "bytes",
+                name: "data",
+                type: "bytes"
+              }
+            ],
+            internalType: "struct L2Message",
+            name: "message",
+            type: "tuple"
+          },
+          {
+            internalType: "bytes32[]",
+            name: "proof",
+            type: "bytes32[]"
+          }
+        ],
+        internalType: "struct MessageInclusionProof",
+        name: "_proof",
+        type: "tuple"
+      }
+    ],
+    name: "executeBundle",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_sourceChainId",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes",
+        name: "_bundle",
+        type: "bytes"
+      },
+      {
+        internalType: "enum CallStatus[]",
+        name: "_callStatus",
+        type: "uint8[]"
+      }
+    ],
+    name: "unbundleBundle",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "_bundle",
+        type: "bytes"
+      },
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "chainId",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "l1BatchNumber",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "l2MessageIndex",
+            type: "uint256"
+          },
+          {
+            components: [
+              {
+                internalType: "uint16",
+                name: "txNumberInBatch",
+                type: "uint16"
+              },
+              {
+                internalType: "address",
+                name: "sender",
+                type: "address"
+              },
+              {
+                internalType: "bytes",
+                name: "data",
+                type: "bytes"
+              }
+            ],
+            internalType: "struct L2Message",
+            name: "message",
+            type: "tuple"
+          },
+          {
+            internalType: "bytes32[]",
+            name: "proof",
+            type: "bytes32[]"
+          }
+        ],
+        internalType: "struct MessageInclusionProof",
+        name: "_proof",
+        type: "tuple"
+      }
+    ],
+    name: "verifyBundle",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var IInteropHandler_default = IInteropHandlerABI;
+
+// src/core/internal/abis/InteropRootStorage.ts
+var InteropRootStorageABI = [
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "chainId",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "batchNumber",
+        type: "uint256"
+      }
+    ],
+    name: "interopRoots",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var InteropRootStorage_default = InteropRootStorageABI;
+
+// src/core/internal/abis/L2MessageVerification.ts
+var L2MessageVerificationABI = [
+  {
+    inputs: [],
+    name: "DepthMoreThanOneForRecursiveMerkleProof",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "HashedLogIsDefault",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "InvalidProofLengthForFinalNode",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "MerkleIndexOutOfBounds",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "MerklePathEmpty",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "MerklePathOutOfBounds",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "metadataVersion",
+        type: "uint256"
+      }
+    ],
+    name: "UnsupportedProofMetadataVersion",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "chainId",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "l2BatchNumber",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "l2MessageIndex",
+            type: "uint256"
+          },
+          {
+            internalType: "address",
+            name: "l2Sender",
+            type: "address"
+          },
+          {
+            internalType: "uint16",
+            name: "l2TxNumberInBatch",
+            type: "uint16"
+          },
+          {
+            internalType: "bytes",
+            name: "message",
+            type: "bytes"
+          },
+          {
+            internalType: "bytes32[]",
+            name: "merkleProof",
+            type: "bytes32[]"
+          }
+        ],
+        internalType: "struct FinalizeL1DepositParams",
+        name: "_finalizeWithdrawalParams",
+        type: "tuple"
+      }
+    ],
+    name: "proveL1DepositParamsInclusion",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "success",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_chainId",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes32",
+        name: "_l2TxHash",
+        type: "bytes32"
+      },
+      {
+        internalType: "uint256",
+        name: "_l2BatchNumber",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "_l2MessageIndex",
+        type: "uint256"
+      },
+      {
+        internalType: "uint16",
+        name: "_l2TxNumberInBatch",
+        type: "uint16"
+      },
+      {
+        internalType: "bytes32[]",
+        name: "_merkleProof",
+        type: "bytes32[]"
+      },
+      {
+        internalType: "enum TxStatus",
+        name: "_status",
+        type: "uint8"
+      }
+    ],
+    name: "proveL1ToL2TransactionStatusShared",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_chainId",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "_blockOrBatchNumber",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "_leafProofMask",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes32",
+        name: "_leaf",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes32[]",
+        name: "_proof",
+        type: "bytes32[]"
+      }
+    ],
+    name: "proveL2LeafInclusionShared",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_chainId",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "_blockOrBatchNumber",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "_leafProofMask",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes32",
+        name: "_leaf",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes32[]",
+        name: "_proof",
+        type: "bytes32[]"
+      },
+      {
+        internalType: "uint256",
+        name: "_depth",
+        type: "uint256"
+      }
+    ],
+    name: "proveL2LeafInclusionSharedRecursive",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_chainId",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "_blockOrBatchNumber",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "_index",
+        type: "uint256"
+      },
+      {
+        components: [
+          {
+            internalType: "uint8",
+            name: "l2ShardId",
+            type: "uint8"
+          },
+          {
+            internalType: "bool",
+            name: "isService",
+            type: "bool"
+          },
+          {
+            internalType: "uint16",
+            name: "txNumberInBatch",
+            type: "uint16"
+          },
+          {
+            internalType: "address",
+            name: "sender",
+            type: "address"
+          },
+          {
+            internalType: "bytes32",
+            name: "key",
+            type: "bytes32"
+          },
+          {
+            internalType: "bytes32",
+            name: "value",
+            type: "bytes32"
+          }
+        ],
+        internalType: "struct L2Log",
+        name: "_log",
+        type: "tuple"
+      },
+      {
+        internalType: "bytes32[]",
+        name: "_proof",
+        type: "bytes32[]"
+      }
+    ],
+    name: "proveL2LogInclusionShared",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
   },
   {
-    type: "event",
-    name: "NewRelayedPriorityTransaction",
     inputs: [
-      { name: "txId", type: "uint256", indexed: false, internalType: "uint256" },
-      { name: "txHash", type: "bytes32", indexed: false, internalType: "bytes32" },
       {
-        name: "expirationTimestamp",
-        type: "uint64",
-        indexed: false,
-        internalType: "uint64"
+        internalType: "uint256",
+        name: "_chainId",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "_blockOrBatchNumber",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "_index",
+        type: "uint256"
+      },
+      {
+        components: [
+          {
+            internalType: "uint16",
+            name: "txNumberInBatch",
+            type: "uint16"
+          },
+          {
+            internalType: "address",
+            name: "sender",
+            type: "address"
+          },
+          {
+            internalType: "bytes",
+            name: "data",
+            type: "bytes"
+          }
+        ],
+        internalType: "struct L2Message",
+        name: "_message",
+        type: "tuple"
+      },
+      {
+        internalType: "bytes32[]",
+        name: "_proof",
+        type: "bytes32[]"
       }
     ],
-    anonymous: false
-  },
-  { type: "error", name: "BaseTokenGasPriceDenominatorNotSet", inputs: [] },
-  {
-    type: "error",
-    name: "BatchNotExecuted",
-    inputs: [{ name: "batchNumber", type: "uint256", internalType: "uint256" }]
-  },
-  { type: "error", name: "GasPerPubdataMismatch", inputs: [] },
-  { type: "error", name: "HashedLogIsDefault", inputs: [] },
-  { type: "error", name: "InvalidChainId", inputs: [] },
-  { type: "error", name: "InvalidProofLengthForFinalNode", inputs: [] },
-  {
-    type: "error",
-    name: "LengthIsNotDivisibleBy32",
-    inputs: [{ name: "length", type: "uint256", internalType: "uint256" }]
-  },
-  { type: "error", name: "LocalRootIsZero", inputs: [] },
-  { type: "error", name: "LocalRootMustBeZero", inputs: [] },
-  {
-    type: "error",
-    name: "MalformedBytecode",
-    inputs: [{ name: "", type: "uint8", internalType: "enum BytecodeError" }]
-  },
-  { type: "error", name: "MerkleIndexOutOfBounds", inputs: [] },
-  { type: "error", name: "MerklePathEmpty", inputs: [] },
-  { type: "error", name: "MerklePathOutOfBounds", inputs: [] },
-  {
-    type: "error",
-    name: "MsgValueTooLow",
-    inputs: [
-      { name: "required", type: "uint256", internalType: "uint256" },
-      { name: "provided", type: "uint256", internalType: "uint256" }
-    ]
-  },
-  { type: "error", name: "NotHyperchain", inputs: [] },
-  { type: "error", name: "NotInitializedReentrancyGuard", inputs: [] },
-  {
-    type: "error",
-    name: "NotL1",
-    inputs: [{ name: "blockChainId", type: "uint256", internalType: "uint256" }]
-  },
-  { type: "error", name: "NotSettlementLayer", inputs: [] },
-  { type: "error", name: "OnlyEraSupported", inputs: [] },
-  {
-    type: "error",
-    name: "PubdataGreaterThanLimit",
-    inputs: [
-      { name: "limit", type: "uint256", internalType: "uint256" },
-      { name: "length", type: "uint256", internalType: "uint256" }
-    ]
-  },
-  { type: "error", name: "Reentrancy", inputs: [] },
-  { type: "error", name: "TooManyFactoryDeps", inputs: [] },
-  { type: "error", name: "TooMuchGas", inputs: [] },
-  { type: "error", name: "TransactionNotAllowed", inputs: [] },
-  { type: "error", name: "TxnBodyGasLimitNotEnoughGas", inputs: [] },
-  {
-    type: "error",
-    name: "Unauthorized",
-    inputs: [{ name: "caller", type: "address", internalType: "address" }]
-  },
-  {
-    type: "error",
-    name: "UnsupportedProofMetadataVersion",
-    inputs: [{ name: "metadataVersion", type: "uint256", internalType: "uint256" }]
-  },
-  { type: "error", name: "ValidateTxnNotEnoughGas", inputs: [] },
-  { type: "error", name: "ZeroGasPriceL1TxZKSyncOS", inputs: [] }
+    name: "proveL2MessageInclusionShared",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
 ];
-var Mailbox_default = MailboxABI;
+var L2MessageVerification_default = L2MessageVerificationABI;
 
 // src/core/errors/factory.ts
 var factory_exports = {};
@@ -4528,6 +5947,45 @@ __export(factory_exports, {
   shapeCause: () => shapeCause
 });
 
+// src/core/utils/hash.ts
+var RegExpHex = /^0x[0-9a-fA-F]*$/;
+var isHash = (x, length) => {
+  if (!x || typeof x !== "string") return false;
+  return (length === void 0 || x.length === length) && RegExpHex.test(x);
+};
+var isHashArray = (x, length) => {
+  if (!Array.isArray(x)) return false;
+  return x.every((item) => isHash(item, length));
+};
+var isHash66 = (x) => isHash(x, 66);
+var isHash66Array = (x) => isHashArray(x, 66);
+
+// src/core/utils/number.ts
+var isNumber = (x) => typeof x === "number" && Number.isFinite(x);
+var isBigint = (x) => typeof x === "bigint";
+
+// src/core/utils/addr.ts
+function isAddress(x) {
+  return isHash(x, 42);
+}
+function isAddressEq(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
+function isETH(token) {
+  return isAddressEq(token, FORMAL_ETH_ADDRESS) || isAddressEq(token, L2_BASE_TOKEN_ADDRESS) || isAddressEq(token, ETH_ADDRESS);
+}
+function normalizeAddrEq(a, b) {
+  if (!a || !b) return false;
+  const normalize = (s) => {
+    const hasPrefix = s.slice(0, 2).toLowerCase() === "0x";
+    const body = hasPrefix ? s.slice(2) : s;
+    return `0x${body.toLowerCase()}`;
+  };
+  return normalize(a) === normalize(b);
+}
+var hexEq = (a, b) => a.toLowerCase() === b.toLowerCase();
+var normalizeL1Token = (token) => isAddressEq(token, FORMAL_ETH_ADDRESS) ? ETH_ADDRESS : token;
+
 // src/core/errors/formatter.ts
 function elideMiddle(s, max = 96) {
   if (s.length <= max) return s;
@@ -4538,7 +5996,7 @@ function shortJSON(v, max = 240) {
   try {
     const s = JSON.stringify(
       v,
-      (_k, val) => typeof val === "bigint" ? `${val.toString()}n` : val
+      (_k, val) => isBigint(val) ? `${val.toString()}n` : val
     );
     return s.length > max ? elideMiddle(s, max) : s;
   } catch {
@@ -4558,7 +6016,7 @@ function formatContextLine(ctx) {
   if (txHash !== void 0)
     parts.push(`txHash=${typeof txHash === "string" ? txHash : shortJSON(txHash, 96)}`);
   if (nonce !== void 0) {
-    const nonceStr = typeof nonce === "string" || typeof nonce === "number" || typeof nonce === "bigint" ? String(nonce) : shortJSON(nonce, 48);
+    const nonceStr = typeof nonce === "string" || isNumber(nonce) || isBigint(nonce) ? String(nonce) : shortJSON(nonce, 48);
     parts.push(`nonce=${nonceStr}`);
   }
   return parts.length ? `  ${kv("Context", parts.join("  \u2022  "))}` : void 0;
@@ -4588,17 +6046,17 @@ function formatCause(c) {
     const head = [];
     if (obj.name !== void 0) {
       const nameVal = obj.name;
-      const nameStr = typeof nameVal === "string" || typeof nameVal === "number" || typeof nameVal === "bigint" || typeof nameVal === "boolean" ? String(nameVal) : shortJSON(nameVal, 120);
+      const nameStr = typeof nameVal === "string" || isNumber(nameVal) || isBigint(nameVal) || typeof nameVal === "boolean" ? String(nameVal) : shortJSON(nameVal, 120);
       head.push(`name=${nameStr}`);
     }
     if (obj.code !== void 0) {
       const codeVal = obj.code;
-      const codeStr = typeof codeVal === "string" || typeof codeVal === "number" || typeof codeVal === "bigint" || typeof codeVal === "boolean" ? String(codeVal) : shortJSON(codeVal, 120);
+      const codeStr = typeof codeVal === "string" || isNumber(codeVal) || isBigint(codeVal) || typeof codeVal === "boolean" ? String(codeVal) : shortJSON(codeVal, 120);
       head.push(`code=${codeStr}`);
     }
     if (head.length) out.push(`  ${kv("Cause", head.join("  "))}`);
     if (obj.message) {
-      const messageStr = typeof obj.message === "string" || typeof obj.message === "number" || typeof obj.message === "bigint" || typeof obj.message === "boolean" ? String(obj.message) : shortJSON(obj.message, 600);
+      const messageStr = typeof obj.message === "string" || isNumber(obj.message) || isBigint(obj.message) || typeof obj.message === "boolean" ? String(obj.message) : shortJSON(obj.message, 600);
       out.push(`              message=${elideMiddle(messageStr, 600)}`);
     }
     if (obj.data) {
@@ -4674,20 +6132,20 @@ function createError(type, input) {
   return new ZKsyncError({ ...input, type });
 }
 function shapeCause(err) {
-  const isRecord = (x) => x !== null && typeof x === "object";
+  const isRecord2 = (x) => x !== null && typeof x === "object";
   let data = void 0;
-  if (isRecord(err)) {
+  if (isRecord2(err)) {
     const r2 = err;
     const d = r2.data;
-    if (isRecord(d) && "data" in d) {
+    if (isRecord2(d) && "data" in d) {
       data = d.data;
-    } else if ("error" in r2 && isRecord(r2.error) && "data" in r2.error) {
+    } else if ("error" in r2 && isRecord2(r2.error) && "data" in r2.error) {
       data = r2.error.data;
     } else if ("data" in r2) {
       data = r2.data;
     }
   }
-  const r = isRecord(err) ? err : void 0;
+  const r = isRecord2(err) ? err : void 0;
   const name = r && typeof r.name === "string" ? r.name : void 0;
   const message = r && typeof r.message === "string" ? r.message : r && typeof r.shortMessage === "string" ? r.shortMessage : void 0;
   const code = r && "code" in r ? r.code : void 0;
@@ -4703,6 +6161,7 @@ function shapeCause(err) {
 var zks_exports = {};
 __export(zks_exports, {
   createZksRpc: () => createZksRpc,
+  normalizeBlockMetadata: () => normalizeBlockMetadata,
   normalizeGenesis: () => normalizeGenesis,
   normalizeProof: () => normalizeProof
 });
@@ -4728,6 +6187,8 @@ var METHODS = {
   getBridgehub: "zks_getBridgehubContract",
   getL2ToL1LogProof: "zks_getL2ToL1LogProof",
   getReceipt: "eth_getTransactionReceipt",
+  getBytecodeSupplier: "zks_getBytecodeSupplierContract",
+  getBlockMetadataByNumber: "zks_getBlockMetadataByNumber",
   getGenesis: "zks_getGenesis"
 };
 function toHexArray(arr) {
@@ -4747,7 +6208,7 @@ function normalizeProof(p) {
         context: { keys: Object.keys(raw ?? {}) }
       });
     }
-    const toBig = (x) => typeof x === "bigint" ? x : typeof x === "number" ? BigInt(x) : typeof x === "string" ? BigInt(x) : (() => {
+    const toBig = (x) => isBigint(x) ? x : isNumber(x) ? BigInt(x) : typeof x === "string" ? BigInt(x) : (() => {
       throw createError("RPC", {
         resource: "zksrpc",
         operation: "zksrpc.normalizeProof",
@@ -4758,7 +6219,8 @@ function normalizeProof(p) {
     return {
       id: toBig(idRaw),
       batchNumber: toBig(bnRaw),
-      proof: toHexArray(raw?.proof)
+      proof: toHexArray(raw?.proof),
+      root: raw.root
     };
   } catch (e) {
     if (isZKsyncError(e)) throw e;
@@ -4780,20 +6242,53 @@ function ensureHex(value, field, context) {
     context: { field, valueType: typeof value, ...context }
   });
 }
-function ensureNumber(value, field) {
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  if (typeof value === "bigint") return Number(value);
+function ensureNumber(value, field, opts) {
+  const operation = opts?.operation ?? "zksrpc.normalizeGenesis";
+  const messagePrefix = opts?.messagePrefix ?? "Malformed genesis response";
+  if (isNumber(value)) return value;
+  if (isBigint(value)) return Number(value);
   if (typeof value === "string" && value.trim() !== "") {
     const parsed = Number(value);
     if (Number.isFinite(parsed)) return parsed;
   }
   throw createError("RPC", {
     resource: "zksrpc",
-    operation: "zksrpc.normalizeGenesis",
-    message: "Malformed genesis response: expected numeric value.",
+    operation,
+    message: `${messagePrefix}: expected numeric value.`,
+    context: { field, valueType: typeof value }
+  });
+}
+function ensureBigInt(value, field, opts) {
+  const operation = opts?.operation ?? "zksrpc.normalizeBlockMetadata";
+  const messagePrefix = opts?.messagePrefix ?? "Malformed block metadata response";
+  if (isBigint(value)) return value;
+  if (isNumber(value)) {
+    if (!Number.isInteger(value)) {
+      throw createError("RPC", {
+        resource: "zksrpc",
+        operation,
+        message: `${messagePrefix}: expected integer value.`,
+        context: { field, valueType: typeof value }
+      });
+    }
+    return BigInt(value);
+  }
+  if (typeof value === "string" && value.trim() !== "") {
+    try {
+      return BigInt(value);
+    } catch {
+    }
+  }
+  throw createError("RPC", {
+    resource: "zksrpc",
+    operation,
+    message: `${messagePrefix}: expected bigint-compatible value.`,
     context: { field, valueType: typeof value }
   });
 }
+function isRecord(x) {
+  return !!x && typeof x === "object" && !Array.isArray(x);
+}
 function normalizeContractTuple(tuple, index) {
   if (!Array.isArray(tuple) || tuple.length < 2) {
     throw createError("RPC", {
@@ -4809,7 +6304,7 @@ function normalizeContractTuple(tuple, index) {
     bytecode: ensureHex(bytecodeRaw, "initial_contracts.bytecode", { index })
   };
 }
-function normalizeStorageTuple(tuple, index) {
+function normalizeRawStorageTuple(tuple, index) {
   if (!Array.isArray(tuple) || tuple.length < 2) {
     throw createError("RPC", {
       resource: "zksrpc",
@@ -4820,10 +6315,53 @@ function normalizeStorageTuple(tuple, index) {
   }
   const [keyRaw, valueRaw] = tuple;
   return {
+    format: "raw",
     key: ensureHex(keyRaw, "additional_storage.key", { index }),
     value: ensureHex(valueRaw, "additional_storage.value", { index })
   };
 }
+function normalizeAdditionalStorage(value, record) {
+  const effective = value ?? record["additional_storage_raw"];
+  if (Array.isArray(effective)) {
+    return effective.map((entry, index) => {
+      const kv2 = normalizeRawStorageTuple(entry, index);
+      return { format: "raw", key: kv2.key, value: kv2.value };
+    });
+  }
+  if (isRecord(effective)) {
+    const out = [];
+    for (const [addrRaw, slotsRaw] of Object.entries(effective)) {
+      const address = ensureHex(addrRaw, "additional_storage.address", {});
+      if (!isRecord(slotsRaw)) {
+        throw createError("RPC", {
+          resource: "zksrpc",
+          operation: "zksrpc.normalizeGenesis",
+          message: "Malformed genesis response: additional_storage[address] must be an object map.",
+          context: { address, valueType: typeof slotsRaw }
+        });
+      }
+      for (const [slotRaw, valRaw] of Object.entries(slotsRaw)) {
+        out.push({
+          format: "pretty",
+          address,
+          key: ensureHex(slotRaw, "additional_storage.key", { address }),
+          value: ensureHex(valRaw, "additional_storage.value", { address, key: slotRaw })
+        });
+      }
+    }
+    return out;
+  }
+  throw createError("RPC", {
+    resource: "zksrpc",
+    operation: "zksrpc.normalizeGenesis",
+    message: "Malformed genesis response: additional_storage must be an array (raw) or an object map (pretty).",
+    context: {
+      valueType: typeof effective,
+      hasAdditionalStorage: "additional_storage" in record,
+      hasAdditionalStorageRaw: "additional_storage_raw" in record
+    }
+  });
+}
 function normalizeGenesis(raw) {
   try {
     if (!raw || typeof raw !== "object") {
@@ -4844,21 +6382,12 @@ function normalizeGenesis(raw) {
         context: { valueType: typeof contractsRaw }
       });
     }
-    const storageRaw = record["additional_storage"];
-    if (!Array.isArray(storageRaw)) {
-      throw createError("RPC", {
-        resource: "zksrpc",
-        operation: "zksrpc.normalizeGenesis",
-        message: "Malformed genesis response: additional_storage must be an array.",
-        context: { valueType: typeof storageRaw }
-      });
-    }
     const executionVersion = ensureNumber(record["execution_version"], "execution_version");
     const genesisRoot = ensureHex(record["genesis_root"], "genesis_root", {});
     const initialContracts = contractsRaw.map(
       (entry, index) => normalizeContractTuple(entry, index)
     );
-    const additionalStorage = storageRaw.map((entry, index) => normalizeStorageTuple(entry, index));
+    const additionalStorage = normalizeAdditionalStorage(record["additional_storage"], record);
     return {
       initialContracts,
       additionalStorage,
@@ -4876,6 +6405,57 @@ function normalizeGenesis(raw) {
     });
   }
 }
+function normalizeBlockMetadata(raw) {
+  try {
+    if (!raw || typeof raw !== "object") {
+      throw createError("RPC", {
+        resource: "zksrpc",
+        operation: "zksrpc.normalizeBlockMetadata",
+        message: "Malformed block metadata response: expected object.",
+        context: { receivedType: typeof raw }
+      });
+    }
+    const record = raw;
+    const pubdataPricePerByte = ensureBigInt(
+      record["pubdata_price_per_byte"] ?? record["pubdataPricePerByte"],
+      "pubdata_price_per_byte",
+      {
+        operation: "zksrpc.normalizeBlockMetadata",
+        messagePrefix: "Malformed block metadata response"
+      }
+    );
+    const nativePrice = ensureBigInt(
+      record["native_price"] ?? record["nativePrice"],
+      "native_price",
+      {
+        operation: "zksrpc.normalizeBlockMetadata",
+        messagePrefix: "Malformed block metadata response"
+      }
+    );
+    const executionVersion = ensureNumber(
+      record["execution_version"] ?? record["executionVersion"],
+      "execution_version",
+      {
+        operation: "zksrpc.normalizeBlockMetadata",
+        messagePrefix: "Malformed block metadata response"
+      }
+    );
+    return {
+      pubdataPricePerByte,
+      nativePrice,
+      executionVersion
+    };
+  } catch (e) {
+    if (isZKsyncError(e)) throw e;
+    throw createError("RPC", {
+      resource: "zksrpc",
+      operation: "zksrpc.normalizeBlockMetadata",
+      message: "Failed to normalize block metadata response.",
+      context: { receivedType: typeof raw },
+      cause: shapeCause(e)
+    });
+  }
+}
 function createZksRpc(transport) {
   return {
     // Fetches the Bridgehub contract address.
@@ -4898,6 +6478,26 @@ function createZksRpc(transport) {
         }
       );
     },
+    // Fetches the Bytecode Supplier contract address.
+    async getBytecodeSupplierAddress() {
+      return withRpcOp(
+        "zksrpc.getBytecodeSupplierAddress",
+        "Failed to fetch Bytecode Supplier address.",
+        {},
+        async () => {
+          const addrRaw = await transport(METHODS.getBytecodeSupplier, []);
+          if (typeof addrRaw !== "string" || !addrRaw.startsWith("0x")) {
+            throw createError("RPC", {
+              resource: "zksrpc",
+              operation: "zksrpc.getBytecodeSupplierAddress",
+              message: "Unexpected Bytecode Supplier address response.",
+              context: { valueType: typeof addrRaw }
+            });
+          }
+          return addrRaw;
+        }
+      );
+    },
     // Fetches a proof for an L2→L1 log emitted in the given transaction.
     async getL2ToL1LogProof(txHash, index) {
       return withRpcOp(
@@ -4934,6 +6534,19 @@ function createZksRpc(transport) {
         }
       );
     },
+    // Fetches block metadata for the given block number.
+    async getBlockMetadataByNumber(blockNumber) {
+      return withRpcOp(
+        "zksrpc.getBlockMetadataByNumber",
+        "Failed to fetch block metadata.",
+        { blockNumber },
+        async () => {
+          const raw = await transport(METHODS.getBlockMetadataByNumber, [blockNumber]);
+          if (raw == null) return null;
+          return normalizeBlockMetadata(raw);
+        }
+      );
+    },
     // Fetches the genesis configuration returned by `zks_getGenesis`.
     async getGenesis() {
       return withRpcOp(
@@ -4957,26 +6570,6 @@ function makeTransportFromViem(client) {
   return (m, p = []) => client.request({ method: m, params: p });
 }
 
-// src/core/utils/addr.ts
-var isHash66 = (x) => !!x && x.startsWith("0x") && x.length === 66;
-function isAddressEq(a, b) {
-  return a.toLowerCase() === b.toLowerCase();
-}
-function isETH(token) {
-  return isAddressEq(token, FORMAL_ETH_ADDRESS) || isAddressEq(token, L2_BASE_TOKEN_ADDRESS) || isAddressEq(token, ETH_ADDRESS);
-}
-function normalizeAddrEq(a, b) {
-  if (!a || !b) return false;
-  const normalize = (s) => {
-    const hasPrefix = s.slice(0, 2).toLowerCase() === "0x";
-    const body = hasPrefix ? s.slice(2) : s;
-    return `0x${body.toLowerCase()}`;
-  };
-  return normalize(a) === normalize(b);
-}
-var hexEq = (a, b) => a.toLowerCase() === b.toLowerCase();
-var normalizeL1Token = (token) => isAddressEq(token, FORMAL_ETH_ADDRESS) ? ETH_ADDRESS : token;
-
 // src/core/resources/deposits/route.ts
 async function pickDepositRoute(client, chainIdL2, token) {
   if (isETH(token)) {
@@ -5000,11 +6593,14 @@ function pickWithdrawRoute(args) {
   return "erc20-nonbase";
 }
 
-// src/core/resources/withdrawals/events.ts
+// src/core/utils/events.ts
+function extractPreferAddress(opts) {
+  const preferAddr = typeof opts?.prefer === "object" ? opts.prefer.address : opts?.prefer === "assetRouter" ? L2_ASSET_ROUTER_ADDRESS : L1_MESSENGER_ADDRESS;
+  return (preferAddr || L1_MESSENGER_ADDRESS).toLowerCase();
+}
 function findL1MessageSentLog(receipt, opts) {
   const index = opts?.index ?? 0;
-  const preferAddr = typeof opts?.prefer === "object" ? opts?.prefer.address : opts?.prefer === "assetRouter" ? L2_ASSET_ROUTER_ADDRESS : L1_MESSENGER_ADDRESS;
-  const prefer = (preferAddr ?? L1_MESSENGER_ADDRESS).toLowerCase();
+  const preferAddr = extractPreferAddress(opts);
   const matches = receipt.logs.filter((lg) => {
     const t0 = (lg.topics?.[0] ?? "").toLowerCase();
     return t0 === TOPIC_L1_MESSAGE_SENT_NEW || t0 === TOPIC_L1_MESSAGE_SENT_LEG;
@@ -5012,13 +6608,18 @@ function findL1MessageSentLog(receipt, opts) {
   if (!matches.length) {
     throw new Error("No L1MessageSent event found in L2 receipt logs.");
   }
-  const preferred = matches.find((lg) => (lg.address ?? "").toLowerCase() === prefer);
+  const preferred = matches.find((lg) => (lg.address ?? "").toLowerCase() === preferAddr);
   const chosen = preferred ?? matches[index] ?? matches[0];
   if (!chosen) {
     throw new Error("No suitable L1MessageSent event found.");
   }
   return chosen;
 }
+function isL1MessageSentLog(log, opts) {
+  const topic = log.topics[0].toLowerCase();
+  const preferAddr = extractPreferAddress(opts);
+  return log.address.toLowerCase() === preferAddr && (topic === TOPIC_L1_MESSAGE_SENT_LEG.toLowerCase() || topic === TOPIC_L1_MESSAGE_SENT_NEW.toLowerCase());
+}
 
 // src/core/resources/withdrawals/logs.ts
 function messengerLogIndex(raw, opts) {
@@ -5044,9 +6645,14 @@ exports.errors = factory_exports;
 exports.findL1MessageSentLog = findL1MessageSentLog;
 exports.formatEnvelopePretty = formatEnvelopePretty;
 exports.hexEq = hexEq;
+exports.isAddress = isAddress;
 exports.isAddressEq = isAddressEq;
 exports.isETH = isETH;
+exports.isHash = isHash;
 exports.isHash66 = isHash66;
+exports.isHash66Array = isHash66Array;
+exports.isHashArray = isHashArray;
+exports.isL1MessageSentLog = isL1MessageSentLog;
 exports.makeTransportFromEthers = makeTransportFromEthers;
 exports.makeTransportFromViem = makeTransportFromViem;
 exports.messengerLogIndex = messengerLogIndex;