viem 2.21.6 → 2.21.7

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # viem
 
+## 2.21.7
+
+### Patch Changes
+
+- [`644f72d`](https://github.com/wevm/viem/commit/644f72db0ac08808918917b2610e403d9bd1bb64) Thanks [@jxom](https://github.com/jxom)! - Fixed an issue where `hashAuthorization` & `serializeAuthorizationList` did not RLP-serialize zeroish nonces correctly.
+
+- [#2719](https://github.com/wevm/viem/pull/2719) [`7fdb149`](https://github.com/wevm/viem/commit/7fdb14929f2446555315df4cf1b99bc086dd8d6b) Thanks [@sammdec](https://github.com/sammdec)! - Added `parentBeaconBlockRoot` to `Block` type.
+
+- [#2722](https://github.com/wevm/viem/pull/2722) [`0b5c7b6`](https://github.com/wevm/viem/commit/0b5c7b6e273cb00834099ec78e4e9555a3c34d5e) Thanks [@coffeexcoin](https://github.com/coffeexcoin)! - Added multicall3 contract for Abstract Testnet.
+
 ## 2.21.6
 
 ### Patch Changes

package/_cjs/chains/definitions/abstractTestnet.js

@@ -23,6 +23,12 @@ exports.abstractTestnet = (0, defineChain_js_1.defineChain)({
         },
     },
     testnet: true,
+    contracts: {
+        multicall3: {
+            address: '0xF9cda624FBC7e059355ce98a31693d299FACd963',
+            blockCreated: 358349,
+        },
+    },
     custom: {
         getEip712Domain(transaction) {
             const message = (0, getEip712Domain_js_1.transactionToMessage)(transaction);

package/_cjs/chains/definitions/abstractTestnet.js.map

@@ -1 +1 @@
-{"version":3,"file":"abstractTestnet.js","sourceRoot":"","sources":["../../../chains/definitions/abstractTestnet.ts"],"names":[],"mappings":";;;AAAA,qEAA8D;AAC9D,gEAAyD;AAEzD,8EAA4E;AAE/D,QAAA,eAAe,GAAiB,IAAA,4BAAW,EAAC;IACvD,GAAG,4BAAW;IACd,EAAE,EAAE,MAAM;IACV,IAAI,EAAE,kBAAkB;IACxB,cAAc,EAAE;QACd,QAAQ,EAAE,EAAE;QACZ,IAAI,EAAE,KAAK;QACX,MAAM,EAAE,KAAK;KACd;IACD,OAAO,EAAE;QACP,OAAO,EAAE,EAAE,IAAI,EAAE,CAAC,6BAA6B,CAAC,EAAE;KACnD;IACD,cAAc,EAAE;QACd,OAAO,EAAE;YACP,IAAI,EAAE,yBAAyB;YAC/B,GAAG,EAAE,kCAAkC;SACxC;KACF;IACD,OAAO,EAAE,IAAI;IACb,MAAM,EAAE;QACN,eAAe,CAAC,WAAgD;YAC9D,MAAM,OAAO,GAAG,IAAA,yCAAoB,EAAC,WAAW,CAAC,CAAA;YAEjD,OAAO;gBACL,MAAM,EAAE;oBACN,IAAI,EAAE,UAAU;oBAChB,OAAO,EAAE,GAAG;oBACZ,OAAO,EAAE,WAAW,CAAC,OAAO;iBAC7B;gBACD,KAAK,EAAE;oBACL,WAAW,EAAE;wBACX,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE;wBACnC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE;wBACjC,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE;wBAC/B,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE;wBACrC,EAAE,IAAI,EAAE,wBAAwB,EAAE,IAAI,EAAE,SAAS,EAAE;wBACnD,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,SAAS,EAAE;wBACzC,EAAE,IAAI,EAAE,sBAAsB,EAAE,IAAI,EAAE,SAAS,EAAE;wBACjD,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE;wBACtC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE;wBAClC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE;wBAClC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE;wBAC/B,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,WAAW,EAAE;wBAC1C,EAAE,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE,OAAO,EAAE;qBAC1C;iBACF;gBACD,WAAW,EAAE,aAAa;gBAC1B,OAAO,EAAE,OAAO;aACjB,CAAA;QACH,CAAC;KACF;CACF,CAAC,CAAA"}
+{"version":3,"file":"abstractTestnet.js","sourceRoot":"","sources":["../../../chains/definitions/abstractTestnet.ts"],"names":[],"mappings":";;;AAAA,qEAA8D;AAC9D,gEAAyD;AAEzD,8EAA4E;AAE/D,QAAA,eAAe,GAAiB,IAAA,4BAAW,EAAC;IACvD,GAAG,4BAAW;IACd,EAAE,EAAE,MAAM;IACV,IAAI,EAAE,kBAAkB;IACxB,cAAc,EAAE;QACd,QAAQ,EAAE,EAAE;QACZ,IAAI,EAAE,KAAK;QACX,MAAM,EAAE,KAAK;KACd;IACD,OAAO,EAAE;QACP,OAAO,EAAE,EAAE,IAAI,EAAE,CAAC,6BAA6B,CAAC,EAAE;KACnD;IACD,cAAc,EAAE;QACd,OAAO,EAAE;YACP,IAAI,EAAE,yBAAyB;YAC/B,GAAG,EAAE,kCAAkC;SACxC;KACF;IACD,OAAO,EAAE,IAAI;IACb,SAAS,EAAE;QACT,UAAU,EAAE;YACV,OAAO,EAAE,4CAA4C;YACrD,YAAY,EAAE,MAAM;SACrB;KACF;IACD,MAAM,EAAE;QACN,eAAe,CAAC,WAAgD;YAC9D,MAAM,OAAO,GAAG,IAAA,yCAAoB,EAAC,WAAW,CAAC,CAAA;YAEjD,OAAO;gBACL,MAAM,EAAE;oBACN,IAAI,EAAE,UAAU;oBAChB,OAAO,EAAE,GAAG;oBACZ,OAAO,EAAE,WAAW,CAAC,OAAO;iBAC7B;gBACD,KAAK,EAAE;oBACL,WAAW,EAAE;wBACX,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE;wBACnC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE;wBACjC,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE;wBAC/B,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE;wBACrC,EAAE,IAAI,EAAE,wBAAwB,EAAE,IAAI,EAAE,SAAS,EAAE;wBACnD,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,SAAS,EAAE;wBACzC,EAAE,IAAI,EAAE,sBAAsB,EAAE,IAAI,EAAE,SAAS,EAAE;wBACjD,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE;wBACtC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE;wBAClC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE;wBAClC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE;wBAC/B,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,WAAW,EAAE;wBAC1C,EAAE,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE,OAAO,EAAE;qBAC1C;iBACF;gBACD,WAAW,EAAE,aAAa;gBAC1B,OAAO,EAAE,OAAO;aACjB,CAAA;QACH,CAAC;KACF;CACF,CAAC,CAAA"}

package/_cjs/errors/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
-exports.version = '2.21.6';
+exports.version = '2.21.7';
 //# sourceMappingURL=version.js.map

package/_cjs/experimental/eip7702/utils/hashAuthorization.js

@@ -10,7 +10,11 @@ function hashAuthorization(parameters) {
     const { chainId, contractAddress, nonce, to } = parameters;
     const hash = (0, keccak256_js_1.keccak256)((0, concat_js_1.concatHex)([
         '0x05',
-        (0, toRlp_js_1.toRlp)([(0, toHex_js_1.numberToHex)(chainId), contractAddress, (0, toHex_js_1.numberToHex)(nonce)]),
+        (0, toRlp_js_1.toRlp)([
+            (0, toHex_js_1.numberToHex)(chainId),
+            contractAddress,
+            nonce ? (0, toHex_js_1.numberToHex)(nonce) : '0x',
+        ]),
     ]));
     if (to === 'bytes')
         return (0, toBytes_js_1.hexToBytes)(hash);

package/_cjs/experimental/eip7702/utils/hashAuthorization.js.map

@@ -1 +1 @@
-{"version":3,"file":"hashAuthorization.js","sourceRoot":"","sources":["../../../../experimental/eip7702/utils/hashAuthorization.ts"],"names":[],"mappings":";;AA2CA,8CAYC;AArDD,6DAGsC;AACtC,mEAG2C;AAC3C,+DAGyC;AACzC,+DAA6E;AAC7E,mEAGyC;AAyBzC,SAAgB,iBAAiB,CAC/B,UAA2C;IAE3C,MAAM,EAAE,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,UAAU,CAAA;IAC1D,MAAM,IAAI,GAAG,IAAA,wBAAS,EACpB,IAAA,qBAAS,EAAC;QACR,MAAM;QACN,IAAA,gBAAK,EAAC,CAAC,IAAA,sBAAW,EAAC,OAAO,CAAC,EAAE,eAAe,EAAE,IAAA,sBAAW,EAAC,KAAK,CAAC,CAAC,CAAC;KACnE,CAAC,CACH,CAAA;IACD,IAAI,EAAE,KAAK,OAAO;QAAE,OAAO,IAAA,uBAAU,EAAC,IAAI,CAAoC,CAAA;IAC9E,OAAO,IAAuC,CAAA;AAChD,CAAC"}
+{"version":3,"file":"hashAuthorization.js","sourceRoot":"","sources":["../../../../experimental/eip7702/utils/hashAuthorization.ts"],"names":[],"mappings":";;AA2CA,8CAgBC;AAzDD,6DAGsC;AACtC,mEAG2C;AAC3C,+DAGyC;AACzC,+DAA6E;AAC7E,mEAGyC;AAyBzC,SAAgB,iBAAiB,CAC/B,UAA2C;IAE3C,MAAM,EAAE,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,UAAU,CAAA;IAC1D,MAAM,IAAI,GAAG,IAAA,wBAAS,EACpB,IAAA,qBAAS,EAAC;QACR,MAAM;QACN,IAAA,gBAAK,EAAC;YACJ,IAAA,sBAAW,EAAC,OAAO,CAAC;YACpB,eAAe;YACf,KAAK,CAAC,CAAC,CAAC,IAAA,sBAAW,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI;SAClC,CAAC;KACH,CAAC,CACH,CAAA;IACD,IAAI,EAAE,KAAK,OAAO;QAAE,OAAO,IAAA,uBAAU,EAAC,IAAI,CAAoC,CAAA;IAC9E,OAAO,IAAuC,CAAA;AAChD,CAAC"}

package/_cjs/experimental/eip7702/utils/serializeAuthorizationList.js

@@ -12,7 +12,7 @@ function serializeAuthorizationList(authorizationList) {
         serializedAuthorizationList.push([
             (0, toHex_js_1.toHex)(chainId),
             contractAddress,
-            (0, toHex_js_1.toHex)(nonce),
+            nonce ? (0, toHex_js_1.toHex)(nonce) : '0x',
             ...(0, serializeTransaction_js_1.toYParitySignatureArray)({}, signature),
         ]);
     }

package/_cjs/experimental/eip7702/utils/serializeAuthorizationList.js.map

@@ -1 +1 @@
-{"version":3,"file":"serializeAuthorizationList.js","sourceRoot":"","sources":["../../../../experimental/eip7702/utils/serializeAuthorizationList.ts"],"names":[],"mappings":";;AAeA,gEAiBC;AA/BD,+DAAwD;AACxD,gGAA4F;AAa5F,SAAgB,0BAA0B,CACxC,iBAA+D;IAE/D,IAAI,CAAC,iBAAiB,IAAI,iBAAiB,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAA;IAEnE,MAAM,2BAA2B,GAAG,EAAE,CAAA;IACtC,KAAK,MAAM,aAAa,IAAI,iBAAiB,EAAE,CAAC;QAC9C,MAAM,EAAE,eAAe,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,SAAS,EAAE,GAAG,aAAa,CAAA;QACvE,2BAA2B,CAAC,IAAI,CAAC;YAC/B,IAAA,gBAAK,EAAC,OAAO,CAAC;YACd,eAAe;YACf,IAAA,gBAAK,EAAC,KAAK,CAAC;YACZ,GAAG,IAAA,iDAAuB,EAAC,EAAE,EAAE,SAAS,CAAC;SAC1C,CAAC,CAAA;IACJ,CAAC;IAED,OAAO,2BAAyE,CAAA;AAClF,CAAC"}
+{"version":3,"file":"serializeAuthorizationList.js","sourceRoot":"","sources":["../../../../experimental/eip7702/utils/serializeAuthorizationList.ts"],"names":[],"mappings":";;AAeA,gEAiBC;AA/BD,+DAAwD;AACxD,gGAA4F;AAa5F,SAAgB,0BAA0B,CACxC,iBAA+D;IAE/D,IAAI,CAAC,iBAAiB,IAAI,iBAAiB,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAA;IAEnE,MAAM,2BAA2B,GAAG,EAAE,CAAA;IACtC,KAAK,MAAM,aAAa,IAAI,iBAAiB,EAAE,CAAC;QAC9C,MAAM,EAAE,eAAe,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,SAAS,EAAE,GAAG,aAAa,CAAA;QACvE,2BAA2B,CAAC,IAAI,CAAC;YAC/B,IAAA,gBAAK,EAAC,OAAO,CAAC;YACd,eAAe;YACf,KAAK,CAAC,CAAC,CAAC,IAAA,gBAAK,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI;YAC3B,GAAG,IAAA,iDAAuB,EAAC,EAAE,EAAE,SAAS,CAAC;SAC1C,CAAC,CAAA;IACJ,CAAC;IAED,OAAO,2BAAyE,CAAA;AAClF,CAAC"}

package/_esm/chains/definitions/abstractTestnet.js

@@ -20,6 +20,12 @@ export const abstractTestnet = /*#__PURE__*/ defineChain({
         },
     },
     testnet: true,
+    contracts: {
+        multicall3: {
+            address: '0xF9cda624FBC7e059355ce98a31693d299FACd963',
+            blockCreated: 358349,
+        },
+    },
     custom: {
         getEip712Domain(transaction) {
             const message = transactionToMessage(transaction);

package/_esm/chains/definitions/abstractTestnet.js.map

@@ -1 +1 @@
-{"version":3,"file":"abstractTestnet.js","sourceRoot":"","sources":["../../../chains/definitions/abstractTestnet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AAC9D,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAEzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAA;AAE5E,MAAM,CAAC,MAAM,eAAe,GAAG,aAAa,CAAC,WAAW,CAAC;IACvD,GAAG,WAAW;IACd,EAAE,EAAE,MAAM;IACV,IAAI,EAAE,kBAAkB;IACxB,cAAc,EAAE;QACd,QAAQ,EAAE,EAAE;QACZ,IAAI,EAAE,KAAK;QACX,MAAM,EAAE,KAAK;KACd;IACD,OAAO,EAAE;QACP,OAAO,EAAE,EAAE,IAAI,EAAE,CAAC,6BAA6B,CAAC,EAAE;KACnD;IACD,cAAc,EAAE;QACd,OAAO,EAAE;YACP,IAAI,EAAE,yBAAyB;YAC/B,GAAG,EAAE,kCAAkC;SACxC;KACF;IACD,OAAO,EAAE,IAAI;IACb,MAAM,EAAE;QACN,eAAe,CAAC,WAAgD;YAC9D,MAAM,OAAO,GAAG,oBAAoB,CAAC,WAAW,CAAC,CAAA;YAEjD,OAAO;gBACL,MAAM,EAAE;oBACN,IAAI,EAAE,UAAU,EAAE,sCAAsC;oBACxD,OAAO,EAAE,GAAG;oBACZ,OAAO,EAAE,WAAW,CAAC,OAAO;iBAC7B;gBACD,KAAK,EAAE;oBACL,WAAW,EAAE;wBACX,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE;wBACnC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE;wBACjC,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE;wBAC/B,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE;wBACrC,EAAE,IAAI,EAAE,wBAAwB,EAAE,IAAI,EAAE,SAAS,EAAE;wBACnD,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,SAAS,EAAE;wBACzC,EAAE,IAAI,EAAE,sBAAsB,EAAE,IAAI,EAAE,SAAS,EAAE;wBACjD,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE;wBACtC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE;wBAClC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE;wBAClC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE;wBAC/B,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,WAAW,EAAE;wBAC1C,EAAE,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE,OAAO,EAAE;qBAC1C;iBACF;gBACD,WAAW,EAAE,aAAa;gBAC1B,OAAO,EAAE,OAAO;aACjB,CAAA;QACH,CAAC;KACF;CACF,CAAC,CAAA"}
+{"version":3,"file":"abstractTestnet.js","sourceRoot":"","sources":["../../../chains/definitions/abstractTestnet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AAC9D,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAEzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAA;AAE5E,MAAM,CAAC,MAAM,eAAe,GAAG,aAAa,CAAC,WAAW,CAAC;IACvD,GAAG,WAAW;IACd,EAAE,EAAE,MAAM;IACV,IAAI,EAAE,kBAAkB;IACxB,cAAc,EAAE;QACd,QAAQ,EAAE,EAAE;QACZ,IAAI,EAAE,KAAK;QACX,MAAM,EAAE,KAAK;KACd;IACD,OAAO,EAAE;QACP,OAAO,EAAE,EAAE,IAAI,EAAE,CAAC,6BAA6B,CAAC,EAAE;KACnD;IACD,cAAc,EAAE;QACd,OAAO,EAAE;YACP,IAAI,EAAE,yBAAyB;YAC/B,GAAG,EAAE,kCAAkC;SACxC;KACF;IACD,OAAO,EAAE,IAAI;IACb,SAAS,EAAE;QACT,UAAU,EAAE;YACV,OAAO,EAAE,4CAA4C;YACrD,YAAY,EAAE,MAAM;SACrB;KACF;IACD,MAAM,EAAE;QACN,eAAe,CAAC,WAAgD;YAC9D,MAAM,OAAO,GAAG,oBAAoB,CAAC,WAAW,CAAC,CAAA;YAEjD,OAAO;gBACL,MAAM,EAAE;oBACN,IAAI,EAAE,UAAU,EAAE,sCAAsC;oBACxD,OAAO,EAAE,GAAG;oBACZ,OAAO,EAAE,WAAW,CAAC,OAAO;iBAC7B;gBACD,KAAK,EAAE;oBACL,WAAW,EAAE;wBACX,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE;wBACnC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE;wBACjC,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE;wBAC/B,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE;wBACrC,EAAE,IAAI,EAAE,wBAAwB,EAAE,IAAI,EAAE,SAAS,EAAE;wBACnD,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,SAAS,EAAE;wBACzC,EAAE,IAAI,EAAE,sBAAsB,EAAE,IAAI,EAAE,SAAS,EAAE;wBACjD,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE;wBACtC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE;wBAClC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE;wBAClC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE;wBAC/B,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,WAAW,EAAE;wBAC1C,EAAE,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE,OAAO,EAAE;qBAC1C;iBACF;gBACD,WAAW,EAAE,aAAa;gBAC1B,OAAO,EAAE,OAAO;aACjB,CAAA;QACH,CAAC;KACF;CACF,CAAC,CAAA"}

package/_esm/errors/version.js

@@ -1,2 +1,2 @@
-export const version = '2.21.6';
+export const version = '2.21.7';
 //# sourceMappingURL=version.js.map

package/_esm/experimental/eip7702/utils/hashAuthorization.js

@@ -10,7 +10,11 @@ export function hashAuthorization(parameters) {
     const { chainId, contractAddress, nonce, to } = parameters;
     const hash = keccak256(concatHex([
         '0x05',
-        toRlp([numberToHex(chainId), contractAddress, numberToHex(nonce)]),
+        toRlp([
+            numberToHex(chainId),
+            contractAddress,
+            nonce ? numberToHex(nonce) : '0x',
+        ]),
     ]));
     if (to === 'bytes')
         return hexToBytes(hash);

package/_esm/experimental/eip7702/utils/hashAuthorization.js.map

@@ -1 +1 @@
-{"version":3,"file":"hashAuthorization.js","sourceRoot":"","sources":["../../../../experimental/eip7702/utils/hashAuthorization.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,SAAS,GACV,MAAM,+BAA+B,CAAA;AACtC,OAAO,EAEL,UAAU,GACX,MAAM,oCAAoC,CAAA;AAC3C,OAAO,EAEL,WAAW,GACZ,MAAM,kCAAkC,CAAA;AACzC,OAAO,EAAuB,KAAK,EAAE,MAAM,kCAAkC,CAAA;AAC7E,OAAO,EAEL,SAAS,GACV,MAAM,kCAAkC,CAAA;AAsBzC;;GAEG;AACH,MAAM,UAAU,iBAAiB,CAC/B,UAA2C;IAE3C,MAAM,EAAE,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,UAAU,CAAA;IAC1D,MAAM,IAAI,GAAG,SAAS,CACpB,SAAS,CAAC;QACR,MAAM;QACN,KAAK,CAAC,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,eAAe,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;KACnE,CAAC,CACH,CAAA;IACD,IAAI,EAAE,KAAK,OAAO;QAAE,OAAO,UAAU,CAAC,IAAI,CAAoC,CAAA;IAC9E,OAAO,IAAuC,CAAA;AAChD,CAAC"}
+{"version":3,"file":"hashAuthorization.js","sourceRoot":"","sources":["../../../../experimental/eip7702/utils/hashAuthorization.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,SAAS,GACV,MAAM,+BAA+B,CAAA;AACtC,OAAO,EAEL,UAAU,GACX,MAAM,oCAAoC,CAAA;AAC3C,OAAO,EAEL,WAAW,GACZ,MAAM,kCAAkC,CAAA;AACzC,OAAO,EAAuB,KAAK,EAAE,MAAM,kCAAkC,CAAA;AAC7E,OAAO,EAEL,SAAS,GACV,MAAM,kCAAkC,CAAA;AAsBzC;;GAEG;AACH,MAAM,UAAU,iBAAiB,CAC/B,UAA2C;IAE3C,MAAM,EAAE,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,UAAU,CAAA;IAC1D,MAAM,IAAI,GAAG,SAAS,CACpB,SAAS,CAAC;QACR,MAAM;QACN,KAAK,CAAC;YACJ,WAAW,CAAC,OAAO,CAAC;YACpB,eAAe;YACf,KAAK,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI;SAClC,CAAC;KACH,CAAC,CACH,CAAA;IACD,IAAI,EAAE,KAAK,OAAO;QAAE,OAAO,UAAU,CAAC,IAAI,CAAoC,CAAA;IAC9E,OAAO,IAAuC,CAAA;AAChD,CAAC"}

package/_esm/experimental/eip7702/utils/serializeAuthorizationList.js

@@ -12,7 +12,7 @@ export function serializeAuthorizationList(authorizationList) {
         serializedAuthorizationList.push([
             toHex(chainId),
             contractAddress,
-            toHex(nonce),
+            nonce ? toHex(nonce) : '0x',
             ...toYParitySignatureArray({}, signature),
         ]);
     }

package/_esm/experimental/eip7702/utils/serializeAuthorizationList.js.map

@@ -1 +1 @@
-{"version":3,"file":"serializeAuthorizationList.js","sourceRoot":"","sources":["../../../../experimental/eip7702/utils/serializeAuthorizationList.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,kCAAkC,CAAA;AACxD,OAAO,EAAE,uBAAuB,EAAE,MAAM,oDAAoD,CAAA;AAU5F;;GAEG;AACH,MAAM,UAAU,0BAA0B,CACxC,iBAA+D;IAE/D,IAAI,CAAC,iBAAiB,IAAI,iBAAiB,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAA;IAEnE,MAAM,2BAA2B,GAAG,EAAE,CAAA;IACtC,KAAK,MAAM,aAAa,IAAI,iBAAiB,EAAE,CAAC;QAC9C,MAAM,EAAE,eAAe,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,SAAS,EAAE,GAAG,aAAa,CAAA;QACvE,2BAA2B,CAAC,IAAI,CAAC;YAC/B,KAAK,CAAC,OAAO,CAAC;YACd,eAAe;YACf,KAAK,CAAC,KAAK,CAAC;YACZ,GAAG,uBAAuB,CAAC,EAAE,EAAE,SAAS,CAAC;SAC1C,CAAC,CAAA;IACJ,CAAC;IAED,OAAO,2BAAyE,CAAA;AAClF,CAAC"}
+{"version":3,"file":"serializeAuthorizationList.js","sourceRoot":"","sources":["../../../../experimental/eip7702/utils/serializeAuthorizationList.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,kCAAkC,CAAA;AACxD,OAAO,EAAE,uBAAuB,EAAE,MAAM,oDAAoD,CAAA;AAU5F;;GAEG;AACH,MAAM,UAAU,0BAA0B,CACxC,iBAA+D;IAE/D,IAAI,CAAC,iBAAiB,IAAI,iBAAiB,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAA;IAEnE,MAAM,2BAA2B,GAAG,EAAE,CAAA;IACtC,KAAK,MAAM,aAAa,IAAI,iBAAiB,EAAE,CAAC;QAC9C,MAAM,EAAE,eAAe,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,SAAS,EAAE,GAAG,aAAa,CAAA;QACvE,2BAA2B,CAAC,IAAI,CAAC;YAC/B,KAAK,CAAC,OAAO,CAAC;YACd,eAAe;YACf,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI;YAC3B,GAAG,uBAAuB,CAAC,EAAE,EAAE,SAAS,CAAC;SAC1C,CAAC,CAAA;IACJ,CAAC;IAED,OAAO,2BAAyE,CAAA;AAClF,CAAC"}

package/_types/celo/chainConfig.d.ts

@@ -15,6 +15,7 @@ export declare const chainConfig: {
                 miner: import("abitype").Address;
                 nonce: bigint | null | undefined;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../index.js").Hex | undefined;
                 parentHash: import("../index.js").Hash;
                 receiptsRoot: import("../index.js").Hex;
                 sealFields: import("../index.js").Hex[];
@@ -428,6 +429,7 @@ export declare const chainConfig: {
                 miner: import("abitype").Address;
                 nonce: bigint | null | undefined;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../index.js").Hex | undefined;
                 parentHash: import("../index.js").Hash;
                 receiptsRoot: import("../index.js").Hex;
                 sealFields: import("../index.js").Hex[];

package/_types/celo/chainConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chainConfig.d.ts","sourceRoot":"","sources":["../../celo/chainConfig.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAId,CAAA"}
+{"version":3,"file":"chainConfig.d.ts","sourceRoot":"","sources":["../../celo/chainConfig.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAId,CAAA"}

package/_types/celo/formatters.d.ts

@@ -15,6 +15,7 @@ export declare const formatters: {
             miner: import("abitype").Address;
             nonce: bigint | null | undefined;
             number: bigint | null;
+            parentBeaconBlockRoot?: import("../index.js").Hex | undefined;
             parentHash: import("../index.js").Hash;
             receiptsRoot: import("../index.js").Hex;
             sealFields: import("../index.js").Hex[];

package/_types/celo/formatters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatters.d.ts","sourceRoot":"","sources":["../../celo/formatters.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAEV,YAAY,EACZ,kBAAkB,EAElB,eAAe,EACf,sBAAsB,EACvB,MAAM,YAAY,CAAA;AAGnB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Da,CAAA"}
+{"version":3,"file":"formatters.d.ts","sourceRoot":"","sources":["../../celo/formatters.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAEV,YAAY,EACZ,kBAAkB,EAElB,eAAe,EACf,sBAAsB,EACvB,MAAM,YAAY,CAAA;AAGnB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Da,CAAA"}

package/_types/chains/definitions/abstractTestnet.d.ts

@@ -6,15 +6,12 @@ export declare const abstractTestnet: {
             readonly url: "https://explorer.testnet.abs.xyz";
         };
     };
-    contracts?: import("../index.js").Prettify<{
-        [key: string]: import("../../index.js").ChainContract | {
-            [sourceId: number]: import("../../index.js").ChainContract | undefined;
-        } | undefined;
-    } & {
-        ensRegistry?: import("../../index.js").ChainContract | undefined;
-        ensUniversalResolver?: import("../../index.js").ChainContract | undefined;
-        multicall3?: import("../../index.js").ChainContract | undefined;
-    }> | undefined;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xF9cda624FBC7e059355ce98a31693d299FACd963";
+            readonly blockCreated: 358349;
+        };
+    };
     id: 11124;
     name: "Abstract Testnet";
     nativeCurrency: {
@@ -64,6 +61,7 @@ export declare const abstractTestnet: {
                 mixHash: import("../../index.js").Hash;
                 nonce: `0x${string}` | null;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];

package/_types/chains/definitions/abstractTestnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"abstractTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/abstractTestnet.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,mCAAmC,CAAA;AAG5F,eAAO,MAAM,eAAe;;;;;;;;;;;;mBAsCF,CAAC;4BACM,CAAC;kBACC,CAAA;;;;;;;;;;;;;;;;;gDApBF,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BlE,CAAA"}
+{"version":3,"file":"abstractTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/abstractTestnet.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,mCAAmC,CAAA;AAG5F,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDA0BK,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BlE,CAAA"}

package/_types/chains/definitions/ancient8.d.ts

@@ -76,6 +76,7 @@ export declare const ancient8: {
                 mixHash: import("../../index.js").Hash;
                 nonce: `0x${string}` | null;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];

package/_types/chains/definitions/ancient8.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ancient8.d.ts","sourceRoot":"","sources":["../../../chains/definitions/ancient8.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCnB,CAAA"}
+{"version":3,"file":"ancient8.d.ts","sourceRoot":"","sources":["../../../chains/definitions/ancient8.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCnB,CAAA"}

package/_types/chains/definitions/ancient8Sepolia.d.ts

@@ -76,6 +76,7 @@ export declare const ancient8Sepolia: {
                 mixHash: import("../../index.js").Hash;
                 nonce: `0x${string}` | null;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];

package/_types/chains/definitions/ancient8Sepolia.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ancient8Sepolia.d.ts","sourceRoot":"","sources":["../../../chains/definitions/ancient8Sepolia.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsC1B,CAAA"}
+{"version":3,"file":"ancient8Sepolia.d.ts","sourceRoot":"","sources":["../../../chains/definitions/ancient8Sepolia.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsC1B,CAAA"}

package/_types/chains/definitions/base.d.ts

@@ -80,6 +80,7 @@ export declare const base: {
                 mixHash: import("../../index.js").Hash;
                 nonce: `0x${string}` | null;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];

package/_types/chains/definitions/base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../chains/definitions/base.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Cf,CAAA"}
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../chains/definitions/base.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Cf,CAAA"}

package/_types/chains/definitions/baseGoerli.d.ts

@@ -78,6 +78,7 @@ export declare const baseGoerli: {
                 mixHash: import("../../index.js").Hash;
                 nonce: `0x${string}` | null;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];

package/_types/chains/definitions/baseGoerli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"baseGoerli.d.ts","sourceRoot":"","sources":["../../../chains/definitions/baseGoerli.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCrB,CAAA"}
+{"version":3,"file":"baseGoerli.d.ts","sourceRoot":"","sources":["../../../chains/definitions/baseGoerli.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCrB,CAAA"}

package/_types/chains/definitions/baseSepolia.d.ts

@@ -85,6 +85,7 @@ export declare const baseSepolia: {
                 mixHash: import("../../index.js").Hash;
                 nonce: `0x${string}` | null;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];

package/_types/chains/definitions/baseSepolia.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"baseSepolia.d.ts","sourceRoot":"","sources":["../../../chains/definitions/baseSepolia.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDtB,CAAA"}
+{"version":3,"file":"baseSepolia.d.ts","sourceRoot":"","sources":["../../../chains/definitions/baseSepolia.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDtB,CAAA"}

package/_types/chains/definitions/bob.d.ts

@@ -75,6 +75,7 @@ export declare const bob: {
                 mixHash: import("../../index.js").Hash;
                 nonce: `0x${string}` | null;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];

package/_types/chains/definitions/bob.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bob.d.ts","sourceRoot":"","sources":["../../../chains/definitions/bob.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCd,CAAA"}
+{"version":3,"file":"bob.d.ts","sourceRoot":"","sources":["../../../chains/definitions/bob.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCd,CAAA"}

package/_types/chains/definitions/bobSepolia.d.ts

@@ -75,6 +75,7 @@ export declare const bobSepolia: {
                 mixHash: import("../../index.js").Hash;
                 nonce: `0x${string}` | null;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];

package/_types/chains/definitions/bobSepolia.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bobSepolia.d.ts","sourceRoot":"","sources":["../../../chains/definitions/bobSepolia.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CrB,CAAA"}
+{"version":3,"file":"bobSepolia.d.ts","sourceRoot":"","sources":["../../../chains/definitions/bobSepolia.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CrB,CAAA"}

package/_types/chains/definitions/celo.d.ts

@@ -43,6 +43,7 @@ export declare const celo: {
                 miner: import("abitype").Address;
                 nonce: bigint | null | undefined;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];
@@ -453,6 +454,7 @@ export declare const celo: {
                 miner: import("abitype").Address;
                 nonce: bigint | null | undefined;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];

package/_types/chains/definitions/celo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"celo.d.ts","sourceRoot":"","sources":["../../../chains/definitions/celo.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Bf,CAAA"}
+{"version":3,"file":"celo.d.ts","sourceRoot":"","sources":["../../../chains/definitions/celo.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Bf,CAAA"}

package/_types/chains/definitions/celoAlfajores.d.ts

@@ -43,6 +43,7 @@ export declare const celoAlfajores: {
                 miner: import("abitype").Address;
                 nonce: bigint | null | undefined;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];
@@ -453,6 +454,7 @@ export declare const celoAlfajores: {
                 miner: import("abitype").Address;
                 nonce: bigint | null | undefined;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];

package/_types/chains/definitions/celoAlfajores.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"celoAlfajores.d.ts","sourceRoot":"","sources":["../../../chains/definitions/celoAlfajores.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BxB,CAAA"}
+{"version":3,"file":"celoAlfajores.d.ts","sourceRoot":"","sources":["../../../chains/definitions/celoAlfajores.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BxB,CAAA"}

package/_types/chains/definitions/dchain.d.ts

@@ -59,6 +59,7 @@ export declare const dchain: {
                 mixHash: import("../../index.js").Hash;
                 nonce: `0x${string}` | null;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];

package/_types/chains/definitions/dchain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dchain.d.ts","sourceRoot":"","sources":["../../../chains/definitions/dchain.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBjB,CAAA"}
+{"version":3,"file":"dchain.d.ts","sourceRoot":"","sources":["../../../chains/definitions/dchain.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBjB,CAAA"}

package/_types/chains/definitions/dchainTestnet.d.ts

@@ -59,6 +59,7 @@ export declare const dchainTestnet: {
                 mixHash: import("../../index.js").Hash;
                 nonce: `0x${string}` | null;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];

package/_types/chains/definitions/dchainTestnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dchainTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/dchainTestnet.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBxB,CAAA"}
+{"version":3,"file":"dchainTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/dchainTestnet.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBxB,CAAA"}

package/_types/chains/definitions/fraxtal.d.ts

@@ -79,6 +79,7 @@ export declare const fraxtal: {
                 mixHash: import("../../index.js").Hash;
                 nonce: `0x${string}` | null;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];

package/_types/chains/definitions/fraxtal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fraxtal.d.ts","sourceRoot":"","sources":["../../../chains/definitions/fraxtal.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyClB,CAAA"}
+{"version":3,"file":"fraxtal.d.ts","sourceRoot":"","sources":["../../../chains/definitions/fraxtal.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyClB,CAAA"}

package/_types/chains/definitions/fraxtalTestnet.d.ts

@@ -79,6 +79,7 @@ export declare const fraxtalTestnet: {
                 mixHash: import("../../index.js").Hash;
                 nonce: `0x${string}` | null;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];

package/_types/chains/definitions/fraxtalTestnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fraxtalTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/fraxtalTestnet.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCzB,CAAA"}
+{"version":3,"file":"fraxtalTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/fraxtalTestnet.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCzB,CAAA"}

package/_types/chains/definitions/funkiMainnet.d.ts

@@ -58,6 +58,7 @@ export declare const funkiMainnet: {
                 mixHash: import("../../index.js").Hash;
                 nonce: `0x${string}` | null;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];

package/_types/chains/definitions/funkiMainnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"funkiMainnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/funkiMainnet.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBvB,CAAA"}
+{"version":3,"file":"funkiMainnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/funkiMainnet.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBvB,CAAA"}

package/_types/chains/definitions/funkiSepolia.d.ts

@@ -62,6 +62,7 @@ export declare const funkiSepolia: {
                 mixHash: import("../../index.js").Hash;
                 nonce: `0x${string}` | null;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];

package/_types/chains/definitions/funkiSepolia.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"funkiSepolia.d.ts","sourceRoot":"","sources":["../../../chains/definitions/funkiSepolia.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BvB,CAAA"}
+{"version":3,"file":"funkiSepolia.d.ts","sourceRoot":"","sources":["../../../chains/definitions/funkiSepolia.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BvB,CAAA"}

package/_types/chains/definitions/garnet.d.ts

@@ -80,6 +80,7 @@ export declare const garnet: {
                 mixHash: import("../../index.js").Hash;
                 nonce: `0x${string}` | null;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];

package/_types/chains/definitions/garnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"garnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/garnet.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2CjB,CAAA"}
+{"version":3,"file":"garnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/garnet.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2CjB,CAAA"}

package/_types/chains/definitions/lisk.d.ts

@@ -44,6 +44,7 @@ export declare const lisk: {
                 mixHash: import("../../index.js").Hash;
                 nonce: `0x${string}` | null;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];

package/_types/chains/definitions/lisk.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lisk.d.ts","sourceRoot":"","sources":["../../../chains/definitions/lisk.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2Bf,CAAA"}
+{"version":3,"file":"lisk.d.ts","sourceRoot":"","sources":["../../../chains/definitions/lisk.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2Bf,CAAA"}

package/_types/chains/definitions/liskSepolia.d.ts

@@ -77,6 +77,7 @@ export declare const liskSepolia: {
                 mixHash: import("../../index.js").Hash;
                 nonce: `0x${string}` | null;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];

package/_types/chains/definitions/liskSepolia.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"liskSepolia.d.ts","sourceRoot":"","sources":["../../../chains/definitions/liskSepolia.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCtB,CAAA"}
+{"version":3,"file":"liskSepolia.d.ts","sourceRoot":"","sources":["../../../chains/definitions/liskSepolia.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCtB,CAAA"}

package/_types/chains/definitions/metalL2.d.ts

@@ -79,6 +79,7 @@ export declare const metalL2: {
                 mixHash: import("../../index.js").Hash;
                 nonce: `0x${string}` | null;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];

package/_types/chains/definitions/metalL2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metalL2.d.ts","sourceRoot":"","sources":["../../../chains/definitions/metalL2.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6ClB,CAAA"}
+{"version":3,"file":"metalL2.d.ts","sourceRoot":"","sources":["../../../chains/definitions/metalL2.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6ClB,CAAA"}

package/_types/chains/definitions/modeTestnet.d.ts

@@ -81,6 +81,7 @@ export declare const modeTestnet: {
                 mixHash: import("../../index.js").Hash;
                 nonce: `0x${string}` | null;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];

package/_types/chains/definitions/modeTestnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"modeTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/modeTestnet.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4CtB,CAAA"}
+{"version":3,"file":"modeTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/modeTestnet.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4CtB,CAAA"}

package/_types/chains/definitions/optimism.d.ts

@@ -83,6 +83,7 @@ export declare const optimism: {
                 mixHash: import("../../index.js").Hash;
                 nonce: `0x${string}` | null;
                 number: bigint | null;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | undefined;
                 parentHash: import("../../index.js").Hash;
                 receiptsRoot: import("../../index.js").Hex;
                 sealFields: import("../../index.js").Hex[];

package/_types/chains/definitions/optimism.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"optimism.d.ts","sourceRoot":"","sources":["../../../chains/definitions/optimism.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6CnB,CAAA"}
+{"version":3,"file":"optimism.d.ts","sourceRoot":"","sources":["../../../chains/definitions/optimism.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6CnB,CAAA"}