@0xpolygonid/js-sdk 1.17.1 → 1.17.2

package/dist/browser/umd/index.js

@@ -2182,19 +2182,19 @@ var PolygonIdSdk = (function (exports) {
         }
         return [Ah, Al];
     }
-    const toBig = (h, l) => (BigInt(h >>> 0) << _32n$1) | BigInt(l >>> 0);
+    const toBig$1 = (h, l) => (BigInt(h >>> 0) << _32n$1) | BigInt(l >>> 0);
     // for Shift in [0, 32)
-    const shrSH = (h, _l, s) => h >>> s;
-    const shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+    const shrSH$1 = (h, _l, s) => h >>> s;
+    const shrSL$1 = (h, l, s) => (h << (32 - s)) | (l >>> s);
     // Right rotate for Shift in [1, 32)
-    const rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));
-    const rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+    const rotrSH$1 = (h, l, s) => (h >>> s) | (l << (32 - s));
+    const rotrSL$1 = (h, l, s) => (h << (32 - s)) | (l >>> s);
     // Right rotate for Shift in (32, 64), NOTE: 32 is special case.
-    const rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));
-    const rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));
+    const rotrBH$1 = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));
+    const rotrBL$1 = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));
     // Right rotate for shift===32 (just swaps l&h)
-    const rotr32H = (_h, l) => l;
-    const rotr32L = (h, _l) => h;
+    const rotr32H$1 = (_h, l) => l;
+    const rotr32L$1 = (h, _l) => h;
     // Left rotate for Shift in [1, 32)
     const rotlSH$1 = (h, l, s) => (h << s) | (l >>> (32 - s));
     const rotlSL$1 = (h, l, s) => (l << s) | (h >>> (32 - s));
@@ -2203,30 +2203,30 @@ var PolygonIdSdk = (function (exports) {
     const rotlBL$1 = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));
     // JS uses 32-bit signed integers for bitwise operations which means we cannot
     // simple take carry out of low bit sum by shift, we need to use division.
-    function add$1(Ah, Al, Bh, Bl) {
+    function add$2(Ah, Al, Bh, Bl) {
         const l = (Al >>> 0) + (Bl >>> 0);
         return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };
     }
     // Addition with more than 2 elements
-    const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
-    const add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;
-    const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
-    const add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;
-    const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
-    const add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;
+    const add3L$1 = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+    const add3H$1 = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;
+    const add4L$1 = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+    const add4H$1 = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;
+    const add5L$1 = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+    const add5H$1 = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;
     // prettier-ignore
-    const u64 = {
-        fromBig: fromBig$1, split: split$2, toBig,
-        shrSH, shrSL,
-        rotrSH, rotrSL, rotrBH, rotrBL,
-        rotr32H, rotr32L,
+    const u64$1 = {
+        fromBig: fromBig$1, split: split$2, toBig: toBig$1,
+        shrSH: shrSH$1, shrSL: shrSL$1,
+        rotrSH: rotrSH$1, rotrSL: rotrSL$1, rotrBH: rotrBH$1, rotrBL: rotrBL$1,
+        rotr32H: rotr32H$1, rotr32L: rotr32L$1,
         rotlSH: rotlSH$1, rotlSL: rotlSL$1, rotlBH: rotlBH$1, rotlBL: rotlBL$1,
-        add: add$1, add3L, add3H, add4L, add4H, add5H, add5L,
+        add: add$2, add3L: add3L$1, add3H: add3H$1, add4L: add4L$1, add4H: add4H$1, add5H: add5H$1, add5L: add5L$1,
     };
 
     // Round contants (first 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409):
     // prettier-ignore
-    const [SHA512_Kh, SHA512_Kl] = /* @__PURE__ */ (() => u64.split([
+    const [SHA512_Kh$1, SHA512_Kl$1] = /* @__PURE__ */ (() => u64$1.split([
         '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',
         '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',
         '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',
@@ -2249,9 +2249,9 @@ var PolygonIdSdk = (function (exports) {
         '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'
     ].map(n => BigInt(n))))();
     // Temporary buffer, not used to store anything between runs
-    const SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
-    const SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
-    class SHA512 extends HashMD {
+    const SHA512_W_H$1 = /* @__PURE__ */ new Uint32Array(80);
+    const SHA512_W_L$1 = /* @__PURE__ */ new Uint32Array(80);
+    let SHA512$1 = class SHA512 extends HashMD {
         constructor() {
             super(128, 64, 16, false);
             // We cannot use array here since array allows indexing by variable which means optimizer/compiler cannot use registers.
@@ -2302,43 +2302,43 @@ var PolygonIdSdk = (function (exports) {
         process(view, offset) {
             // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array
             for (let i = 0; i < 16; i++, offset += 4) {
-                SHA512_W_H[i] = view.getUint32(offset);
-                SHA512_W_L[i] = view.getUint32((offset += 4));
+                SHA512_W_H$1[i] = view.getUint32(offset);
+                SHA512_W_L$1[i] = view.getUint32((offset += 4));
             }
             for (let i = 16; i < 80; i++) {
                 // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)
-                const W15h = SHA512_W_H[i - 15] | 0;
-                const W15l = SHA512_W_L[i - 15] | 0;
-                const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);
-                const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);
+                const W15h = SHA512_W_H$1[i - 15] | 0;
+                const W15l = SHA512_W_L$1[i - 15] | 0;
+                const s0h = u64$1.rotrSH(W15h, W15l, 1) ^ u64$1.rotrSH(W15h, W15l, 8) ^ u64$1.shrSH(W15h, W15l, 7);
+                const s0l = u64$1.rotrSL(W15h, W15l, 1) ^ u64$1.rotrSL(W15h, W15l, 8) ^ u64$1.shrSL(W15h, W15l, 7);
                 // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)
-                const W2h = SHA512_W_H[i - 2] | 0;
-                const W2l = SHA512_W_L[i - 2] | 0;
-                const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);
-                const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);
+                const W2h = SHA512_W_H$1[i - 2] | 0;
+                const W2l = SHA512_W_L$1[i - 2] | 0;
+                const s1h = u64$1.rotrSH(W2h, W2l, 19) ^ u64$1.rotrBH(W2h, W2l, 61) ^ u64$1.shrSH(W2h, W2l, 6);
+                const s1l = u64$1.rotrSL(W2h, W2l, 19) ^ u64$1.rotrBL(W2h, W2l, 61) ^ u64$1.shrSL(W2h, W2l, 6);
                 // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];
-                const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
-                const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
-                SHA512_W_H[i] = SUMh | 0;
-                SHA512_W_L[i] = SUMl | 0;
+                const SUMl = u64$1.add4L(s0l, s1l, SHA512_W_L$1[i - 7], SHA512_W_L$1[i - 16]);
+                const SUMh = u64$1.add4H(SUMl, s0h, s1h, SHA512_W_H$1[i - 7], SHA512_W_H$1[i - 16]);
+                SHA512_W_H$1[i] = SUMh | 0;
+                SHA512_W_L$1[i] = SUMl | 0;
             }
             let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
             // Compression function main loop, 80 rounds
             for (let i = 0; i < 80; i++) {
                 // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)
-                const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);
-                const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);
+                const sigma1h = u64$1.rotrSH(Eh, El, 14) ^ u64$1.rotrSH(Eh, El, 18) ^ u64$1.rotrBH(Eh, El, 41);
+                const sigma1l = u64$1.rotrSL(Eh, El, 14) ^ u64$1.rotrSL(Eh, El, 18) ^ u64$1.rotrBL(Eh, El, 41);
                 //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
                 const CHIh = (Eh & Fh) ^ (~Eh & Gh);
                 const CHIl = (El & Fl) ^ (~El & Gl);
                 // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]
                 // prettier-ignore
-                const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
-                const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+                const T1ll = u64$1.add5L(Hl, sigma1l, CHIl, SHA512_Kl$1[i], SHA512_W_L$1[i]);
+                const T1h = u64$1.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh$1[i], SHA512_W_H$1[i]);
                 const T1l = T1ll | 0;
                 // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)
-                const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);
-                const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);
+                const sigma0h = u64$1.rotrSH(Ah, Al, 28) ^ u64$1.rotrBH(Ah, Al, 34) ^ u64$1.rotrBH(Ah, Al, 39);
+                const sigma0l = u64$1.rotrSL(Ah, Al, 28) ^ u64$1.rotrBL(Ah, Al, 34) ^ u64$1.rotrBL(Ah, Al, 39);
                 const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);
                 const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);
                 Hh = Gh | 0;
@@ -2347,38 +2347,38 @@ var PolygonIdSdk = (function (exports) {
                 Gl = Fl | 0;
                 Fh = Eh | 0;
                 Fl = El | 0;
-                ({ h: Eh, l: El } = u64.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+                ({ h: Eh, l: El } = u64$1.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
                 Dh = Ch | 0;
                 Dl = Cl | 0;
                 Ch = Bh | 0;
                 Cl = Bl | 0;
                 Bh = Ah | 0;
                 Bl = Al | 0;
-                const All = u64.add3L(T1l, sigma0l, MAJl);
-                Ah = u64.add3H(All, T1h, sigma0h, MAJh);
+                const All = u64$1.add3L(T1l, sigma0l, MAJl);
+                Ah = u64$1.add3H(All, T1h, sigma0h, MAJh);
                 Al = All | 0;
             }
             // Add the compressed chunk to the current hash value
-            ({ h: Ah, l: Al } = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
-            ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
-            ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
-            ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
-            ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
-            ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
-            ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
-            ({ h: Hh, l: Hl } = u64.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+            ({ h: Ah, l: Al } = u64$1.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+            ({ h: Bh, l: Bl } = u64$1.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+            ({ h: Ch, l: Cl } = u64$1.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+            ({ h: Dh, l: Dl } = u64$1.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+            ({ h: Eh, l: El } = u64$1.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+            ({ h: Fh, l: Fl } = u64$1.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+            ({ h: Gh, l: Gl } = u64$1.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+            ({ h: Hh, l: Hl } = u64$1.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
             this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
         }
         roundClean() {
-            SHA512_W_H.fill(0);
-            SHA512_W_L.fill(0);
+            SHA512_W_H$1.fill(0);
+            SHA512_W_L$1.fill(0);
         }
         destroy() {
             this.buffer.fill(0);
             this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
         }
-    }
-    const sha512 = /* @__PURE__ */ wrapConstructor$1(() => new SHA512());
+    };
+    const sha512$1 = /* @__PURE__ */ wrapConstructor$1(() => new SHA512$1());
 
     /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
     // 100 lines of code in the file are duplicated from noble-hashes (utils).
@@ -3707,7 +3707,7 @@ var PolygonIdSdk = (function (exports) {
         // Base point (x, y) aka generator point
         Gx: BigInt('15112221349535400772501151409588531511454012693041857206046113283949847762202'),
         Gy: BigInt('46316835694926478169428394003475163141307993866256225615783033603165251855960'),
-        hash: sha512,
+        hash: sha512$1,
         randomBytes: randomBytes$1,
         adjustScalarBytes,
         // dom2
@@ -3924,7 +3924,7 @@ var PolygonIdSdk = (function (exports) {
      * SHA2-256 hash function
      * @param message - data that would be hashed
      */
-    const sha256$2 = /* @__PURE__ */ wrapConstructor$1(() => new SHA256$1());
+    const sha256$3 = /* @__PURE__ */ wrapConstructor$1(() => new SHA256$1());
 
     /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
     // Short Weierstrass curve. The formula is: y² = x³ + ax + b
@@ -5027,7 +5027,7 @@ var PolygonIdSdk = (function (exports) {
                 return { k1neg, k1, k2neg, k2 };
             },
         },
-    }, sha256$2);
+    }, sha256$3);
     // Schnorr signatures are superior to ECDSA from above. Below is Schnorr-specific BIP0340 code.
     // https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki
     BigInt(0);
@@ -6306,7 +6306,7 @@ var PolygonIdSdk = (function (exports) {
         Gy: BigInt('0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5'),
         h: BigInt(1),
         lowS: false,
-    }, sha256$2);
+    }, sha256$3);
 
     // https://homes.esat.kuleuven.be/~bosselae/ripemd160.html
     // https://homes.esat.kuleuven.be/~bosselae/ripemd160/pdf/AB-9601/AB-9601.pdf
@@ -7084,9 +7084,9 @@ var PolygonIdSdk = (function (exports) {
       return '0'.repeat(size - data.length) + data;
     }
 
-    function sha256$1(payload) {
+    function sha256$2(payload) {
       const data = typeof payload === 'string' ? fromString$1(payload) : payload;
-      return sha256$2(data);
+      return sha256$3(data);
     }
     const keccak = keccak_256$1;
     function toEthereumAddress(hexPublicKey) {
@@ -7119,7 +7119,7 @@ var PolygonIdSdk = (function (exports) {
 
       return function (data) {
         try {
-          const signature = secp256k1$1.sign(sha256$1(data), privateKeyBytes);
+          const signature = secp256k1$1.sign(sha256$2(data), privateKeyBytes);
           return Promise.resolve(toJose({
             r: leftpad(signature.r.toString(16)),
             s: leftpad(signature.s.toString(16)),
@@ -7135,10 +7135,10 @@ var PolygonIdSdk = (function (exports) {
       // Use the same version/prefix byte as the given address.
       const version = bytesToHex$1(base58ToBytes(otherAddress).slice(0, 1));
       const publicKeyBuffer = hexToBytes$1(publicKey);
-      const publicKeyHash = ripemd160(sha256$1(publicKeyBuffer));
+      const publicKeyHash = ripemd160(sha256$2(publicKeyBuffer));
       const step1 = version + bytesToHex$1(publicKeyHash);
-      const step2 = sha256$1(hexToBytes$1(step1));
-      const step3 = sha256$1(step2);
+      const step2 = sha256$2(hexToBytes$1(step1));
+      const step3 = sha256$2(step2);
       const checksum = bytesToHex$1(step3).substring(0, 8);
       const step4 = step1 + checksum;
       return bytesToBase58(hexToBytes$1(step4));
@@ -7146,7 +7146,7 @@ var PolygonIdSdk = (function (exports) {
 
     function publicKeyToAddress(publicKey, prefix) {
       const publicKeyBuffer = secp256k1$1.ProjectivePoint.fromHex(publicKey).toRawBytes();
-      const hash = ripemd160(sha256$1(publicKeyBuffer));
+      const hash = ripemd160(sha256$2(publicKeyBuffer));
       const words = bech32.toWords(hash);
       return bech32.encode(prefix, words).replace(prefix, '');
     }
@@ -7211,7 +7211,7 @@ var PolygonIdSdk = (function (exports) {
       };
     }
     function verifyES256(data, signature, authenticators) {
-      const hash = sha256$1(data);
+      const hash = sha256$2(data);
       const sig = p256.Signature.fromCompact(toSignatureObject2(signature).compact);
       const fullPublicKeys = authenticators.filter(a => !a.ethereumAddress && !a.blockchainAccountId);
       const signer = fullPublicKeys.find(pk => {
@@ -7228,7 +7228,7 @@ var PolygonIdSdk = (function (exports) {
       return signer;
     }
     function verifyES256K(data, signature, authenticators) {
-      const hash = sha256$1(data);
+      const hash = sha256$2(data);
       const signatureNormalized = secp256k1$1.Signature.fromCompact(base64ToBytes(signature)).normalizeS();
       const fullPublicKeys = authenticators.filter(a => {
         return !a.ethereumAddress && !a.blockchainAccountId;
@@ -7269,7 +7269,7 @@ var PolygonIdSdk = (function (exports) {
         });
       }
 
-      const hash = sha256$1(data);
+      const hash = sha256$2(data);
 
       const checkSignatureAgainstSigner = sigObj => {
         const signature = secp256k1$1.Signature.fromCompact(sigObj.compact).addRecoveryBit(sigObj.recovery || 0);
@@ -30171,7 +30171,7 @@ var PolygonIdSdk = (function (exports) {
     /**
      *  The current version of Ethers.
      */
-    const version = "6.8.0";
+    const version = "6.13.1";
 
     /**
      *  Property helper functions.
@@ -30277,7 +30277,7 @@ var PolygonIdSdk = (function (exports) {
      *  Returns true if the %%error%% matches an error thrown by ethers
      *  that matches the error %%code%%.
      *
-     *  In TypeScript envornoments, this can be used to check that %%error%%
+     *  In TypeScript environments, this can be used to check that %%error%%
      *  matches an EthersError type, which means the expected properties will
      *  be set.
      *
@@ -30303,13 +30303,13 @@ var PolygonIdSdk = (function (exports) {
     }
     /**
      *  Returns a new Error configured to the format ethers emits errors, with
-     *  the %%message%%, [[api:ErrorCode]] %%code%% and additioanl properties
+     *  the %%message%%, [[api:ErrorCode]] %%code%% and additional properties
      *  for the corresponding EthersError.
      *
      *  Each error in ethers includes the version of ethers, a
-     *  machine-readable [[ErrorCode]], and depneding on %%code%%, additional
-     *  required properties. The error message will also include the %%meeage%%,
-     *  ethers version, %%code%% and all aditional properties, serialized.
+     *  machine-readable [[ErrorCode]], and depending on %%code%%, additional
+     *  required properties. The error message will also include the %%message%%,
+     *  ethers version, %%code%% and all additional properties, serialized.
      */
     function makeError(message, code, info) {
         let shortMessage = message;
@@ -30391,7 +30391,7 @@ var PolygonIdSdk = (function (exports) {
             count: count,
             expectedCount: expectedCount
         });
-        assert$2(count <= expectedCount, "too many arguemnts" + message, "UNEXPECTED_ARGUMENT", {
+        assert$2(count <= expectedCount, "too many arguments" + message, "UNEXPECTED_ARGUMENT", {
             count: count,
             expectedCount: expectedCount
         });
@@ -30461,7 +30461,7 @@ var PolygonIdSdk = (function (exports) {
             }
             return value;
         }
-        if (typeof (value) === "string" && value.match(/^0x([0-9a-f][0-9a-f])*$/i)) {
+        if (typeof (value) === "string" && value.match(/^0x(?:[0-9a-f][0-9a-f])*$/i)) {
             const result = new Uint8Array((value.length - 2) / 2);
             let offset = 2;
             for (let i = 0; i < result.length; i++) {
@@ -30770,7 +30770,7 @@ var PolygonIdSdk = (function (exports) {
         }
         else {
             const width = getNumber(_width, "width");
-            assert$2(width * 2 >= result.length, `value exceeds width (${width} bits)`, "NUMERIC_FAULT", {
+            assert$2(width * 2 >= result.length, `value exceeds width (${width} bytes)`, "NUMERIC_FAULT", {
                 operation: "toBeHex",
                 fault: "overflow",
                 value: _value
@@ -30839,12 +30839,20 @@ var PolygonIdSdk = (function (exports) {
      *  Encode %%value%% as a Base58-encoded string.
      */
     function encodeBase58(_value) {
-        let value = toBigInt(getBytes(_value));
+        const bytes = getBytes(_value);
+        let value = toBigInt(bytes);
         let result = "";
         while (value) {
             result = Alphabet[Number(value % BN_58)] + result;
             value /= BN_58;
         }
+        // Account for leading padding zeros
+        for (let i = 0; i < bytes.length; i++) {
+            if (bytes[i]) {
+                break;
+            }
+            result = Alphabet[0] + result;
+        }
         return result;
     }
 
@@ -31061,6 +31069,7 @@ var PolygonIdSdk = (function (exports) {
      *  If %%form%% is specified, the string is normalized.
      */
     function toUtf8Bytes(str, form) {
+        assertArgument(typeof (str) === "string", "invalid string value", "str", str);
         if (form != null) {
             assertNormalize(form);
             str = str.normalize(form);
@@ -31115,9 +31124,9 @@ var PolygonIdSdk = (function (exports) {
         return _toUtf8String(getUtf8CodePoints(bytes, onError));
     }
 
-    // @TODO: timeout is completely ignored; start a Promise.any with a reject?
     function createGetUrl(options) {
         async function getUrl(req, _signal) {
+            assert$2(_signal == null || !_signal.cancelled, "request cancelled before sending", "CANCELLED");
             const protocol = req.url.split(":")[0].toLowerCase();
             assert$2(protocol === "http" || protocol === "https", `unsupported protocol ${protocol}`, "UNSUPPORTED_OPERATION", {
                 info: { protocol },
@@ -31126,19 +31135,36 @@ var PolygonIdSdk = (function (exports) {
             assert$2(protocol === "https" || !req.credentials || req.allowInsecureAuthentication, "insecure authorized connections unsupported", "UNSUPPORTED_OPERATION", {
                 operation: "request"
             });
-            let signal = undefined;
+            let error = null;
+            const controller = new AbortController();
+            const timer = setTimeout(() => {
+                error = makeError("request timeout", "TIMEOUT");
+                controller.abort();
+            }, req.timeout);
             if (_signal) {
-                const controller = new AbortController();
-                signal = controller.signal;
-                _signal.addListener(() => { controller.abort(); });
+                _signal.addListener(() => {
+                    error = makeError("request cancelled", "CANCELLED");
+                    controller.abort();
+                });
             }
             const init = {
                 method: req.method,
                 headers: new Headers(Array.from(req)),
                 body: req.body || undefined,
-                signal
+                signal: controller.signal
             };
-            const resp = await fetch(req.url, init);
+            let resp;
+            try {
+                resp = await fetch(req.url, init);
+            }
+            catch (_error) {
+                clearTimeout(timer);
+                if (error) {
+                    throw error;
+                }
+                throw _error;
+            }
+            clearTimeout(timer);
             const headers = {};
             resp.headers.forEach((value, key) => {
                 headers[key.toLowerCase()] = value;
@@ -31156,7 +31182,7 @@ var PolygonIdSdk = (function (exports) {
 
     /**
      *  Fetching content from the web is environment-specific, so Ethers
-     *  provides an abstraction the each environment can implement to provide
+     *  provides an abstraction that each environment can implement to provide
      *  this service.
      *
      *  On [Node.js](link-node), the ``http`` and ``https`` libs are used to
@@ -31164,10 +31190,10 @@ var PolygonIdSdk = (function (exports) {
      *  and populate the [[FetchResponse]].
      *
      *  In a browser, the [DOM fetch](link-js-fetch) is used, and the resulting
-     *  ``Promise`` is waited on to retreive the payload.
+     *  ``Promise`` is waited on to retrieve the payload.
      *
      *  The [[FetchRequest]] is responsible for handling many common situations,
-     *  such as redirects, server throttling, authentcation, etc.
+     *  such as redirects, server throttling, authentication, etc.
      *
      *  It also handles common gateways, such as IPFS and data URIs.
      *
@@ -31291,7 +31317,7 @@ var PolygonIdSdk = (function (exports) {
         #throttle;
         #getUrlFunc;
         /**
-         *  The fetch URI to requrest.
+         *  The fetch URL to request.
          */
         get url() { return this.#url; }
         set url(url) {
@@ -31305,15 +31331,15 @@ var PolygonIdSdk = (function (exports) {
          *  header.
          *
          *  If %%body%% is null, the body is cleared (along with the
-         *  intrinsic ``Content-Type``) and the .
+         *  intrinsic ``Content-Type``).
          *
-         *  If %%body%% is a string, the intrincis ``Content-Type`` is set to
+         *  If %%body%% is a string, the intrinsic ``Content-Type`` is set to
          *  ``text/plain``.
          *
-         *  If %%body%% is a Uint8Array, the intrincis ``Content-Type`` is set to
+         *  If %%body%% is a Uint8Array, the intrinsic ``Content-Type`` is set to
          *  ``application/octet-stream``.
          *
-         *  If %%body%% is any other object, the intrincis ``Content-Type`` is
+         *  If %%body%% is any other object, the intrinsic ``Content-Type`` is
          *  set to ``application/json``.
          */
         get body() {
@@ -31373,7 +31399,7 @@ var PolygonIdSdk = (function (exports) {
          *  The headers that will be used when requesting the URI. All
          *  keys are lower-case.
          *
-         *  This object is a copy, so any chnages will **NOT** be reflected
+         *  This object is a copy, so any changes will **NOT** be reflected
          *  in the ``FetchRequest``.
          *
          *  To set a header entry, use the ``setHeader`` method.
@@ -31465,7 +31491,7 @@ var PolygonIdSdk = (function (exports) {
             this.#allowInsecure = !!value;
         }
         /**
-         *  The timeout (in milliseconds) to wait for a complere response.
+         *  The timeout (in milliseconds) to wait for a complete response.
          *  //(default: 5 minutes)//
          */
         get timeout() { return this.#timeout; }
@@ -31672,7 +31698,7 @@ var PolygonIdSdk = (function (exports) {
          *  to %%location%%.
          */
         redirect(location) {
-            // Redirection; for now we only support absolute locataions
+            // Redirection; for now we only support absolute locations
             const current = this.url.split(":")[0].toLowerCase();
             const target = location.split(":")[0].toLowerCase();
             // Don't allow redirecting:
@@ -31724,6 +31750,7 @@ var PolygonIdSdk = (function (exports) {
             clone.#preflight = this.#preflight;
             clone.#process = this.#process;
             clone.#retry = this.#retry;
+            clone.#throttle = Object.assign({}, this.#throttle);
             clone.#getUrlFunc = this.#getUrlFunc;
             return clone;
         }
@@ -31810,7 +31837,7 @@ var PolygonIdSdk = (function (exports) {
         }
     }
     /**
-     *  The response for a FetchREquest.
+     *  The response for a FetchRequest.
      */
     class FetchResponse {
         #statusCode;
@@ -31940,7 +31967,7 @@ var PolygonIdSdk = (function (exports) {
             return this.headers[key.toLowerCase()];
         }
         /**
-         *  Returns true of the response has a body.
+         *  Returns true if the response has a body.
          */
         hasBody() {
             return (this.#body != null);
@@ -31966,8 +31993,23 @@ var PolygonIdSdk = (function (exports) {
             if (message === "") {
                 message = `server response ${this.statusCode} ${this.statusMessage}`;
             }
+            let requestUrl = null;
+            if (this.request) {
+                requestUrl = this.request.url;
+            }
+            let responseBody = null;
+            try {
+                if (this.#body) {
+                    responseBody = toUtf8String(this.#body);
+                }
+            }
+            catch (e) { }
             assert$2(false, message, "SERVER_ERROR", {
-                request: (this.request || "unknown request"), response: this, error
+                request: (this.request || "unknown request"), response: this, error,
+                info: {
+                    requestUrl, responseBody,
+                    responseStatus: `${this.statusCode} ${this.statusMessage}`
+                }
             });
         }
     }
@@ -32114,11 +32156,38 @@ var PolygonIdSdk = (function (exports) {
     // - `then` is used to detect if an object is a Promise for await
     const passProperties$1 = ["then"];
     const _guard$2 = {};
+    const resultNames = new WeakMap();
+    function getNames(result) {
+        return resultNames.get(result);
+    }
+    function setNames(result, names) {
+        resultNames.set(result, names);
+    }
     function throwError(name, error) {
         const wrapped = new Error(`deferred error during ABI decoding triggered accessing ${name}`);
         wrapped.error = error;
         throw wrapped;
     }
+    function toObject(names, items, deep) {
+        if (names.indexOf(null) >= 0) {
+            return items.map((item, index) => {
+                if (item instanceof Result) {
+                    return toObject(getNames(item), item, deep);
+                }
+                return item;
+            });
+        }
+        return names.reduce((accum, name, index) => {
+            let item = items.getValue(name);
+            if (!(name in accum)) {
+                if (deep && item instanceof Result) {
+                    item = toObject(getNames(item), item, deep);
+                }
+                accum[name] = item;
+            }
+            return accum;
+        }, {});
+    }
     /**
      *  A [[Result]] is a sub-class of Array, which allows accessing any
      *  of its values either positionally by its index or, if keys are
@@ -32127,6 +32196,9 @@ var PolygonIdSdk = (function (exports) {
      *  @_docloc: api/abi
      */
     class Result extends Array {
+        // No longer used; but cannot be removed as it will remove the
+        // #private field from the .d.ts which may break backwards
+        // compatibility
         #names;
         /**
          *  @private
@@ -32159,20 +32231,22 @@ var PolygonIdSdk = (function (exports) {
                 return accum;
             }, (new Map()));
             // Remove any key thats not unique
-            this.#names = Object.freeze(items.map((item, index) => {
+            setNames(this, Object.freeze(items.map((item, index) => {
                 const name = names[index];
                 if (name != null && nameCounts.get(name) === 1) {
                     return name;
                 }
                 return null;
-            }));
+            })));
+            // Dummy operations to prevent TypeScript from complaining
+            this.#names = [];
             if (!wrap) {
                 return;
             }
             // A wrapped Result is immutable
             Object.freeze(this);
             // Proxy indices and names so we can trap deferred errors
-            return new Proxy(this, {
+            const proxy = new Proxy(this, {
                 get: (target, prop, receiver) => {
                     if (typeof (prop) === "string") {
                         // Index accessor
@@ -32207,39 +32281,44 @@ var PolygonIdSdk = (function (exports) {
                     return Reflect.get(target, prop, receiver);
                 }
             });
+            setNames(proxy, getNames(this));
+            return proxy;
         }
         /**
-         *  Returns the Result as a normal Array.
+         *  Returns the Result as a normal Array. If %%deep%%, any children
+         *  which are Result objects are also converted to a normal Array.
          *
          *  This will throw if there are any outstanding deferred
          *  errors.
          */
-        toArray() {
+        toArray(deep) {
             const result = [];
             this.forEach((item, index) => {
                 if (item instanceof Error) {
                     throwError(`index ${index}`, item);
                 }
+                if (deep && item instanceof Result) {
+                    item = item.toArray(deep);
+                }
                 result.push(item);
             });
             return result;
         }
         /**
-         *  Returns the Result as an Object with each name-value pair.
+         *  Returns the Result as an Object with each name-value pair. If
+         *  %%deep%%, any children which are Result objects are also
+         *  converted to an Object.
          *
          *  This will throw if any value is unnamed, or if there are
          *  any outstanding deferred errors.
          */
-        toObject() {
-            return this.#names.reduce((accum, name, index) => {
-                assert$2(name != null, "value at index ${ index } unnamed", "UNSUPPORTED_OPERATION", {
+        toObject(deep) {
+            const names = getNames(this);
+            return names.reduce((accum, name, index) => {
+                assert$2(name != null, `value at index ${index} unnamed`, "UNSUPPORTED_OPERATION", {
                     operation: "toObject()"
                 });
-                // Add values for names that don't conflict
-                if (!(name in accum)) {
-                    accum[name] = this.getValue(name);
-                }
-                return accum;
+                return toObject(names, this, deep);
             }, {});
         }
         /**
@@ -32267,10 +32346,11 @@ var PolygonIdSdk = (function (exports) {
             if (end > this.length) {
                 end = this.length;
             }
+            const _names = getNames(this);
             const result = [], names = [];
             for (let i = start; i < end; i++) {
                 result.push(this[i]);
-                names.push(this.#names[i]);
+                names.push(_names[i]);
             }
             return new Result(_guard$2, result, names);
         }
@@ -32278,6 +32358,7 @@ var PolygonIdSdk = (function (exports) {
          *  @_ignore
          */
         filter(callback, thisArg) {
+            const _names = getNames(this);
             const result = [], names = [];
             for (let i = 0; i < this.length; i++) {
                 const item = this[i];
@@ -32286,7 +32367,7 @@ var PolygonIdSdk = (function (exports) {
                 }
                 if (callback.call(thisArg, item, i, this)) {
                     result.push(item);
-                    names.push(this.#names[i]);
+                    names.push(_names[i]);
                 }
             }
             return new Result(_guard$2, result, names);
@@ -32314,7 +32395,7 @@ var PolygonIdSdk = (function (exports) {
          *  accessible by name.
          */
         getValue(name) {
-            const index = this.#names.indexOf(name);
+            const index = getNames(this).indexOf(name);
             if (index === -1) {
                 return undefined;
             }
@@ -32424,15 +32505,35 @@ var PolygonIdSdk = (function (exports) {
         allowLoose;
         #data;
         #offset;
-        constructor(data, allowLoose) {
+        #bytesRead;
+        #parent;
+        #maxInflation;
+        constructor(data, allowLoose, maxInflation) {
             defineProperties(this, { allowLoose: !!allowLoose });
             this.#data = getBytesCopy(data);
+            this.#bytesRead = 0;
+            this.#parent = null;
+            this.#maxInflation = (maxInflation != null) ? maxInflation : 1024;
             this.#offset = 0;
         }
         get data() { return hexlify(this.#data); }
         get dataLength() { return this.#data.length; }
         get consumed() { return this.#offset; }
         get bytes() { return new Uint8Array(this.#data); }
+        #incrementBytesRead(count) {
+            if (this.#parent) {
+                return this.#parent.#incrementBytesRead(count);
+            }
+            this.#bytesRead += count;
+            // Check for excessive inflation (see: #4537)
+            assert$2(this.#maxInflation < 1 || this.#bytesRead <= this.#maxInflation * this.dataLength, `compressed ABI data exceeds inflation ratio of ${this.#maxInflation} ( see: https:/\/github.com/ethers-io/ethers.js/issues/4537 )`, "BUFFER_OVERRUN", {
+                buffer: getBytesCopy(this.#data), offset: this.#offset,
+                length: count, info: {
+                    bytesRead: this.#bytesRead,
+                    dataLength: this.dataLength
+                }
+            });
+        }
         #peekBytes(offset, length, loose) {
             let alignedLength = Math.ceil(length / WordSize) * WordSize;
             if (this.#offset + alignedLength > this.#data.length) {
@@ -32451,11 +32552,14 @@ var PolygonIdSdk = (function (exports) {
         }
         // Create a sub-reader with the same underlying data, but offset
         subReader(offset) {
-            return new Reader(this.#data.slice(this.#offset + offset), this.allowLoose);
+            const reader = new Reader(this.#data.slice(this.#offset + offset), this.allowLoose, this.#maxInflation);
+            reader.#parent = this;
+            return reader;
         }
         // Read bytes
         readBytes(length, loose) {
             let bytes = this.#peekBytes(0, length, !!loose);
+            this.#incrementBytesRead(length);
             this.#offset += bytes.length;
             // @TODO: Make sure the length..end bytes are all 0?
             return bytes.slice(0, length);
@@ -32871,7 +32975,7 @@ var PolygonIdSdk = (function (exports) {
      * SHA2-256 hash function
      * @param message - data that would be hashed
      */
-    const sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
+    const sha256$1 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
 
     const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
     const _32n = /* @__PURE__ */ BigInt(32);
@@ -32890,12 +32994,225 @@ var PolygonIdSdk = (function (exports) {
         }
         return [Ah, Al];
     }
+    const toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);
+    // for Shift in [0, 32)
+    const shrSH = (h, _l, s) => h >>> s;
+    const shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+    // Right rotate for Shift in [1, 32)
+    const rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));
+    const rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+    // Right rotate for Shift in (32, 64), NOTE: 32 is special case.
+    const rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));
+    const rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));
+    // Right rotate for shift===32 (just swaps l&h)
+    const rotr32H = (_h, l) => l;
+    const rotr32L = (h, _l) => h;
     // Left rotate for Shift in [1, 32)
     const rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));
     const rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));
     // Left rotate for Shift in (32, 64), NOTE: 32 is special case.
     const rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));
     const rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));
+    // JS uses 32-bit signed integers for bitwise operations which means we cannot
+    // simple take carry out of low bit sum by shift, we need to use division.
+    function add$1(Ah, Al, Bh, Bl) {
+        const l = (Al >>> 0) + (Bl >>> 0);
+        return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };
+    }
+    // Addition with more than 2 elements
+    const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+    const add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;
+    const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+    const add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;
+    const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+    const add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;
+    // prettier-ignore
+    const u64 = {
+        fromBig, split: split$1, toBig,
+        shrSH, shrSL,
+        rotrSH, rotrSL, rotrBH, rotrBL,
+        rotr32H, rotr32L,
+        rotlSH, rotlSL, rotlBH, rotlBL,
+        add: add$1, add3L, add3H, add4L, add4H, add5H, add5L,
+    };
+
+    // Round contants (first 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409):
+    // prettier-ignore
+    const [SHA512_Kh, SHA512_Kl] = /* @__PURE__ */ (() => u64.split([
+        '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',
+        '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',
+        '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',
+        '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',
+        '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',
+        '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',
+        '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',
+        '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',
+        '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',
+        '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',
+        '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',
+        '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',
+        '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',
+        '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',
+        '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',
+        '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',
+        '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',
+        '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',
+        '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',
+        '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'
+    ].map(n => BigInt(n))))();
+    // Temporary buffer, not used to store anything between runs
+    const SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
+    const SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
+    class SHA512 extends SHA2 {
+        constructor() {
+            super(128, 64, 16, false);
+            // We cannot use array here since array allows indexing by variable which means optimizer/compiler cannot use registers.
+            // Also looks cleaner and easier to verify with spec.
+            // Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
+            // h -- high 32 bits, l -- low 32 bits
+            this.Ah = 0x6a09e667 | 0;
+            this.Al = 0xf3bcc908 | 0;
+            this.Bh = 0xbb67ae85 | 0;
+            this.Bl = 0x84caa73b | 0;
+            this.Ch = 0x3c6ef372 | 0;
+            this.Cl = 0xfe94f82b | 0;
+            this.Dh = 0xa54ff53a | 0;
+            this.Dl = 0x5f1d36f1 | 0;
+            this.Eh = 0x510e527f | 0;
+            this.El = 0xade682d1 | 0;
+            this.Fh = 0x9b05688c | 0;
+            this.Fl = 0x2b3e6c1f | 0;
+            this.Gh = 0x1f83d9ab | 0;
+            this.Gl = 0xfb41bd6b | 0;
+            this.Hh = 0x5be0cd19 | 0;
+            this.Hl = 0x137e2179 | 0;
+        }
+        // prettier-ignore
+        get() {
+            const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+            return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];
+        }
+        // prettier-ignore
+        set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
+            this.Ah = Ah | 0;
+            this.Al = Al | 0;
+            this.Bh = Bh | 0;
+            this.Bl = Bl | 0;
+            this.Ch = Ch | 0;
+            this.Cl = Cl | 0;
+            this.Dh = Dh | 0;
+            this.Dl = Dl | 0;
+            this.Eh = Eh | 0;
+            this.El = El | 0;
+            this.Fh = Fh | 0;
+            this.Fl = Fl | 0;
+            this.Gh = Gh | 0;
+            this.Gl = Gl | 0;
+            this.Hh = Hh | 0;
+            this.Hl = Hl | 0;
+        }
+        process(view, offset) {
+            // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array
+            for (let i = 0; i < 16; i++, offset += 4) {
+                SHA512_W_H[i] = view.getUint32(offset);
+                SHA512_W_L[i] = view.getUint32((offset += 4));
+            }
+            for (let i = 16; i < 80; i++) {
+                // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)
+                const W15h = SHA512_W_H[i - 15] | 0;
+                const W15l = SHA512_W_L[i - 15] | 0;
+                const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);
+                const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);
+                // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)
+                const W2h = SHA512_W_H[i - 2] | 0;
+                const W2l = SHA512_W_L[i - 2] | 0;
+                const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);
+                const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);
+                // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];
+                const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+                const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
+                SHA512_W_H[i] = SUMh | 0;
+                SHA512_W_L[i] = SUMl | 0;
+            }
+            let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+            // Compression function main loop, 80 rounds
+            for (let i = 0; i < 80; i++) {
+                // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)
+                const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);
+                const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);
+                //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
+                const CHIh = (Eh & Fh) ^ (~Eh & Gh);
+                const CHIl = (El & Fl) ^ (~El & Gl);
+                // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]
+                // prettier-ignore
+                const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+                const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+                const T1l = T1ll | 0;
+                // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)
+                const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);
+                const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);
+                const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);
+                const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);
+                Hh = Gh | 0;
+                Hl = Gl | 0;
+                Gh = Fh | 0;
+                Gl = Fl | 0;
+                Fh = Eh | 0;
+                Fl = El | 0;
+                ({ h: Eh, l: El } = u64.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+                Dh = Ch | 0;
+                Dl = Cl | 0;
+                Ch = Bh | 0;
+                Cl = Bl | 0;
+                Bh = Ah | 0;
+                Bl = Al | 0;
+                const All = u64.add3L(T1l, sigma0l, MAJl);
+                Ah = u64.add3H(All, T1h, sigma0h, MAJh);
+                Al = All | 0;
+            }
+            // Add the compressed chunk to the current hash value
+            ({ h: Ah, l: Al } = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+            ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+            ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+            ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+            ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+            ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+            ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+            ({ h: Hh, l: Hl } = u64.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+            this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
+        }
+        roundClean() {
+            SHA512_W_H.fill(0);
+            SHA512_W_L.fill(0);
+        }
+        destroy() {
+            this.buffer.fill(0);
+            this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+        }
+    }
+    const sha512 = /* @__PURE__ */ wrapConstructor(() => new SHA512());
+
+    /* Browser Crypto Shims */
+    function getGlobal() {
+        if (typeof self !== 'undefined') {
+            return self;
+        }
+        if (typeof window !== 'undefined') {
+            return window;
+        }
+        if (typeof global !== 'undefined') {
+            return global;
+        }
+        throw new Error('unable to locate global object');
+    }
+    getGlobal();
+    function createHash(algo) {
+        switch (algo) {
+            case "sha256": return sha256$1.create();
+            case "sha512": return sha512.create();
+        }
+        assertArgument(false, "invalid hashing algorithm name", "algorithm", algo);
+    }
 
     // SHA3 (keccak) is based on a new design: basically, the internal state is bigger than output size.
     // It's called a sponge function.
@@ -33134,6 +33451,43 @@ var PolygonIdSdk = (function (exports) {
     };
     Object.freeze(keccak256);
 
+    const _sha256 = function (data) {
+        return createHash("sha256").update(data).digest();
+    };
+    let __sha256 = _sha256;
+    let locked256 = false;
+    /**
+     *  Compute the cryptographic SHA2-256 hash of %%data%%.
+     *
+     *  @_docloc: api/crypto:Hash Functions
+     *  @returns DataHexstring
+     *
+     *  @example:
+     *    sha256("0x")
+     *    //_result:
+     *
+     *    sha256("0x1337")
+     *    //_result:
+     *
+     *    sha256(new Uint8Array([ 0x13, 0x37 ]))
+     *    //_result:
+     *
+     */
+    function sha256(_data) {
+        const data = getBytes(_data, "data");
+        return hexlify(__sha256(data));
+    }
+    sha256._ = _sha256;
+    sha256.lock = function () { locked256 = true; };
+    sha256.register = function (func) {
+        if (locked256) {
+            throw new Error("sha256 is locked");
+        }
+        __sha256 = func;
+    };
+    Object.freeze(sha256);
+    Object.freeze(sha256);
+
     /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
     // 100 lines of code in the file are duplicated from noble-hashes (utils).
     // This is OK: `abstract` directory does not use noble-hashes.
@@ -34949,7 +35303,7 @@ var PolygonIdSdk = (function (exports) {
                 return { k1neg, k1, k2neg, k2 };
             },
         },
-    }, sha256);
+    }, sha256$1);
     // Schnorr signatures are superior to ECDSA from above. Below is Schnorr-specific BIP0340 code.
     // https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki
     BigInt(0);
@@ -36703,7 +37057,7 @@ var PolygonIdSdk = (function (exports) {
         return keccak256(toUtf8Bytes(value));
     }
 
-    // created 2023-09-12T22:05:14.211Z
+    // created 2023-09-25T01:01:55.148Z
     // compressed base64-encoded blob for include-ens data
     // source: https://github.com/adraffy/ens-normalize.js/blob/main/src/make.js
     // see: https://github.com/adraffy/ens-normalize.js#security
@@ -36984,7 +37338,7 @@ var PolygonIdSdk = (function (exports) {
     	return c;
     }
 
-    // created 2023-09-12T22:05:14.211Z
+    // created 2023-09-25T01:01:55.148Z
     // compressed base64-encoded blob for include-nf data
     // source: https://github.com/adraffy/ens-normalize.js/blob/main/src/make.js
     // see: https://github.com/adraffy/ens-normalize.js#security
@@ -37200,6 +37554,7 @@ var PolygonIdSdk = (function (exports) {
     	let r = read_compressed_payload(COMPRESSED$1);
     	const read_sorted_array = () => read_sorted(r);
     	const read_sorted_set = () => new Set(read_sorted_array());
+    	const set_add_many = (set, v) => v.forEach(x => set.add(x));
 
     	MAPPED = new Map(read_mapped(r)); 
     	IGNORED = read_sorted_set(); // ignored characters are not valid, so just read raw codepoints
@@ -37222,13 +37577,20 @@ var PolygonIdSdk = (function (exports) {
 
     	let chunks = read_sorted_arrays(r);
     	let unrestricted = r();
-    	const read_chunked = () => new Set(read_sorted_array().flatMap(i => chunks[i]).concat(read_sorted_array()));
+    	//const read_chunked = () => new Set(read_sorted_array().flatMap(i => chunks[i]).concat(read_sorted_array()));
+    	const read_chunked = () => {
+    		// 20230921: build set in parts, 2x faster
+    		let set = new Set();
+    		read_sorted_array().forEach(i => set_add_many(set, chunks[i]));
+    		set_add_many(set, read_sorted_array());
+    		return set; 
+    	};
     	GROUPS = read_array_while(i => {
     		// minifier property mangling seems unsafe
     		// so these are manually renamed to single chars
     		let N = read_array_while(r).map(x => x+0x60);
     		if (N.length) {
-    			let R = i >= unrestricted; // first arent restricted
+    			let R = i >= unrestricted; // unrestricted then restricted
     			N[0] -= 32; // capitalize
     			N = str_from_cps(N);
     			if (R) N=`Restricted[${N}]`;
@@ -37266,6 +37628,7 @@ var PolygonIdSdk = (function (exports) {
     	});
 
     	// compute confusable-extent complements
+    	// usage: WHOLE_MAP.get(cp).M.get(cp) = complement set
     	for (let {V, M} of new Set(WHOLE_MAP.values())) {
     		// connect all groups that have each whole character
     		let recs = [];
@@ -37277,34 +37640,37 @@ var PolygonIdSdk = (function (exports) {
     				recs.push(rec);
     			}
     			rec.V.push(cp);
-    			gs.forEach(g => rec.G.add(g));
+    			set_add_many(rec.G, gs);
     		}
     		// per character cache groups which are not a member of the extent
-    		let union = recs.flatMap(x => Array_from(x.G));
+    		let union = recs.flatMap(x => Array_from(x.G)); // all of the groups used by this whole
     		for (let {G, V} of recs) {
-    			let complement = new Set(union.filter(g => !G.has(g)));
+    			let complement = new Set(union.filter(g => !G.has(g))); // groups not covered by the extent
     			for (let cp of V) {
-    				M.set(cp, complement);
+    				M.set(cp, complement); // this is the same reference
     			}
     		}
     	}
 
     	// compute valid set
-    	let union = new Set(); // exists in 1+ groups
+    	// 20230924: VALID was union but can be re-used
+    	VALID = new Set(); // exists in 1+ groups
     	let multi = new Set(); // exists in 2+ groups
-    	const add_to_union = cp => union.has(cp) ? multi.add(cp) : union.add(cp);
+    	const add_to_union = cp => VALID.has(cp) ? multi.add(cp) : VALID.add(cp);
     	for (let g of GROUPS) {
     		for (let cp of g.P) add_to_union(cp);
     		for (let cp of g.Q) add_to_union(cp);
     	}
     	// dual purpose WHOLE_MAP: return placeholder if unique non-confusable
-    	for (let cp of union) {
+    	for (let cp of VALID) {
     		if (!WHOLE_MAP.has(cp) && !multi.has(cp)) {
     			WHOLE_MAP.set(cp, UNIQUE_PH);
     		}
     	}
-    	VALID = new Set(Array_from(union).concat(Array_from(nfd(union)))); // possibly valid
-
+    	// add all decomposed parts
+    	// see derive: "Valid is Closed (via Brute-force)"
+    	set_add_many(VALID, nfd(VALID));
+    	
     	// decode emoji
     	// 20230719: emoji are now fully-expanded to avoid quirk logic 
     	EMOJI_LIST = read_trie(r).map(v => Emoji.from(v)).sort(compare_arrays);
@@ -37357,7 +37723,7 @@ var PolygonIdSdk = (function (exports) {
 
     function check_label_extension(cps) {
     	if (cps.length >= 4 && cps[2] == HYPHEN && cps[3] == HYPHEN) {
-    		throw new Error(`invalid label extension: "${str_from_cps(cps.slice(0, 4))}"`);
+    		throw new Error(`invalid label extension: "${str_from_cps(cps.slice(0, 4))}"`); // this can only be ascii so cant be bidi
     	}
     }
     function check_leading_underscore(cps) {
@@ -37391,13 +37757,18 @@ var PolygonIdSdk = (function (exports) {
     // create a safe to print string 
     // invisibles are escaped
     // leading cm uses placeholder
+    // if cps exceed max, middle truncate with ellipsis
     // quoter(cp) => string, eg. 3000 => "{3000}"
     // note: in html, you'd call this function then replace [<>&] with entities
-    function safe_str_from_cps(cps, quoter = quote_cp) {
+    function safe_str_from_cps(cps, max = Infinity, quoter = quote_cp) {
     	//if (Number.isInteger(cps)) cps = [cps];
     	//if (!Array.isArray(cps)) throw new TypeError(`expected codepoints`);
     	let buf = [];
     	if (is_combining_mark(cps[0])) buf.push('◌');
+    	if (cps.length > max) {
+    		max >>= 1;
+    		cps = [...cps.slice(0, max), 0x2026, ...cps.slice(-max)];
+    	}
     	let prev = 0;
     	let n = cps.length;
     	for (let i = 0; i < n; i++) {
@@ -37562,7 +37933,7 @@ var PolygonIdSdk = (function (exports) {
     			// don't print label again if just a single label
     			let msg = error.message;
     			// bidi_qq() only necessary if msg is digits
-    			throw new Error(split.length == 1 ? msg : `Invalid label ${bidi_qq(safe_str_from_cps(input))}: ${msg}`); 
+    			throw new Error(split.length == 1 ? msg : `Invalid label ${bidi_qq(safe_str_from_cps(input, 63))}: ${msg}`); 
     		}
     		return str_from_cps(output);
     	}).join(STOP_CH);
@@ -37816,12 +38187,11 @@ var PolygonIdSdk = (function (exports) {
      *  This is used for various parts of ENS name resolution, such
      *  as the wildcard resolution.
      */
-    function dnsEncode(name) {
+    function dnsEncode(name, _maxLength) {
+        const length = (_maxLength != null) ? _maxLength : 63;
+        assertArgument(length <= 255, "DNS encoded label cannot exceed 255", "length", length);
         return hexlify(concat(ensNameSplit(name).map((comp) => {
-            // DNS does not allow components over 63 bytes in length
-            if (comp.length > 63) {
-                throw new Error("invalid DNS encoded entry; length exceeds 63 bytes");
-            }
+            assertArgument(comp.length <= length, `label ${JSON.stringify(name)} exceeds ${length} bytes`, "name", name);
             const bytes = new Uint8Array(comp.length + 1);
             bytes.set(comp, 1);
             bytes[0] = bytes.length - 1;
@@ -37893,6 +38263,15 @@ var PolygonIdSdk = (function (exports) {
     const BN_28 = BigInt(28);
     const BN_35 = BigInt(35);
     const BN_MAX_UINT = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+    const BLOB_SIZE = 4096 * 32;
+    function getVersionedHash(version, hash) {
+        let versioned = version.toString(16);
+        while (versioned.length < 2) {
+            versioned = "0" + versioned;
+        }
+        versioned += sha256(hash).substring(4);
+        return "0x" + versioned;
+    }
     function handleAddress(value) {
         if (value === "0x") {
             return null;
@@ -37930,6 +38309,13 @@ var PolygonIdSdk = (function (exports) {
     function formatAccessList(value) {
         return accessListify(value).map((set) => [set.address, set.storageKeys]);
     }
+    function formatHashes(value, param) {
+        assertArgument(Array.isArray(value), `invalid ${param}`, "value", value);
+        for (let i = 0; i < value.length; i++) {
+            assertArgument(isHexString(value[i], 32), "invalid ${ param } hash", `value[${i}]`, value[i]);
+        }
+        return value;
+    }
     function _parseLegacy(data) {
         const fields = decodeRlp(data);
         assertArgument(Array.isArray(fields) && (fields.length === 9 || fields.length === 6), "invalid field count for legacy transaction", "data", data);
@@ -37968,18 +38354,18 @@ var PolygonIdSdk = (function (exports) {
                 s: zeroPadValue(fields[8], 32),
                 v
             });
-            tx.hash = keccak256(data);
+            //tx.hash = keccak256(data);
         }
         return tx;
     }
     function _serializeLegacy(tx, sig) {
         const fields = [
-            formatNumber(tx.nonce || 0, "nonce"),
+            formatNumber(tx.nonce, "nonce"),
             formatNumber(tx.gasPrice || 0, "gasPrice"),
-            formatNumber(tx.gasLimit || 0, "gasLimit"),
-            ((tx.to != null) ? getAddress(tx.to) : "0x"),
-            formatNumber(tx.value || 0, "value"),
-            (tx.data || "0x"),
+            formatNumber(tx.gasLimit, "gasLimit"),
+            (tx.to || "0x"),
+            formatNumber(tx.value, "value"),
+            tx.data,
         ];
         let chainId = BN_0$4;
         if (tx.chainId != BN_0$4) {
@@ -38042,14 +38428,12 @@ var PolygonIdSdk = (function (exports) {
     function _parseEip1559(data) {
         const fields = decodeRlp(getBytes(data).slice(1));
         assertArgument(Array.isArray(fields) && (fields.length === 9 || fields.length === 12), "invalid field count for transaction type: 2", "data", hexlify(data));
-        const maxPriorityFeePerGas = handleUint(fields[2], "maxPriorityFeePerGas");
-        const maxFeePerGas = handleUint(fields[3], "maxFeePerGas");
         const tx = {
             type: 2,
             chainId: handleUint(fields[0], "chainId"),
             nonce: handleNumber(fields[1], "nonce"),
-            maxPriorityFeePerGas: maxPriorityFeePerGas,
-            maxFeePerGas: maxFeePerGas,
+            maxPriorityFeePerGas: handleUint(fields[2], "maxPriorityFeePerGas"),
+            maxFeePerGas: handleUint(fields[3], "maxFeePerGas"),
             gasPrice: null,
             gasLimit: handleUint(fields[4], "gasLimit"),
             to: handleAddress(fields[5]),
@@ -38061,21 +38445,21 @@ var PolygonIdSdk = (function (exports) {
         if (fields.length === 9) {
             return tx;
         }
-        tx.hash = keccak256(data);
+        //tx.hash = keccak256(data);
         _parseEipSignature(tx, fields.slice(9));
         return tx;
     }
     function _serializeEip1559(tx, sig) {
         const fields = [
-            formatNumber(tx.chainId || 0, "chainId"),
-            formatNumber(tx.nonce || 0, "nonce"),
+            formatNumber(tx.chainId, "chainId"),
+            formatNumber(tx.nonce, "nonce"),
             formatNumber(tx.maxPriorityFeePerGas || 0, "maxPriorityFeePerGas"),
             formatNumber(tx.maxFeePerGas || 0, "maxFeePerGas"),
-            formatNumber(tx.gasLimit || 0, "gasLimit"),
-            ((tx.to != null) ? getAddress(tx.to) : "0x"),
-            formatNumber(tx.value || 0, "value"),
-            (tx.data || "0x"),
-            (formatAccessList(tx.accessList || []))
+            formatNumber(tx.gasLimit, "gasLimit"),
+            (tx.to || "0x"),
+            formatNumber(tx.value, "value"),
+            tx.data,
+            formatAccessList(tx.accessList || [])
         ];
         if (sig) {
             fields.push(formatNumber(sig.yParity, "yParity"));
@@ -38102,20 +38486,20 @@ var PolygonIdSdk = (function (exports) {
         if (fields.length === 8) {
             return tx;
         }
-        tx.hash = keccak256(data);
+        //tx.hash = keccak256(data);
         _parseEipSignature(tx, fields.slice(8));
         return tx;
     }
     function _serializeEip2930(tx, sig) {
         const fields = [
-            formatNumber(tx.chainId || 0, "chainId"),
-            formatNumber(tx.nonce || 0, "nonce"),
+            formatNumber(tx.chainId, "chainId"),
+            formatNumber(tx.nonce, "nonce"),
             formatNumber(tx.gasPrice || 0, "gasPrice"),
-            formatNumber(tx.gasLimit || 0, "gasLimit"),
-            ((tx.to != null) ? getAddress(tx.to) : "0x"),
-            formatNumber(tx.value || 0, "value"),
-            (tx.data || "0x"),
-            (formatAccessList(tx.accessList || []))
+            formatNumber(tx.gasLimit, "gasLimit"),
+            (tx.to || "0x"),
+            formatNumber(tx.value, "value"),
+            tx.data,
+            formatAccessList(tx.accessList || [])
         ];
         if (sig) {
             fields.push(formatNumber(sig.yParity, "recoveryParam"));
@@ -38124,6 +38508,96 @@ var PolygonIdSdk = (function (exports) {
         }
         return concat(["0x01", encodeRlp(fields)]);
     }
+    function _parseEip4844(data) {
+        let fields = decodeRlp(getBytes(data).slice(1));
+        let typeName = "3";
+        let blobs = null;
+        // Parse the network format
+        if (fields.length === 4 && Array.isArray(fields[0])) {
+            typeName = "3 (network format)";
+            const fBlobs = fields[1], fCommits = fields[2], fProofs = fields[3];
+            assertArgument(Array.isArray(fBlobs), "invalid network format: blobs not an array", "fields[1]", fBlobs);
+            assertArgument(Array.isArray(fCommits), "invalid network format: commitments not an array", "fields[2]", fCommits);
+            assertArgument(Array.isArray(fProofs), "invalid network format: proofs not an array", "fields[3]", fProofs);
+            assertArgument(fBlobs.length === fCommits.length, "invalid network format: blobs/commitments length mismatch", "fields", fields);
+            assertArgument(fBlobs.length === fProofs.length, "invalid network format: blobs/proofs length mismatch", "fields", fields);
+            blobs = [];
+            for (let i = 0; i < fields[1].length; i++) {
+                blobs.push({
+                    data: fBlobs[i],
+                    commitment: fCommits[i],
+                    proof: fProofs[i],
+                });
+            }
+            fields = fields[0];
+        }
+        assertArgument(Array.isArray(fields) && (fields.length === 11 || fields.length === 14), `invalid field count for transaction type: ${typeName}`, "data", hexlify(data));
+        const tx = {
+            type: 3,
+            chainId: handleUint(fields[0], "chainId"),
+            nonce: handleNumber(fields[1], "nonce"),
+            maxPriorityFeePerGas: handleUint(fields[2], "maxPriorityFeePerGas"),
+            maxFeePerGas: handleUint(fields[3], "maxFeePerGas"),
+            gasPrice: null,
+            gasLimit: handleUint(fields[4], "gasLimit"),
+            to: handleAddress(fields[5]),
+            value: handleUint(fields[6], "value"),
+            data: hexlify(fields[7]),
+            accessList: handleAccessList(fields[8], "accessList"),
+            maxFeePerBlobGas: handleUint(fields[9], "maxFeePerBlobGas"),
+            blobVersionedHashes: fields[10]
+        };
+        if (blobs) {
+            tx.blobs = blobs;
+        }
+        assertArgument(tx.to != null, `invalid address for transaction type: ${typeName}`, "data", data);
+        assertArgument(Array.isArray(tx.blobVersionedHashes), "invalid blobVersionedHashes: must be an array", "data", data);
+        for (let i = 0; i < tx.blobVersionedHashes.length; i++) {
+            assertArgument(isHexString(tx.blobVersionedHashes[i], 32), `invalid blobVersionedHash at index ${i}: must be length 32`, "data", data);
+        }
+        // Unsigned EIP-4844 Transaction
+        if (fields.length === 11) {
+            return tx;
+        }
+        // @TODO: Do we need to do this? This is only called internally
+        // and used to verify hashes; it might save time to not do this
+        //tx.hash = keccak256(concat([ "0x03", encodeRlp(fields) ]));
+        _parseEipSignature(tx, fields.slice(11));
+        return tx;
+    }
+    function _serializeEip4844(tx, sig, blobs) {
+        const fields = [
+            formatNumber(tx.chainId, "chainId"),
+            formatNumber(tx.nonce, "nonce"),
+            formatNumber(tx.maxPriorityFeePerGas || 0, "maxPriorityFeePerGas"),
+            formatNumber(tx.maxFeePerGas || 0, "maxFeePerGas"),
+            formatNumber(tx.gasLimit, "gasLimit"),
+            (tx.to || ZeroAddress),
+            formatNumber(tx.value, "value"),
+            tx.data,
+            formatAccessList(tx.accessList || []),
+            formatNumber(tx.maxFeePerBlobGas || 0, "maxFeePerBlobGas"),
+            formatHashes(tx.blobVersionedHashes || [], "blobVersionedHashes")
+        ];
+        if (sig) {
+            fields.push(formatNumber(sig.yParity, "yParity"));
+            fields.push(toBeArray(sig.r));
+            fields.push(toBeArray(sig.s));
+            // We have blobs; return the network wrapped format
+            if (blobs) {
+                return concat([
+                    "0x03",
+                    encodeRlp([
+                        fields,
+                        blobs.map((b) => b.data),
+                        blobs.map((b) => b.commitment),
+                        blobs.map((b) => b.proof),
+                    ])
+                ]);
+            }
+        }
+        return concat(["0x03", encodeRlp(fields)]);
+    }
     /**
      *  A **Transaction** describes an operation to be executed on
      *  Ethereum by an Externally Owned Account (EOA). It includes
@@ -38150,6 +38624,10 @@ var PolygonIdSdk = (function (exports) {
         #chainId;
         #sig;
         #accessList;
+        #maxFeePerBlobGas;
+        #blobVersionedHashes;
+        #kzg;
+        #blobs;
         /**
          *  The transaction type.
          *
@@ -38176,6 +38654,11 @@ var PolygonIdSdk = (function (exports) {
                 case "eip-1559":
                     this.#type = 2;
                     break;
+                case 3:
+                case "cancun":
+                case "eip-4844":
+                    this.#type = 3;
+                    break;
                 default:
                     assertArgument(false, "unsupported transaction type", "type", value);
             }
@@ -38188,6 +38671,7 @@ var PolygonIdSdk = (function (exports) {
                 case 0: return "legacy";
                 case 1: return "eip-2930";
                 case 2: return "eip-1559";
+                case 3: return "eip-4844";
             }
             return null;
         }
@@ -38195,7 +38679,13 @@ var PolygonIdSdk = (function (exports) {
          *  The ``to`` address for the transaction or ``null`` if the
          *  transaction is an ``init`` transaction.
          */
-        get to() { return this.#to; }
+        get to() {
+            const value = this.#to;
+            if (value == null && this.type === 3) {
+                return ZeroAddress;
+            }
+            return value;
+        }
         set to(value) {
             this.#to = (value == null) ? null : getAddress(value);
         }
@@ -38232,7 +38722,7 @@ var PolygonIdSdk = (function (exports) {
         get maxPriorityFeePerGas() {
             const value = this.#maxPriorityFeePerGas;
             if (value == null) {
-                if (this.type === 2) {
+                if (this.type === 2 || this.type === 3) {
                     return BN_0$4;
                 }
                 return null;
@@ -38249,7 +38739,7 @@ var PolygonIdSdk = (function (exports) {
         get maxFeePerGas() {
             const value = this.#maxFeePerGas;
             if (value == null) {
-                if (this.type === 2) {
+                if (this.type === 2 || this.type === 3) {
                     return BN_0$4;
                 }
                 return null;
@@ -38293,7 +38783,9 @@ var PolygonIdSdk = (function (exports) {
         get accessList() {
             const value = this.#accessList || null;
             if (value == null) {
-                if (this.type === 1 || this.type === 2) {
+                if (this.type === 1 || this.type === 2 || this.type === 3) {
+                    // @TODO: in v7, this should assign the value or become
+                    // a live object itself, otherwise mutation is inconsistent
                     return [];
                 }
                 return null;
@@ -38303,6 +38795,122 @@ var PolygonIdSdk = (function (exports) {
         set accessList(value) {
             this.#accessList = (value == null) ? null : accessListify(value);
         }
+        /**
+         *  The max fee per blob gas for Cancun transactions.
+         */
+        get maxFeePerBlobGas() {
+            const value = this.#maxFeePerBlobGas;
+            if (value == null && this.type === 3) {
+                return BN_0$4;
+            }
+            return value;
+        }
+        set maxFeePerBlobGas(value) {
+            this.#maxFeePerBlobGas = (value == null) ? null : getBigInt(value, "maxFeePerBlobGas");
+        }
+        /**
+         *  The BLOb versioned hashes for Cancun transactions.
+         */
+        get blobVersionedHashes() {
+            // @TODO: Mutation is inconsistent; if unset, the returned value
+            // cannot mutate the object, if set it can
+            let value = this.#blobVersionedHashes;
+            if (value == null && this.type === 3) {
+                return [];
+            }
+            return value;
+        }
+        set blobVersionedHashes(value) {
+            if (value != null) {
+                assertArgument(Array.isArray(value), "blobVersionedHashes must be an Array", "value", value);
+                value = value.slice();
+                for (let i = 0; i < value.length; i++) {
+                    assertArgument(isHexString(value[i], 32), "invalid blobVersionedHash", `value[${i}]`, value[i]);
+                }
+            }
+            this.#blobVersionedHashes = value;
+        }
+        /**
+         *  The BLObs for the Transaction, if any.
+         *
+         *  If ``blobs`` is non-``null``, then the [[seriailized]]
+         *  will return the network formatted sidecar, otherwise it
+         *  will return the standard [[link-eip-2718]] payload. The
+         *  [[unsignedSerialized]] is unaffected regardless.
+         *
+         *  When setting ``blobs``, either fully valid [[Blob]] objects
+         *  may be specified (i.e. correctly padded, with correct
+         *  committments and proofs) or a raw [[BytesLike]] may
+         *  be provided.
+         *
+         *  If raw [[BytesLike]] are provided, the [[kzg]] property **must**
+         *  be already set. The blob will be correctly padded and the
+         *  [[KzgLibrary]] will be used to compute the committment and
+         *  proof for the blob.
+         *
+         *  A BLOb is a sequence of field elements, each of which must
+         *  be within the BLS field modulo, so some additional processing
+         *  may be required to encode arbitrary data to ensure each 32 byte
+         *  field is within the valid range.
+         *
+         *  Setting this automatically populates [[blobVersionedHashes]],
+         *  overwriting any existing values. Setting this to ``null``
+         *  does **not** remove the [[blobVersionedHashes]], leaving them
+         *  present.
+         */
+        get blobs() {
+            if (this.#blobs == null) {
+                return null;
+            }
+            return this.#blobs.map((b) => Object.assign({}, b));
+        }
+        set blobs(_blobs) {
+            if (_blobs == null) {
+                this.#blobs = null;
+                return;
+            }
+            const blobs = [];
+            const versionedHashes = [];
+            for (let i = 0; i < _blobs.length; i++) {
+                const blob = _blobs[i];
+                if (isBytesLike(blob)) {
+                    assert$2(this.#kzg, "adding a raw blob requires a KZG library", "UNSUPPORTED_OPERATION", {
+                        operation: "set blobs()"
+                    });
+                    let data = getBytes(blob);
+                    assertArgument(data.length <= BLOB_SIZE, "blob is too large", `blobs[${i}]`, blob);
+                    // Pad blob if necessary
+                    if (data.length !== BLOB_SIZE) {
+                        const padded = new Uint8Array(BLOB_SIZE);
+                        padded.set(data);
+                        data = padded;
+                    }
+                    const commit = this.#kzg.blobToKzgCommitment(data);
+                    const proof = hexlify(this.#kzg.computeBlobKzgProof(data, commit));
+                    blobs.push({
+                        data: hexlify(data),
+                        commitment: hexlify(commit),
+                        proof
+                    });
+                    versionedHashes.push(getVersionedHash(1, commit));
+                }
+                else {
+                    const commit = hexlify(blob.commitment);
+                    blobs.push({
+                        data: hexlify(blob.data),
+                        commitment: commit,
+                        proof: hexlify(blob.proof)
+                    });
+                    versionedHashes.push(getVersionedHash(1, commit));
+                }
+            }
+            this.#blobs = blobs;
+            this.#blobVersionedHashes = versionedHashes;
+        }
+        get kzg() { return this.#kzg; }
+        set kzg(kzg) {
+            this.#kzg = kzg;
+        }
         /**
          *  Creates a new Transaction with default values.
          */
@@ -38310,15 +38918,19 @@ var PolygonIdSdk = (function (exports) {
             this.#type = null;
             this.#to = null;
             this.#nonce = 0;
-            this.#gasLimit = BigInt(0);
+            this.#gasLimit = BN_0$4;
             this.#gasPrice = null;
             this.#maxPriorityFeePerGas = null;
             this.#maxFeePerGas = null;
             this.#data = "0x";
-            this.#value = BigInt(0);
-            this.#chainId = BigInt(0);
+            this.#value = BN_0$4;
+            this.#chainId = BN_0$4;
             this.#sig = null;
             this.#accessList = null;
+            this.#maxFeePerBlobGas = null;
+            this.#blobVersionedHashes = null;
+            this.#blobs = null;
+            this.#kzg = null;
         }
         /**
          *  The transaction hash, if signed. Otherwise, ``null``.
@@ -38327,7 +38939,7 @@ var PolygonIdSdk = (function (exports) {
             if (this.signature == null) {
                 return null;
             }
-            return keccak256(this.serialized);
+            return keccak256(this.#getSerialized(true, false));
         }
         /**
          *  The pre-image hash of this transaction.
@@ -38363,9 +38975,23 @@ var PolygonIdSdk = (function (exports) {
          *  transaction are non-null.
          */
         isSigned() {
-            //isSigned(): this is SignedTransaction {
             return this.signature != null;
         }
+        #getSerialized(signed, sidecar) {
+            assert$2(!signed || this.signature != null, "cannot serialize unsigned transaction; maybe you meant .unsignedSerialized", "UNSUPPORTED_OPERATION", { operation: ".serialized" });
+            const sig = signed ? this.signature : null;
+            switch (this.inferType()) {
+                case 0:
+                    return _serializeLegacy(this, sig);
+                case 1:
+                    return _serializeEip2930(this, sig);
+                case 2:
+                    return _serializeEip1559(this, sig);
+                case 3:
+                    return _serializeEip4844(this, sig, sidecar ? this.blobs : null);
+            }
+            assert$2(false, "unsupported transaction type", "UNSUPPORTED_OPERATION", { operation: ".serialized" });
+        }
         /**
          *  The serialized transaction.
          *
@@ -38373,16 +38999,7 @@ var PolygonIdSdk = (function (exports) {
          *  use [[unsignedSerialized]].
          */
         get serialized() {
-            assert$2(this.signature != null, "cannot serialize unsigned transaction; maybe you meant .unsignedSerialized", "UNSUPPORTED_OPERATION", { operation: ".serialized" });
-            switch (this.inferType()) {
-                case 0:
-                    return _serializeLegacy(this, this.signature);
-                case 1:
-                    return _serializeEip2930(this, this.signature);
-                case 2:
-                    return _serializeEip1559(this, this.signature);
-            }
-            assert$2(false, "unsupported transaction type", "UNSUPPORTED_OPERATION", { operation: ".serialized" });
+            return this.#getSerialized(true, true);
         }
         /**
          *  The transaction pre-image.
@@ -38391,22 +39008,20 @@ var PolygonIdSdk = (function (exports) {
          *  authorize this transaction.
          */
         get unsignedSerialized() {
-            switch (this.inferType()) {
-                case 0:
-                    return _serializeLegacy(this);
-                case 1:
-                    return _serializeEip2930(this);
-                case 2:
-                    return _serializeEip1559(this);
-            }
-            assert$2(false, "unsupported transaction type", "UNSUPPORTED_OPERATION", { operation: ".unsignedSerialized" });
+            return this.#getSerialized(false, false);
         }
         /**
          *  Return the most "likely" type; currently the highest
          *  supported transaction type.
          */
         inferType() {
-            return (this.inferTypes().pop());
+            const types = this.inferTypes();
+            // Prefer London (EIP-1559) over Cancun (BLOb)
+            if (types.indexOf(2) >= 0) {
+                return 2;
+            }
+            // Return the highest inferred type
+            return (types.pop());
         }
         /**
          *  Validates the explicit properties and returns a list of compatible
@@ -38417,6 +39032,7 @@ var PolygonIdSdk = (function (exports) {
             const hasGasPrice = this.gasPrice != null;
             const hasFee = (this.maxFeePerGas != null || this.maxPriorityFeePerGas != null);
             const hasAccessList = (this.accessList != null);
+            const hasBlob = (this.#maxFeePerBlobGas != null || this.#blobVersionedHashes);
             //if (hasGasPrice && hasFee) {
             //    throw new Error("transaction cannot have gasPrice and maxFeePerGas");
             //}
@@ -38447,10 +39063,14 @@ var PolygonIdSdk = (function (exports) {
                     types.push(1);
                     types.push(2);
                 }
+                else if (hasBlob && this.to) {
+                    types.push(3);
+                }
                 else {
                     types.push(0);
                     types.push(1);
                     types.push(2);
+                    types.push(3);
                 }
             }
             types.sort();
@@ -38486,6 +39106,16 @@ var PolygonIdSdk = (function (exports) {
         isLondon() {
             return (this.type === 2);
         }
+        /**
+         *  Returns true if this transaction is an [[link-eip-4844]] BLOB
+         *  transaction.
+         *
+         *  This provides a Type Guard that the related properties are
+         *  non-null.
+         */
+        isCancun() {
+            return (this.type === 3);
+        }
         /**
          *  Create a copy of this transaciton.
          */
@@ -38534,6 +39164,7 @@ var PolygonIdSdk = (function (exports) {
                 switch (payload[0]) {
                     case 1: return Transaction.from(_parseEip2930(payload));
                     case 2: return Transaction.from(_parseEip1559(payload));
+                    case 3: return Transaction.from(_parseEip4844(payload));
                 }
                 assert$2(false, "unsupported transaction type", "UNSUPPORTED_OPERATION", { operation: "from" });
             }
@@ -38559,6 +39190,9 @@ var PolygonIdSdk = (function (exports) {
             if (tx.maxFeePerGas != null) {
                 result.maxFeePerGas = tx.maxFeePerGas;
             }
+            if (tx.maxFeePerBlobGas != null) {
+                result.maxFeePerBlobGas = tx.maxFeePerBlobGas;
+            }
             if (tx.data != null) {
                 result.data = tx.data;
             }
@@ -38574,12 +39208,24 @@ var PolygonIdSdk = (function (exports) {
             if (tx.accessList != null) {
                 result.accessList = tx.accessList;
             }
+            // This will get overwritten by blobs, if present
+            if (tx.blobVersionedHashes != null) {
+                result.blobVersionedHashes = tx.blobVersionedHashes;
+            }
+            // Make sure we assign the kzg before assigning blobs, which
+            // require the library in the event raw blob data is provided.
+            if (tx.kzg != null) {
+                result.kzg = tx.kzg;
+            }
+            if (tx.blobs != null) {
+                result.blobs = tx.blobs;
+            }
             if (tx.hash != null) {
-                assertArgument(result.isSigned(), "unsigned transaction cannot define hash", "tx", tx);
+                assertArgument(result.isSigned(), "unsigned transaction cannot define '.hash'", "tx", tx);
                 assertArgument(result.hash === tx.hash, "hash mismatch", "tx", tx);
             }
             if (tx.from != null) {
-                assertArgument(result.isSigned(), "unsigned transaction cannot define from", "tx", tx);
+                assertArgument(result.isSigned(), "unsigned transaction cannot define '.from'", "tx", tx);
                 assertArgument(result.from.toLowerCase() === (tx.from || "").toLowerCase(), "from mismatch", "tx", tx);
             }
             return result;
@@ -38646,11 +39292,11 @@ var PolygonIdSdk = (function (exports) {
     function getBaseEncoder(type) {
         // intXX and uintXX
         {
-            const match = type.match(/^(u?)int(\d*)$/);
+            const match = type.match(/^(u?)int(\d+)$/);
             if (match) {
                 const signed = (match[1] === "");
-                const width = parseInt(match[2] || "256");
-                assertArgument(width % 8 === 0 && width !== 0 && width <= 256 && (match[2] == null || match[2] === String(width)), "invalid numeric width", "type", type);
+                const width = parseInt(match[2]);
+                assertArgument(width % 8 === 0 && width !== 0 && width <= 256 && match[2] === String(width), "invalid numeric width", "type", type);
                 const boundsUpper = mask(BN_MAX_UINT256, signed ? (width - 1) : width);
                 const boundsLower = signed ? ((boundsUpper + BN_1) * BN__1) : BN_0$3;
                 return function (_value) {
@@ -38692,6 +39338,23 @@ var PolygonIdSdk = (function (exports) {
     function encodeType(name, fields) {
         return `${name}(${fields.map(({ name, type }) => (type + " " + name)).join(",")})`;
     }
+    // foo[][3] => { base: "foo", index: "[][3]", array: {
+    //     base: "foo", prefix: "foo[]", count: 3 } }
+    function splitArray(type) {
+        const match = type.match(/^([^\x5b]*)((\x5b\d*\x5d)*)(\x5b(\d*)\x5d)$/);
+        if (match) {
+            return {
+                base: match[1],
+                index: (match[2] + match[4]),
+                array: {
+                    base: match[1],
+                    prefix: (match[1] + match[2]),
+                    count: (match[5] ? parseInt(match[5]) : -1),
+                }
+            };
+        }
+        return { base: type };
+    }
     /**
      *  A **TypedDataEncode** prepares and encodes [[link-eip-712]] payloads
      *  for signed typed data.
@@ -38726,8 +39389,7 @@ var PolygonIdSdk = (function (exports) {
          *  do not violate the [[link-eip-712]] structural constraints as
          *  well as computes the [[primaryType]].
          */
-        constructor(types) {
-            this.#types = JSON.stringify(types);
+        constructor(_types) {
             this.#fullTypes = new Map();
             this.#encoderCache = new Map();
             // Link struct types to their direct child structs
@@ -38736,26 +39398,39 @@ var PolygonIdSdk = (function (exports) {
             const parents = new Map();
             // Link all subtypes within a given struct
             const subtypes = new Map();
-            Object.keys(types).forEach((type) => {
+            const types = {};
+            Object.keys(_types).forEach((type) => {
+                types[type] = _types[type].map(({ name, type }) => {
+                    // Normalize the base type (unless name conflict)
+                    let { base, index } = splitArray(type);
+                    if (base === "int" && !_types["int"]) {
+                        base = "int256";
+                    }
+                    if (base === "uint" && !_types["uint"]) {
+                        base = "uint256";
+                    }
+                    return { name, type: (base + (index || "")) };
+                });
                 links.set(type, new Set());
                 parents.set(type, []);
                 subtypes.set(type, new Set());
             });
+            this.#types = JSON.stringify(types);
             for (const name in types) {
                 const uniqueNames = new Set();
                 for (const field of types[name]) {
                     // Check each field has a unique name
-                    assertArgument(!uniqueNames.has(field.name), `duplicate variable name ${JSON.stringify(field.name)} in ${JSON.stringify(name)}`, "types", types);
+                    assertArgument(!uniqueNames.has(field.name), `duplicate variable name ${JSON.stringify(field.name)} in ${JSON.stringify(name)}`, "types", _types);
                     uniqueNames.add(field.name);
                     // Get the base type (drop any array specifiers)
-                    const baseType = (field.type.match(/^([^\x5b]*)(\x5b|$)/))[1] || null;
-                    assertArgument(baseType !== name, `circular type reference to ${JSON.stringify(baseType)}`, "types", types);
+                    const baseType = splitArray(field.type).base;
+                    assertArgument(baseType !== name, `circular type reference to ${JSON.stringify(baseType)}`, "types", _types);
                     // Is this a base encoding type?
                     const encoder = getBaseEncoder(baseType);
                     if (encoder) {
                         continue;
                     }
-                    assertArgument(parents.has(baseType), `unknown type ${JSON.stringify(baseType)}`, "types", types);
+                    assertArgument(parents.has(baseType), `unknown type ${JSON.stringify(baseType)}`, "types", _types);
                     // Add linkage
                     parents.get(baseType).push(name);
                     links.get(name).add(baseType);
@@ -38763,12 +39438,12 @@ var PolygonIdSdk = (function (exports) {
             }
             // Deduce the primary type
             const primaryTypes = Array.from(parents.keys()).filter((n) => (parents.get(n).length === 0));
-            assertArgument(primaryTypes.length !== 0, "missing primary type", "types", types);
-            assertArgument(primaryTypes.length === 1, `ambiguous primary types or unused types: ${primaryTypes.map((t) => (JSON.stringify(t))).join(", ")}`, "types", types);
+            assertArgument(primaryTypes.length !== 0, "missing primary type", "types", _types);
+            assertArgument(primaryTypes.length === 1, `ambiguous primary types or unused types: ${primaryTypes.map((t) => (JSON.stringify(t))).join(", ")}`, "types", _types);
             defineProperties(this, { primaryType: primaryTypes[0] });
             // Check for circular type references
             function checkCircular(type, found) {
-                assertArgument(!found.has(type), `circular type reference to ${JSON.stringify(type)}`, "types", types);
+                assertArgument(!found.has(type), `circular type reference to ${JSON.stringify(type)}`, "types", _types);
                 found.add(type);
                 for (const child of links.get(type)) {
                     if (!parents.has(child)) {
@@ -38811,12 +39486,12 @@ var PolygonIdSdk = (function (exports) {
                 }
             }
             // Array
-            const match = type.match(/^(.*)(\x5b(\d*)\x5d)$/);
-            if (match) {
-                const subtype = match[1];
+            const array = splitArray(type).array;
+            if (array) {
+                const subtype = array.prefix;
                 const subEncoder = this.getEncoder(subtype);
                 return (value) => {
-                    assertArgument(!match[3] || parseInt(match[3]) === value.length, `array length mismatch; expected length ${parseInt(match[3])}`, "value", value);
+                    assertArgument(array.count === -1 || array.count === value.length, `array length mismatch; expected length ${array.count}`, "value", value);
                     let result = value.map(subEncoder);
                     if (this.#fullTypes.has(subtype)) {
                         result = result.map(keccak256);
@@ -38886,10 +39561,10 @@ var PolygonIdSdk = (function (exports) {
                 }
             }
             // Array
-            const match = type.match(/^(.*)(\x5b(\d*)\x5d)$/);
-            if (match) {
-                assertArgument(!match[3] || parseInt(match[3]) === value.length, `array length mismatch; expected length ${parseInt(match[3])}`, "value", value);
-                return value.map((v) => this._visit(match[1], v, callback));
+            const array = splitArray(type).array;
+            if (array) {
+                assertArgument(array.count === -1 || array.count === value.length, `array length mismatch; expected length ${array.count}`, "value", value);
+                return value.map((v) => this._visit(array.prefix, v, callback));
             }
             // Struct
             const fields = this.types[type];
@@ -39028,6 +39703,8 @@ var PolygonIdSdk = (function (exports) {
                 domainTypes.push({ name, type: domainFieldTypes[name] });
             });
             const encoder = TypedDataEncoder.from(types);
+            // Get the normalized types
+            types = encoder.types;
             const typesWithDomain = Object.assign({}, types);
             assertArgument(typesWithDomain.EIP712Domain == null, "types must not contain EIP712Domain type", "types.EIP712Domain", types);
             typesWithDomain.EIP712Domain = domainTypes;
@@ -39078,10 +39755,10 @@ var PolygonIdSdk = (function (exports) {
         items.forEach((k) => result.add(k));
         return Object.freeze(result);
     }
-    const _kwVisibDeploy = "external public payable";
+    const _kwVisibDeploy = "external public payable override";
     const KwVisibDeploy = setify(_kwVisibDeploy.split(" "));
     // Visibility Keywords
-    const _kwVisib = "constant external internal payable private public pure view";
+    const _kwVisib = "constant external internal payable private public pure view override";
     const KwVisib = setify(_kwVisib.split(" "));
     const _kwTypes = "constructor error event fallback function receive struct";
     const KwTypes = setify(_kwTypes.split(" "));
@@ -39135,7 +39812,8 @@ var PolygonIdSdk = (function (exports) {
         // Pops and returns the value of the next token if it is `type`; throws if out of tokens
         popType(type) {
             if (this.peek().type !== type) {
-                throw new Error(`expected ${type}; got ${JSON.stringify(this.peek())}`);
+                const top = this.peek();
+                throw new Error(`expected ${type}; got ${top.type} ${JSON.stringify(top.text)}`);
             }
             return this.pop().text;
         }
@@ -39367,7 +40045,7 @@ var PolygonIdSdk = (function (exports) {
     }
     function consumeEoi(tokens) {
         if (tokens.length) {
-            throw new Error(`unexpected tokens: ${tokens.toString()}`);
+            throw new Error(`unexpected tokens at offset ${tokens.offset}: ${tokens.toString()}`);
         }
     }
     const regexArrayType = new RegExp(/^(.*)\[([0-9]*)\]$/);
@@ -39515,9 +40193,6 @@ var PolygonIdSdk = (function (exports) {
             }
             else {
                 if (this.isTuple()) {
-                    if (format !== "sighash") {
-                        result += this.type;
-                    }
                     result += "(" + this.components.map((comp) => comp.format(format)).join((format === "full") ? ", " : ",") + ")";
                 }
                 else {
@@ -39650,7 +40325,7 @@ var PolygonIdSdk = (function (exports) {
          *  Walks the **ParamType** with %%value%%, asynchronously calling
          *  %%process%% on each type, destructing the %%value%% recursively.
          *
-         *  This can be used to resolve ENS naes by walking and resolving each
+         *  This can be used to resolve ENS names by walking and resolving each
          *  ``"address"`` type.
          */
         async walkAsync(value, process) {
@@ -40059,7 +40734,9 @@ var PolygonIdSdk = (function (exports) {
                 });
             }
             const result = [`constructor${joinParams(format, this.inputs)}`];
-            result.push((this.payable) ? "payable" : "nonpayable");
+            if (this.payable) {
+                result.push("payable");
+            }
             if (this.gas != null) {
                 result.push(`@${this.gas.toString()}`);
             }
@@ -40405,6 +41082,7 @@ var PolygonIdSdk = (function (exports) {
     const paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);
     const paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);
     let defaultCoder = null;
+    let defaultMaxInflation = 1024;
     function getBuiltinCallException(action, tx, data, abiCoder) {
         let message = "missing revert data";
         let reason = null;
@@ -40541,7 +41219,11 @@ var PolygonIdSdk = (function (exports) {
         decode(types, data, loose) {
             const coders = types.map((type) => this.#getCoder(ParamType.from(type)));
             const coder = new TupleCoder(coders, "_");
-            return coder.decode(new Reader(data, loose));
+            return coder.decode(new Reader(data, loose, defaultMaxInflation));
+        }
+        static _setDefaultMaxInflation(value) {
+            assertArgument(typeof (value) === "number" && Number.isInteger(value), "invalid defaultMaxInflation factor", "value", value);
+            defaultMaxInflation = value;
         }
         /**
          *  Returns the shared singleton instance of a default [[AbiCoder]].
@@ -40803,7 +41485,7 @@ var PolygonIdSdk = (function (exports) {
                     frags.push(Fragment.from(a));
                 }
                 catch (error) {
-                    console.log("EE", error);
+                    console.log(`[Warning] Invalid Fragment ${JSON.stringify(a)}:`, error.message);
                 }
             }
             defineProperties(this, {
@@ -41644,7 +42326,11 @@ var PolygonIdSdk = (function (exports) {
             if (typeof (value) === "string") {
                 return new Interface(JSON.parse(value));
             }
-            // Maybe an interface from an older version, or from a symlinked copy
+            // An Interface; possibly from another v6 instance
+            if (typeof (value.formatJson) === "function") {
+                return new Interface(value.formatJson());
+            }
+            // A legacy Interface; from an older version
             if (typeof (value.format) === "function") {
                 return new Interface(value.format("json"));
             }
@@ -41741,7 +42427,7 @@ var PolygonIdSdk = (function (exports) {
         if (req.data) {
             result.data = hexlify(req.data);
         }
-        const bigIntKeys = "chainId,gasLimit,gasPrice,maxFeePerGas,maxPriorityFeePerGas,value".split(/,/);
+        const bigIntKeys = "chainId,gasLimit,gasPrice,maxFeePerBlobGas,maxFeePerGas,maxPriorityFeePerGas,value".split(/,/);
         for (const key of bigIntKeys) {
             if (!(key in req) || req[key] == null) {
                 continue;
@@ -41767,6 +42453,20 @@ var PolygonIdSdk = (function (exports) {
         if ("customData" in req) {
             result.customData = req.customData;
         }
+        if ("blobVersionedHashes" in req && req.blobVersionedHashes) {
+            result.blobVersionedHashes = req.blobVersionedHashes.slice();
+        }
+        if ("kzg" in req) {
+            result.kzg = req.kzg;
+        }
+        if ("blobs" in req && req.blobs) {
+            result.blobs = req.blobs.map((b) => {
+                if (isBytesLike(b)) {
+                    return hexlify(b);
+                }
+                return Object.assign({}, b);
+            });
+        }
         return result;
     }
     /**
@@ -41800,6 +42500,11 @@ var PolygonIdSdk = (function (exports) {
          *  The block hash of the parent block.
          */
         parentHash;
+        /**
+         *  The hash tree root of the parent beacon block for the given
+         *  execution block. See [[link-eip-4788]].
+         */
+        parentBeaconBlockRoot;
         /**
          *  The nonce.
          *
@@ -41825,11 +42530,35 @@ var PolygonIdSdk = (function (exports) {
          *  The total gas used in this block.
          */
         gasUsed;
+        /**
+         *  The root hash for the global state after applying changes
+         *  in this block.
+         */
+        stateRoot;
+        /**
+         *  The hash of the transaction receipts trie.
+         */
+        receiptsRoot;
+        /**
+         *  The total amount of blob gas consumed by the transactions
+         *  within the block. See [[link-eip-4844]].
+         */
+        blobGasUsed;
+        /**
+         *  The running total of blob gas consumed in excess of the
+         *  target, prior to the block. See [[link-eip-4844]].
+         */
+        excessBlobGas;
         /**
          *  The miner coinbase address, wihch receives any subsidies for
          *  including this block.
          */
         miner;
+        /**
+         *  The latest RANDAO mix of the post beacon state of
+         *  the previous block.
+         */
+        prevRandao;
         /**
          *  Any extra data the validator wished to include.
          */
@@ -41862,13 +42591,19 @@ var PolygonIdSdk = (function (exports) {
                 number: block.number,
                 timestamp: block.timestamp,
                 parentHash: block.parentHash,
+                parentBeaconBlockRoot: block.parentBeaconBlockRoot,
                 nonce: block.nonce,
                 difficulty: block.difficulty,
                 gasLimit: block.gasLimit,
                 gasUsed: block.gasUsed,
+                blobGasUsed: block.blobGasUsed,
+                excessBlobGas: block.excessBlobGas,
                 miner: block.miner,
+                prevRandao: getValue(block.prevRandao),
                 extraData: block.extraData,
-                baseFeePerGas: getValue(block.baseFeePerGas)
+                baseFeePerGas: getValue(block.baseFeePerGas),
+                stateRoot: block.stateRoot,
+                receiptsRoot: block.receiptsRoot,
             });
         }
         /**
@@ -41907,7 +42642,7 @@ var PolygonIdSdk = (function (exports) {
          *  Returns a JSON-friendly value.
          */
         toJSON() {
-            const { baseFeePerGas, difficulty, extraData, gasLimit, gasUsed, hash, miner, nonce, number, parentHash, timestamp, transactions } = this;
+            const { baseFeePerGas, difficulty, extraData, gasLimit, gasUsed, hash, miner, prevRandao, nonce, number, parentHash, parentBeaconBlockRoot, stateRoot, receiptsRoot, timestamp, transactions } = this;
             return {
                 _type: "Block",
                 baseFeePerGas: toJson(baseFeePerGas),
@@ -41915,7 +42650,10 @@ var PolygonIdSdk = (function (exports) {
                 extraData,
                 gasLimit: toJson(gasLimit),
                 gasUsed: toJson(gasUsed),
-                hash, miner, nonce, number, parentHash, timestamp,
+                blobGasUsed: toJson(this.blobGasUsed),
+                excessBlobGas: toJson(this.excessBlobGas),
+                hash, miner, prevRandao, nonce, number, parentHash, timestamp,
+                parentBeaconBlockRoot, stateRoot, receiptsRoot,
                 transactions,
             };
         }
@@ -42173,7 +42911,7 @@ var PolygonIdSdk = (function (exports) {
          */
         provider;
         /**
-         *  The address the transaction was send to.
+         *  The address the transaction was sent to.
          */
         to;
         /**
@@ -42218,6 +42956,10 @@ var PolygonIdSdk = (function (exports) {
          *  entire gas limit. After the transaction, the difference is refunded.
          */
         gasUsed;
+        /**
+         *  The gas used for BLObs. See [[link-eip-4844]].
+         */
+        blobGasUsed;
         /**
          *  The amount of gas used by all transactions within the block for this
          *  and all transactions with a lower ``index``.
@@ -42234,6 +42976,10 @@ var PolygonIdSdk = (function (exports) {
          *  fee is protocol-enforced.
          */
         gasPrice;
+        /**
+         *  The price paid per BLOB in gas. See [[link-eip-4844]].
+         */
+        blobGasPrice;
         /**
          *  The [[link-eip-2718]] transaction type.
          */
@@ -42281,7 +43027,9 @@ var PolygonIdSdk = (function (exports) {
                 logsBloom: tx.logsBloom,
                 gasUsed: tx.gasUsed,
                 cumulativeGasUsed: tx.cumulativeGasUsed,
+                blobGasUsed: tx.blobGasUsed,
                 gasPrice,
+                blobGasPrice: tx.blobGasPrice,
                 type: tx.type,
                 //byzantium: tx.byzantium,
                 status: tx.status,
@@ -42306,6 +43054,8 @@ var PolygonIdSdk = (function (exports) {
                 cumulativeGasUsed: toJson(this.cumulativeGasUsed),
                 from,
                 gasPrice: toJson(this.gasPrice),
+                blobGasUsed: toJson(this.blobGasUsed),
+                blobGasPrice: toJson(this.blobGasPrice),
                 gasUsed: toJson(this.gasUsed),
                 hash, index, logs, logsBloom, root, status, to
             };
@@ -42474,6 +43224,10 @@ var PolygonIdSdk = (function (exports) {
          *  to charge the sender.
          */
         maxFeePerGas;
+        /**
+         *  The [[link-eip-4844]] max fee per BLOb gas.
+         */
+        maxFeePerBlobGas;
         /**
          *  The data.
          */
@@ -42496,6 +43250,10 @@ var PolygonIdSdk = (function (exports) {
          *  support it, otherwise ``null``.
          */
         accessList;
+        /**
+         *  The [[link-eip-4844]] BLOb versioned hashes.
+         */
+        blobVersionedHashes;
         #startBlock;
         /**
          *  @_ignore:
@@ -42516,19 +43274,22 @@ var PolygonIdSdk = (function (exports) {
             this.gasPrice = tx.gasPrice;
             this.maxPriorityFeePerGas = (tx.maxPriorityFeePerGas != null) ? tx.maxPriorityFeePerGas : null;
             this.maxFeePerGas = (tx.maxFeePerGas != null) ? tx.maxFeePerGas : null;
+            this.maxFeePerBlobGas = (tx.maxFeePerBlobGas != null) ? tx.maxFeePerBlobGas : null;
             this.chainId = tx.chainId;
             this.signature = tx.signature;
             this.accessList = (tx.accessList != null) ? tx.accessList : null;
+            this.blobVersionedHashes = (tx.blobVersionedHashes != null) ? tx.blobVersionedHashes : null;
             this.#startBlock = -1;
         }
         /**
          *  Returns a JSON-compatible representation of this transaction.
          */
         toJSON() {
-            const { blockNumber, blockHash, index, hash, type, to, from, nonce, data, signature, accessList } = this;
+            const { blockNumber, blockHash, index, hash, type, to, from, nonce, data, signature, accessList, blobVersionedHashes } = this;
             return {
-                _type: "TransactionReceipt",
+                _type: "TransactionResponse",
                 accessList, blockNumber, blockHash,
+                blobVersionedHashes,
                 chainId: toJson(this.chainId),
                 data, from,
                 gasLimit: toJson(this.gasLimit),
@@ -42536,6 +43297,7 @@ var PolygonIdSdk = (function (exports) {
                 hash,
                 maxFeePerGas: toJson(this.maxFeePerGas),
                 maxPriorityFeePerGas: toJson(this.maxPriorityFeePerGas),
+                maxFeePerBlobGas: toJson(this.maxFeePerBlobGas),
                 nonce, signature, to, index, type,
                 value: toJson(this.value),
             };
@@ -42817,6 +43579,13 @@ var PolygonIdSdk = (function (exports) {
         isLondon() {
             return (this.type === 2);
         }
+        /**
+         *  Returns true if hte transaction is a Cancun (i.e. ``type == 3``)
+         *  transaction. See [[link-eip-4844]].
+         */
+        isCancun() {
+            return (this.type === 3);
+        }
         /**
          *  Returns a filter which can be used to listen for orphan events
          *  that evict this transaction.
@@ -42976,8 +43745,8 @@ var PolygonIdSdk = (function (exports) {
          *  and the transaction has not been mined, otherwise this will
          *  wait until enough confirmations have completed.
          */
-        async wait(confirms) {
-            const receipt = await super.wait(confirms);
+        async wait(confirms, timeout) {
+            const receipt = await super.wait(confirms, timeout);
             if (receipt == null) {
                 return null;
             }
@@ -44036,13 +44805,13 @@ var PolygonIdSdk = (function (exports) {
             return false;
         }
         /**
-         *  Resovles to the encoded %%address%% for %%coinType%%.
+         *  Resolves to the encoded %%address%% for %%coinType%%.
          */
         async encodeAddress(coinType, address) {
             throw new Error("unsupported coin");
         }
         /**
-         *  Resovles to the decoded %%data%% for %%coinType%%.
+         *  Resolves to the decoded %%data%% for %%coinType%%.
          */
         async decodeAddress(coinType, data) {
             throw new Error("unsupported coin");
@@ -44122,7 +44891,7 @@ var PolygonIdSdk = (function (exports) {
                     info: { funcName }
                 });
                 params = [
-                    dnsEncode(this.name),
+                    dnsEncode(this.name, 255),
                     iface.encodeFunctionData(fragment, params)
                 ];
                 funcName = "resolve(bytes,bytes)";
@@ -44477,8 +45246,11 @@ var PolygonIdSdk = (function (exports) {
             return format(value);
         });
     }
-    function arrayOf(format) {
+    function arrayOf(format, allowNull) {
         return ((array) => {
+            if (allowNull && array == null) {
+                return null;
+            }
             if (!Array.isArray(array)) {
                 throw new Error("not an array");
             }
@@ -44553,15 +45325,23 @@ var PolygonIdSdk = (function (exports) {
     const _formatBlock = object({
         hash: allowNull(formatHash),
         parentHash: formatHash,
+        parentBeaconBlockRoot: allowNull(formatHash, null),
         number: getNumber,
         timestamp: getNumber,
         nonce: allowNull(formatData),
         difficulty: getBigInt,
         gasLimit: getBigInt,
         gasUsed: getBigInt,
+        stateRoot: allowNull(formatHash, null),
+        receiptsRoot: allowNull(formatHash, null),
+        blobGasUsed: allowNull(getBigInt, null),
+        excessBlobGas: allowNull(getBigInt, null),
         miner: allowNull(getAddress),
+        prevRandao: allowNull(formatHash, null),
         extraData: formatData,
         baseFeePerGas: allowNull(getBigInt)
+    }, {
+        prevRandao: ["mixHash"]
     });
     function formatBlock(value) {
         const result = _formatBlock(value);
@@ -44596,6 +45376,7 @@ var PolygonIdSdk = (function (exports) {
         index: getNumber,
         root: allowNull(hexlify),
         gasUsed: getBigInt,
+        blobGasUsed: allowNull(getBigInt, null),
         logsBloom: allowNull(formatData),
         blockHash: formatHash,
         hash: formatHash,
@@ -44604,6 +45385,7 @@ var PolygonIdSdk = (function (exports) {
         //confirmations: allowNull(getNumber, null),
         cumulativeGasUsed: getBigInt,
         effectiveGasPrice: allowNull(getBigInt),
+        blobGasPrice: allowNull(getBigInt, null),
         status: allowNull(getNumber),
         type: allowNull(getNumber, 0)
     }, {
@@ -44622,6 +45404,8 @@ var PolygonIdSdk = (function (exports) {
         }
         const result = object({
             hash: formatHash,
+            // Some nodes do not return this, usually test nodes (like Ganache)
+            index: allowNull(getNumber, undefined),
             type: (value) => {
                 if (value === "0x" || value == null) {
                     return 0;
@@ -44629,15 +45413,16 @@ var PolygonIdSdk = (function (exports) {
                 return getNumber(value);
             },
             accessList: allowNull(accessListify, null),
+            blobVersionedHashes: allowNull(arrayOf(formatHash, true), null),
             blockHash: allowNull(formatHash, null),
             blockNumber: allowNull(getNumber, null),
             transactionIndex: allowNull(getNumber, null),
-            //confirmations: allowNull(getNumber, null),
             from: getAddress,
             // either (gasPrice) or (maxPriorityFeePerGas + maxFeePerGas) must be set
             gasPrice: allowNull(getBigInt),
             maxPriorityFeePerGas: allowNull(getBigInt),
             maxFeePerGas: allowNull(getBigInt),
+            maxFeePerBlobGas: allowNull(getBigInt, null),
             gasLimit: getBigInt,
             to: allowNull(getAddress, null),
             value: getBigInt,
@@ -44647,7 +45432,8 @@ var PolygonIdSdk = (function (exports) {
             chainId: allowNull(getBigInt, null)
         }, {
             data: ["input"],
-            gasLimit: ["gas"]
+            gasLimit: ["gas"],
+            index: ["transactionIndex"]
         })(value);
         // If to and creates are empty, populate the creates from the value
         if (result.to == null && result.creates == null) {
@@ -45173,23 +45959,6 @@ var PolygonIdSdk = (function (exports) {
             }
         });
     }
-    // Used by Optimism for a custom priority fee
-    function getPriorityFeePlugin(maxPriorityFeePerGas) {
-        return new FetchUrlFeeDataNetworkPlugin("data:", async (fetchFeeData, provider, request) => {
-            const feeData = await fetchFeeData();
-            // This should always fail
-            if (feeData.maxFeePerGas == null || feeData.maxPriorityFeePerGas == null) {
-                return feeData;
-            }
-            // Compute the corrected baseFee to recompute the updated values
-            const baseFee = feeData.maxFeePerGas - feeData.maxPriorityFeePerGas;
-            return {
-                gasPrice: feeData.gasPrice,
-                maxFeePerGas: (baseFee + maxPriorityFeePerGas),
-                maxPriorityFeePerGas
-            };
-        });
-    }
     // See: https://chainlist.org
     let injected = false;
     function injectCommonNetworks() {
@@ -45225,23 +45994,30 @@ var PolygonIdSdk = (function (exports) {
         registerEth("rinkeby", 4, { ensNetwork: 4 });
         registerEth("goerli", 5, { ensNetwork: 5 });
         registerEth("kovan", 42, { ensNetwork: 42 });
-        registerEth("sepolia", 11155111, {});
+        registerEth("sepolia", 11155111, { ensNetwork: 11155111 });
+        registerEth("holesky", 17000, { ensNetwork: 17000 });
         registerEth("classic", 61, {});
         registerEth("classicKotti", 6, {});
         registerEth("arbitrum", 42161, {
             ensNetwork: 1,
         });
         registerEth("arbitrum-goerli", 421613, {});
+        registerEth("arbitrum-sepolia", 421614, {});
+        registerEth("base", 8453, { ensNetwork: 1 });
+        registerEth("base-goerli", 84531, {});
+        registerEth("base-sepolia", 84532, {});
         registerEth("bnb", 56, { ensNetwork: 1 });
         registerEth("bnbt", 97, {});
         registerEth("linea", 59144, { ensNetwork: 1 });
         registerEth("linea-goerli", 59140, {});
+        registerEth("linea-sepolia", 59141, {});
         registerEth("matic", 137, {
             ensNetwork: 1,
             plugins: [
                 getGasStationPlugin("https:/\/gasstation.polygon.technology/v2")
             ]
         });
+        registerEth("matic-amoy", 80002, {});
         registerEth("matic-mumbai", 80001, {
             altNames: ["maticMumbai", "maticmum"],
             plugins: [
@@ -45250,11 +46026,10 @@ var PolygonIdSdk = (function (exports) {
         });
         registerEth("optimism", 10, {
             ensNetwork: 1,
-            plugins: [
-                getPriorityFeePlugin(BigInt("1000000"))
-            ]
+            plugins: []
         });
         registerEth("optimism-goerli", 420, {});
+        registerEth("optimism-sepolia", 11155420, {});
         registerEth("xdai", 100, { ensNetwork: 1 });
     }
 
@@ -45388,6 +46163,34 @@ var PolygonIdSdk = (function (exports) {
         pause(dropWhilePaused) { this.stop(); }
         resume() { this.start(); }
     }
+    class PollingBlockTagSubscriber extends OnBlockSubscriber {
+        #tag;
+        #lastBlock;
+        constructor(provider, tag) {
+            super(provider);
+            this.#tag = tag;
+            this.#lastBlock = -2;
+        }
+        pause(dropWhilePaused) {
+            if (dropWhilePaused) {
+                this.#lastBlock = -2;
+            }
+            super.pause(dropWhilePaused);
+        }
+        async _poll(blockNumber, provider) {
+            const block = await provider.getBlock(this.#tag);
+            if (block == null) {
+                return;
+            }
+            if (this.#lastBlock === -2) {
+                this.#lastBlock = block.number;
+            }
+            else if (block.number > this.#lastBlock) {
+                provider.emit(this.#tag, block.number);
+                this.#lastBlock = block.number;
+            }
+        }
+    }
     /**
      *  @_ignore:
      *
@@ -45586,10 +46389,12 @@ var PolygonIdSdk = (function (exports) {
         if (typeof (_event) === "string") {
             switch (_event) {
                 case "block":
-                case "pending":
                 case "debug":
                 case "error":
-                case "network": {
+                case "finalized":
+                case "network":
+                case "pending":
+                case "safe": {
                     return { type: _event, tag: _event };
                 }
             }
@@ -45887,10 +46692,10 @@ var PolygonIdSdk = (function (exports) {
             switch (blockTag) {
                 case "earliest":
                     return "0x0";
+                case "finalized":
                 case "latest":
                 case "pending":
                 case "safe":
-                case "finalized":
                     return blockTag;
             }
             if (isHexString(blockTag)) {
@@ -45994,7 +46799,7 @@ var PolygonIdSdk = (function (exports) {
             return resolve(address, fromBlock, toBlock);
         }
         /**
-         *  Returns or resovles to a transaction for %%request%%, resolving
+         *  Returns or resolves to a transaction for %%request%%, resolving
          *  any ENS names or [[Addressable]] and returning if already a valid
          *  transaction.
          */
@@ -46034,16 +46839,19 @@ var PolygonIdSdk = (function (exports) {
             // No explicit network was set and this is our first time
             if (this.#networkPromise == null) {
                 // Detect the current network (shared with all calls)
-                const detectNetwork = this._detectNetwork().then((network) => {
-                    this.emit("network", network, null);
-                    return network;
-                }, (error) => {
-                    // Reset the networkPromise on failure, so we will try again
-                    if (this.#networkPromise === detectNetwork) {
-                        this.#networkPromise = null;
+                const detectNetwork = (async () => {
+                    try {
+                        const network = await this._detectNetwork();
+                        this.emit("network", network, null);
+                        return network;
                     }
-                    throw error;
-                });
+                    catch (error) {
+                        if (this.#networkPromise === detectNetwork) {
+                            this.#networkPromise = null;
+                        }
+                        throw error;
+                    }
+                })();
                 this.#networkPromise = detectNetwork;
                 return (await detectNetwork).clone();
             }
@@ -46073,12 +46881,20 @@ var PolygonIdSdk = (function (exports) {
         async getFeeData() {
             const network = await this.getNetwork();
             const getFeeDataFunc = async () => {
-                const { _block, gasPrice } = await resolveProperties({
+                const { _block, gasPrice, priorityFee } = await resolveProperties({
                     _block: this.#getBlock("latest", false),
                     gasPrice: ((async () => {
                         try {
-                            const gasPrice = await this.#perform({ method: "getGasPrice" });
-                            return getBigInt(gasPrice, "%response");
+                            const value = await this.#perform({ method: "getGasPrice" });
+                            return getBigInt(value, "%response");
+                        }
+                        catch (error) { }
+                        return null;
+                    })()),
+                    priorityFee: ((async () => {
+                        try {
+                            const value = await this.#perform({ method: "getPriorityFee" });
+                            return getBigInt(value, "%response");
                         }
                         catch (error) { }
                         return null;
@@ -46089,7 +46905,7 @@ var PolygonIdSdk = (function (exports) {
                 // These are the recommended EIP-1559 heuristics for fee data
                 const block = this._wrapBlock(_block, network);
                 if (block && block.baseFeePerGas) {
-                    maxPriorityFeePerGas = BigInt("1000000000");
+                    maxPriorityFeePerGas = (priorityFee != null) ? priorityFee : BigInt("1000000000");
                     maxFeePerGas = (block.baseFeePerGas * BN_2) + maxPriorityFeePerGas;
                 }
                 return new FeeData(gasPrice, maxFeePerGas, maxPriorityFeePerGas);
@@ -46467,6 +47283,9 @@ var PolygonIdSdk = (function (exports) {
                     subscriber.pollingInterval = this.pollingInterval;
                     return subscriber;
                 }
+                case "safe":
+                case "finalized":
+                    return new PollingBlockTagSubscriber(this, sub.type);
                 case "event":
                     return new PollingEventSubscriber(this, sub.filter);
                 case "transaction":
@@ -47017,8 +47836,8 @@ var PolygonIdSdk = (function (exports) {
                         });
                     }
                 }
-                else if (pop.type === 2) {
-                    // Explicitly using EIP-1559
+                else if (pop.type === 2 || pop.type === 3) {
+                    // Explicitly using EIP-1559 or EIP-4844
                     // Populate missing fee data
                     if (pop.maxFeePerGas == null) {
                         pop.maxFeePerGas = feeData.maxFeePerGas;
@@ -47148,6 +47967,9 @@ var PolygonIdSdk = (function (exports) {
             if (filterIdPromise) {
                 this.#filterIdPromise = null;
                 filterIdPromise.then((filterId) => {
+                    if (this.#provider.destroyed) {
+                        return;
+                    }
                     this.#provider.send("eth_uninstallFilter", [filterId]);
                 });
             }
@@ -47345,12 +48167,45 @@ var PolygonIdSdk = (function (exports) {
             // for it; it should show up very quickly
             return await (new Promise((resolve, reject) => {
                 const timeouts = [1000, 100];
+                let invalids = 0;
                 const checkTx = async () => {
-                    // Try getting the transaction
-                    const tx = await this.provider.getTransaction(hash);
-                    if (tx != null) {
-                        resolve(tx.replaceableTransaction(blockNumber));
-                        return;
+                    try {
+                        // Try getting the transaction
+                        const tx = await this.provider.getTransaction(hash);
+                        if (tx != null) {
+                            resolve(tx.replaceableTransaction(blockNumber));
+                            return;
+                        }
+                    }
+                    catch (error) {
+                        // If we were cancelled: stop polling.
+                        // If the data is bad: the node returns bad transactions
+                        // If the network changed: calling again will also fail
+                        // If unsupported: likely destroyed
+                        if (isError(error, "CANCELLED") || isError(error, "BAD_DATA") ||
+                            isError(error, "NETWORK_ERROR" )) {
+                            if (error.info == null) {
+                                error.info = {};
+                            }
+                            error.info.sendTransactionHash = hash;
+                            reject(error);
+                            return;
+                        }
+                        // Stop-gap for misbehaving backends; see #4513
+                        if (isError(error, "INVALID_ARGUMENT")) {
+                            invalids++;
+                            if (error.info == null) {
+                                error.info = {};
+                            }
+                            error.info.sendTransactionHash = hash;
+                            if (invalids > 10) {
+                                reject(error);
+                                return;
+                            }
+                        }
+                        // Notify anyone that cares; but we will try again, since
+                        // it is likely an intermittent service error
+                        this.provider.emit("error", makeError("failed to fetch transation after sending (will try again)", "UNKNOWN_ERROR", { error }));
                     }
                     // Wait another 4 seconds
                     this.provider._setTimeout(() => { checkTx(); }, timeouts.pop() || 4000);
@@ -47423,11 +48278,12 @@ var PolygonIdSdk = (function (exports) {
         #drainTimer;
         #notReady;
         #network;
+        #pendingDetectNetwork;
         #scheduleDrain() {
             if (this.#drainTimer) {
                 return;
             }
-            // If we aren't using batching, no hard in sending it immeidately
+            // If we aren't using batching, no harm in sending it immediately
             const stallTime = (this._getOption("batchMaxCount") === 1) ? 0 : this._getOption("batchStallTime");
             this.#drainTimer = setTimeout(() => {
                 this.#drainTimer = null;
@@ -47498,6 +48354,7 @@ var PolygonIdSdk = (function (exports) {
             this.#payloads = [];
             this.#drainTimer = null;
             this.#network = null;
+            this.#pendingDetectNetwork = null;
             {
                 let resolve = null;
                 const promise = new Promise((_resolve) => {
@@ -47505,9 +48362,15 @@ var PolygonIdSdk = (function (exports) {
                 });
                 this.#notReady = { promise, resolve };
             }
-            // Make sure any static network is compatbile with the provided netwrok
             const staticNetwork = this._getOption("staticNetwork");
-            if (staticNetwork) {
+            if (typeof (staticNetwork) === "boolean") {
+                assertArgument(!staticNetwork || network !== "any", "staticNetwork cannot be used on special network 'any'", "options", options);
+                if (staticNetwork && network != null) {
+                    this.#network = Network.from(network);
+                }
+            }
+            else if (staticNetwork) {
+                // Make sure any static network is compatbile with the provided netwrok
                 assertArgument(network == null || staticNetwork.matches(network), "staticNetwork MUST match network object", "options", options);
                 this.#network = staticNetwork;
             }
@@ -47540,7 +48403,7 @@ var PolygonIdSdk = (function (exports) {
             if (req.method === "call" || req.method === "estimateGas") {
                 let tx = req.transaction;
                 if (tx && tx.type != null && getBigInt(tx.type)) {
-                    // If there are no EIP-1559 properties, it might be non-EIP-a559
+                    // If there are no EIP-1559 or newer properties, it might be pre-EIP-1559
                     if (tx.maxFeePerGas == null && tx.maxPriorityFeePerGas == null) {
                         const feeData = await this.getFeeData();
                         if (feeData.maxFeePerGas == null && feeData.maxPriorityFeePerGas == null) {
@@ -47568,30 +48431,56 @@ var PolygonIdSdk = (function (exports) {
         async _detectNetwork() {
             const network = this._getOption("staticNetwork");
             if (network) {
-                return network;
+                if (network === true) {
+                    if (this.#network) {
+                        return this.#network;
+                    }
+                }
+                else {
+                    return network;
+                }
+            }
+            if (this.#pendingDetectNetwork) {
+                return await this.#pendingDetectNetwork;
             }
             // If we are ready, use ``send``, which enabled requests to be batched
             if (this.ready) {
-                return Network.from(getBigInt(await this.send("eth_chainId", [])));
+                this.#pendingDetectNetwork = (async () => {
+                    try {
+                        const result = Network.from(getBigInt(await this.send("eth_chainId", [])));
+                        this.#pendingDetectNetwork = null;
+                        return result;
+                    }
+                    catch (error) {
+                        this.#pendingDetectNetwork = null;
+                        throw error;
+                    }
+                })();
+                return await this.#pendingDetectNetwork;
             }
             // We are not ready yet; use the primitive _send
-            const payload = {
-                id: this.#nextId++, method: "eth_chainId", params: [], jsonrpc: "2.0"
-            };
-            this.emit("debug", { action: "sendRpcPayload", payload });
-            let result;
-            try {
-                result = (await this._send(payload))[0];
-            }
-            catch (error) {
-                this.emit("debug", { action: "receiveRpcError", error });
-                throw error;
-            }
-            this.emit("debug", { action: "receiveRpcResult", result });
-            if ("result" in result) {
-                return Network.from(getBigInt(result.result));
-            }
-            throw this.getRpcError(payload, result);
+            this.#pendingDetectNetwork = (async () => {
+                const payload = {
+                    id: this.#nextId++, method: "eth_chainId", params: [], jsonrpc: "2.0"
+                };
+                this.emit("debug", { action: "sendRpcPayload", payload });
+                let result;
+                try {
+                    result = (await this._send(payload))[0];
+                    this.#pendingDetectNetwork = null;
+                }
+                catch (error) {
+                    this.#pendingDetectNetwork = null;
+                    this.emit("debug", { action: "receiveRpcError", error });
+                    throw error;
+                }
+                this.emit("debug", { action: "receiveRpcResult", result });
+                if ("result" in result) {
+                    return Network.from(getBigInt(result.result));
+                }
+                throw this.getRpcError(payload, result);
+            })();
+            return await this.#pendingDetectNetwork;
         }
         /**
          *  Sub-classes **MUST** call this. Until [[_start]] has been called, no calls
@@ -47693,6 +48582,14 @@ var PolygonIdSdk = (function (exports) {
             if (tx.accessList) {
                 result["accessList"] = accessListify(tx.accessList);
             }
+            if (tx.blobVersionedHashes) {
+                // @TODO: Remove this <any> case once EIP-4844 added to prepared tx
+                result["blobVersionedHashes"] = tx.blobVersionedHashes.map(h => h.toLowerCase());
+            }
+            // @TODO: blobs should probably also be copied over, optionally
+            // accounting for the kzg property to backfill blobVersionedHashes
+            // using the commitment. Or should that be left as an exercise to
+            // the caller?
             return result;
         }
         /**
@@ -47707,6 +48604,8 @@ var PolygonIdSdk = (function (exports) {
                     return { method: "eth_blockNumber", args: [] };
                 case "getGasPrice":
                     return { method: "eth_gasPrice", args: [] };
+                case "getPriorityFee":
+                    return { method: "eth_maxPriorityFeePerGas", args: [] };
                 case "getBalance":
                     return {
                         method: "eth_getBalance",
@@ -47957,7 +48856,11 @@ var PolygonIdSdk = (function (exports) {
         #pollingInterval;
         constructor(network, options) {
             super(network, options);
-            this.#pollingInterval = 4000;
+            let pollingInterval = this._getOption("pollingInterval");
+            if (pollingInterval == null) {
+                pollingInterval = defaultOptions.pollingInterval;
+            }
+            this.#pollingInterval = pollingInterval;
         }
         _getSubscriber(sub) {
             const subscriber = super._getSubscriber(sub);
@@ -51549,7 +52452,7 @@ var PolygonIdSdk = (function (exports) {
             const chainId = et$2(Z$2.blockchainFromId(idTyped), Z$2.networkIdFromId(idTyped));
             const config = this.networkByChainId(chainId);
             const provider = new JsonRpcProvider(config.url);
-            const stateContract = new Contract(config.contractAddress, abi$2, this.provider);
+            const stateContract = new Contract(config.contractAddress, abi$2, provider);
             return { stateContract, provider };
         }
         networkByChainId(chainId) {
@@ -79391,16 +80294,8 @@ var PolygonIdSdk = (function (exports) {
             await this.updateIdentityState(did, true, newTreeState);
             return txId;
         }
-        /** {@inheritdoc IIdentityWallet.addBJJAuthCredential} */
-        async addBJJAuthCredential(did, oldTreeState, isOldStateGenesis, ethSigner, opts, prover // it will be needed in case of non ethereum identities
-        ) {
-            opts.seed = opts.seed ?? V$3(32);
-            opts.revocationOpts.nonce =
-                opts.revocationOpts.nonce ??
-                    (isOldStateGenesis
-                        ? 0
-                        : opts.revocationOpts.nonce ?? new DataView(V$3(12).buffer).getUint32(0));
-            const { authClaim, pubKey } = await this.createAuthCoreClaim(opts.revocationOpts.nonce ?? 0, opts.seed);
+        async getAuthBJJCredential(did, oldTreeState, { nonce, seed, id, type }) {
+            const { authClaim, pubKey } = await this.createAuthCoreClaim(nonce, seed);
             const { hi, hv } = authClaim.hiHv();
             await this._storage.mt.addToMerkleTree(did.string(), exports.MerkleTreeType.Claims, hi, hv);
             // Calculate current state after adding credential to merkle tree
@@ -79410,34 +80305,68 @@ var PolygonIdSdk = (function (exports) {
                 oldTreeState.revocationRoot.bigInt(),
                 oldTreeState.rootOfRoots.bigInt()
             ]);
-            let credential = await this.createAuthBJJCredential(did, pubKey, authClaim, currentState, opts.revocationOpts);
-            const txId = await this.transitState(did, oldTreeState, isOldStateGenesis, ethSigner, prover);
-            const { receipt, block } = await this._transactionService.getTransactionReceiptAndBlock(txId);
-            const credsWithIden3MTPProof = await this.generateIden3SparseMerkleTreeProof(did, [credential], txId, receipt?.blockNumber, block?.timestamp, undefined, {
-                revNonce: Number(authClaim.getRevocationNonce()),
-                subjectPosition: exports.SubjectPosition.None,
-                merklizedRootPosition: exports.MerklizedRootPosition.None,
-                updatable: false,
-                version: 0,
-                merklizeOpts: { documentLoader: cacheLoader() }
+            return this.createAuthBJJCredential(did, pubKey, authClaim, currentState, {
+                id,
+                type
             });
-            await this._credentialWallet.saveAll(credsWithIden3MTPProof);
-            await this._storage.identity.saveIdentity({
-                did: did.string(),
-                state: currentState,
-                isStatePublished: true,
-                isStateGenesis: false
+        }
+        /** {@inheritdoc IIdentityWallet.addBJJAuthCredential} */
+        async addBJJAuthCredential(did, oldTreeState, isOldStateGenesis, ethSigner, opts, prover // it will be needed in case of non ethereum identities
+        ) {
+            opts.seed = opts.seed ?? V$3(32);
+            opts.revocationOpts.nonce =
+                opts.revocationOpts.nonce ??
+                    (isOldStateGenesis
+                        ? 0
+                        : opts.revocationOpts.nonce ?? new DataView(V$3(12).buffer).getUint32(0));
+            const credential = await this.getAuthBJJCredential(did, oldTreeState, {
+                nonce: opts.revocationOpts.nonce,
+                seed: opts.seed,
+                id: opts.revocationOpts.id,
+                type: opts.revocationOpts.type
             });
-            const credRefreshed = await this._credentialWallet.findById(credential.id);
-            if (!credRefreshed) {
-                throw new Error('Credential not found in credential wallet');
+            const addMtpToCredAndPublishRevState = async () => {
+                const { receipt, block } = await this._transactionService.getTransactionReceiptAndBlock(txId);
+                const credsWithIden3MTPProof = await this.generateIden3SparseMerkleTreeProof(did, [credential], txId, receipt?.blockNumber, block?.timestamp, undefined, {
+                    revNonce: opts.revocationOpts.nonce ?? 0,
+                    subjectPosition: exports.SubjectPosition.None,
+                    merklizedRootPosition: exports.MerklizedRootPosition.None,
+                    updatable: false,
+                    version: 0,
+                    merklizeOpts: { documentLoader: cacheLoader() }
+                });
+                await this._credentialWallet.saveAll(credsWithIden3MTPProof);
+                await this.publishRevocationInfoByCredentialStatusType(did, opts.revocationOpts.type, {
+                    rhsUrl: opts.revocationOpts.id,
+                    onChain: opts.revocationOpts.onChain
+                });
+                return credsWithIden3MTPProof[0];
+            };
+            let txId = '';
+            let attempt = 2;
+            do {
+                try {
+                    txId = await this.transitState(did, oldTreeState, isOldStateGenesis, ethSigner, prover);
+                    break;
+                }
+                catch (err) {
+                    console.warn(`Error while transiting state, retrying state transition, attempt: ${attempt}`, err);
+                }
+            } while (--attempt);
+            if (!txId) {
+                const oldTransitStateInfoJson = JSON.stringify({
+                    claimsRoot: oldTreeState.claimsRoot.hex(),
+                    revocationRoot: oldTreeState.revocationRoot.hex(),
+                    rootOfRoots: oldTreeState.rootOfRoots.hex(),
+                    state: oldTreeState.state.hex(),
+                    isOldStateGenesis,
+                    credentialId: credential.id,
+                    did: did.string()
+                }, null, 2);
+                await this._credentialWallet.save(credential);
+                throw new Error(`Error publishing state, info to publish: ${oldTransitStateInfoJson}`);
             }
-            credential = credRefreshed;
-            await this.publishRevocationInfoByCredentialStatusType(did, opts.revocationOpts.type, {
-                rhsUrl: opts.revocationOpts.id,
-                onChain: opts.revocationOpts.onChain
-            });
-            return credential;
+            return addMtpToCredAndPublishRevState();
         }
     }