@0xpolygonid/js-sdk 1.16.1 → 1.17.2

package/dist/browser/esm/index.js

@@ -4,7 +4,7 @@ export { jsIden3Core as core };
 import { Path, Merklizer, getDocumentLoader } from '@iden3/js-jsonld-merklization';
 import * as jsJsonldMerklization from '@iden3/js-jsonld-merklization';
 export { jsJsonldMerklization as jsonLDMerklizer };
-import { base58ToBytes as base58ToBytes$2, base58FromBytes, Hex, PrivateKey, PublicKey, Signature as Signature$1, sha256 as sha256$3, poseidon, getRandomBytes, Poseidon } from '@iden3/js-crypto';
+import { base58ToBytes as base58ToBytes$2, base58FromBytes, Hex, PrivateKey, PublicKey, Signature as Signature$1, sha256 as sha256$4, poseidon, getRandomBytes, Poseidon } from '@iden3/js-crypto';
 import { Hash as Hash$2, Proof, verifyProof, rootFromProof, ZERO_HASH, swapEndianness as swapEndianness$1, Merkletree, InMemoryDB, str2Bytes, LocalStorageDB, IndexedDBStorage, testBit, NodeLeaf, NODE_TYPE_LEAF, hashElems } from '@iden3/js-merkletree';
 import { groth16 } from 'snarkjs';
 import { getCurveFromName } from 'ffjavascript';
@@ -89,6 +89,19 @@ class KMS {
         }
         return keyProvider.verify(data, signatureHex, keyId);
     }
+    /**
+     * get all keys by key type
+     *
+     * @param keyType - Key type
+     * @returns list of keys
+     */
+    list(keyType) {
+        const keyProvider = this._registry.get(keyType);
+        if (!keyProvider) {
+            throw new Error(`keyProvider not found for: ${keyType}`);
+        }
+        return keyProvider.list();
+    }
 }
 
 /**
@@ -112,6 +125,9 @@ class InMemoryPrivateKeyStore {
     constructor() {
         this._data = new Map();
     }
+    list() {
+        return Promise.resolve(Array.from(this._data).map(([alias, key]) => ({ alias, key })));
+    }
     async get(args) {
         const privateKey = this._data.get(args.alias);
         if (!privateKey) {
@@ -145,6 +161,20 @@ var KmsKeyType;
  * @implements implements AbstractPrivateKeyStore interface
  */
 class LocalStoragePrivateKeyStore {
+    /**
+     * get all keys
+     *
+     * @abstract
+     * @returns `Promise<{ alias: string; key: string }[]>`
+     */
+    list() {
+        const dataStr = localStorage.getItem(LocalStoragePrivateKeyStore.storageKey);
+        if (!dataStr) {
+            throw new Error('no key under given alias');
+        }
+        const data = JSON.parse(dataStr);
+        return data.map((i) => ({ alias: i.id, key: i.value }));
+    }
     /**
      * Gets key from the local storage
      *
@@ -266,6 +296,25 @@ function values(customStore = defaultGetStore()) {
         return eachCursor(store, (cursor) => items.push(cursor.value)).then(() => items);
     });
 }
+/**
+ * Get all entries in the store. Each entry is an array of `[key, value]`.
+ *
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+function entries(customStore = defaultGetStore()) {
+    return customStore('readonly', (store) => {
+        // Fast path for modern browsers
+        // (although, hopefully we'll get a simpler path some day)
+        if (store.getAll && store.getAllKeys) {
+            return Promise.all([
+                promisifyRequest(store.getAllKeys()),
+                promisifyRequest(store.getAll()),
+            ]).then(([keys, values]) => keys.map((key, i) => [key, values[i]]));
+        }
+        const items = [];
+        return customStore('readonly', (store) => eachCursor(store, (cursor) => items.push([cursor.key, cursor.value])).then(() => items));
+    });
+}
 
 /**
  * Allows storing keys in the indexed db storage of the browser
@@ -279,6 +328,16 @@ class IndexedDBPrivateKeyStore {
     constructor() {
         this._store = createStore(`${IndexedDBPrivateKeyStore.storageKey}-db`, IndexedDBPrivateKeyStore.storageKey);
     }
+    /**
+     * get all keys
+     *
+     * @abstract
+     * @returns `Promise<{ alias: string; key: string }[]>`
+     */
+    async list() {
+        const allEntries = await entries(this._store);
+        return allEntries.map(([alias, key]) => ({ alias, key: key.value }));
+    }
     /**
      * Gets key from the indexed db storage
      *
@@ -1743,6 +1802,14 @@ class BjjProvider {
         this.keyType = keyType;
         this.keyStore = keyStore;
     }
+    /**
+     * get all keys
+     * @returns list of keys
+     */
+    async list() {
+        const allKeysFromKeyStore = await this.keyStore.list();
+        return allKeysFromKeyStore.filter((key) => key.alias.startsWith(this.keyType));
+    }
     /**
      * generates a baby jub jub key from a seed phrase
      * @param {Uint8Array} seed - byte array seed
@@ -2062,19 +2129,19 @@ function split$2(lst, le = false) {
     }
     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));
@@ -2083,30 +2150,30 @@ const rotlBH$1 = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));
 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(Ah, Al, Bh, Bl) {
+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;
+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, add3L, add3H, add4L, add4H, add5H, add5L,
+    add: add$1, 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',
@@ -2129,9 +2196,9 @@ const [SHA512_Kh, SHA512_Kl] = /* @__PURE__ */ (() => u64.split([
     '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.
@@ -2182,43 +2249,43 @@ class SHA512 extends HashMD {
     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;
@@ -2227,38 +2294,38 @@ class SHA512 extends HashMD {
             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).
@@ -3587,7 +3654,7 @@ const ed25519Defaults = {
     // Base point (x, y) aka generator point
     Gx: BigInt('15112221349535400772501151409588531511454012693041857206046113283949847762202'),
     Gy: BigInt('46316835694926478169428394003475163141307993866256225615783033603165251855960'),
-    hash: sha512,
+    hash: sha512$1,
     randomBytes: randomBytes$1,
     adjustScalarBytes,
     // dom2
@@ -3631,6 +3698,14 @@ class Ed25519Provider {
         this.keyType = keyType;
         this._keyStore = _keyStore;
     }
+    /**
+     * get all keys
+     * @returns list of keys
+     */
+    async list() {
+        const allKeysFromKeyStore = await this._keyStore.list();
+        return allKeysFromKeyStore.filter((key) => key.alias.startsWith(this.keyType));
+    }
     /**
      * generates a ed25519 key from a seed phrase
      * @param {Uint8Array} seed - byte array seed
@@ -3796,7 +3871,7 @@ let SHA256$1 = class SHA256 extends HashMD {
  * 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
@@ -4899,7 +4974,7 @@ const secp256k1$1 = createCurve$1({
             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);
@@ -6178,7 +6253,7 @@ const p256 = createCurve$1({
     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
@@ -6956,9 +7031,9 @@ function leftpad(data, size = 64) {
   return '0'.repeat(size - data.length) + data;
 }
 
-function sha256$1(payload) {
+function sha256$2(payload) {
   const data = typeof payload === 'string' ? fromString(payload) : payload;
-  return sha256$2(data);
+  return sha256$3(data);
 }
 const keccak = keccak_256$1;
 function toEthereumAddress(hexPublicKey) {
@@ -6991,7 +7066,7 @@ function ES256KSigner(privateKey, recoverable = false) {
 
   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)),
@@ -7007,10 +7082,10 @@ function publicKeyToAddress$1(publicKey, otherAddress) {
   // 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));
@@ -7018,7 +7093,7 @@ function publicKeyToAddress$1(publicKey, otherAddress) {
 
 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, '');
 }
@@ -7083,7 +7158,7 @@ function toSignatureObject2(signature, recoverable = false) {
   };
 }
 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 => {
@@ -7100,7 +7175,7 @@ function verifyES256(data, signature, authenticators) {
   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;
@@ -7141,7 +7216,7 @@ function verifyRecoverableES256K(data, signature, authenticators) {
     });
   }
 
-  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);
@@ -7270,6 +7345,14 @@ class Sec256k1Provider {
         this.keyType = keyType;
         this._keyStore = keyStore;
     }
+    /**
+     * get all keys
+     * @returns list of keys
+     */
+    async list() {
+        const allKeysFromKeyStore = await this._keyStore.list();
+        return allKeysFromKeyStore.filter((key) => key.alias.startsWith(this.keyType));
+    }
     /**
      * generates a baby jub jub key from a seed phrase
      * @param {Uint8Array} seed - byte array seed
@@ -7324,7 +7407,7 @@ class Sec256k1Provider {
      */
     async verify(message, signatureHex, keyId) {
         const publicKeyHex = await this.publicKey(keyId);
-        return secp256k1$1.verify(signatureHex, sha256$3(message), publicKeyHex);
+        return secp256k1$1.verify(signatureHex, sha256$4(message), publicKeyHex);
     }
     async privateKey(keyId) {
         return this._keyStore.get({ alias: keyId.id });
@@ -29949,7 +30032,7 @@ const cacheLoader = (opts) => {
 /**
  *  The current version of Ethers.
  */
-const version = "6.8.0";
+const version = "6.13.1";
 
 /**
  *  Property helper functions.
@@ -30055,7 +30138,7 @@ function stringify(value) {
  *  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.
  *
@@ -30081,13 +30164,13 @@ function isCallException(error) {
 }
 /**
  *  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;
@@ -30169,7 +30252,7 @@ function assertArgumentCount(count, expectedCount, message) {
         count: count,
         expectedCount: expectedCount
     });
-    assert(count <= expectedCount, "too many arguemnts" + message, "UNEXPECTED_ARGUMENT", {
+    assert(count <= expectedCount, "too many arguments" + message, "UNEXPECTED_ARGUMENT", {
         count: count,
         expectedCount: expectedCount
     });
@@ -30239,7 +30322,7 @@ function _getBytes(value, name, copy) {
         }
         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++) {
@@ -30548,7 +30631,7 @@ function toBeHex(_value, _width) {
     }
     else {
         const width = getNumber(_width, "width");
-        assert(width * 2 >= result.length, `value exceeds width (${width} bits)`, "NUMERIC_FAULT", {
+        assert(width * 2 >= result.length, `value exceeds width (${width} bytes)`, "NUMERIC_FAULT", {
             operation: "toBeHex",
             fault: "overflow",
             value: _value
@@ -30617,12 +30700,20 @@ const BN_58 = BigInt(58);
  *  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;
 }
 
@@ -30839,6 +30930,7 @@ function getUtf8CodePoints(_bytes, onError) {
  *  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);
@@ -30893,9 +30985,9 @@ function toUtf8String(bytes, onError) {
     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(_signal == null || !_signal.cancelled, "request cancelled before sending", "CANCELLED");
         const protocol = req.url.split(":")[0].toLowerCase();
         assert(protocol === "http" || protocol === "https", `unsupported protocol ${protocol}`, "UNSUPPORTED_OPERATION", {
             info: { protocol },
@@ -30904,19 +30996,36 @@ function createGetUrl(options) {
         assert(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;
@@ -30934,7 +31043,7 @@ function createGetUrl(options) {
 
 /**
  *  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
@@ -30942,10 +31051,10 @@ function createGetUrl(options) {
  *  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.
  *
@@ -31069,7 +31178,7 @@ class FetchRequest {
     #throttle;
     #getUrlFunc;
     /**
-     *  The fetch URI to requrest.
+     *  The fetch URL to request.
      */
     get url() { return this.#url; }
     set url(url) {
@@ -31083,15 +31192,15 @@ class FetchRequest {
      *  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() {
@@ -31151,7 +31260,7 @@ class FetchRequest {
      *  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.
@@ -31243,7 +31352,7 @@ class FetchRequest {
         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; }
@@ -31450,7 +31559,7 @@ class FetchRequest {
      *  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:
@@ -31502,6 +31611,7 @@ class FetchRequest {
         clone.#preflight = this.#preflight;
         clone.#process = this.#process;
         clone.#retry = this.#retry;
+        clone.#throttle = Object.assign({}, this.#throttle);
         clone.#getUrlFunc = this.#getUrlFunc;
         return clone;
     }
@@ -31588,7 +31698,7 @@ class FetchRequest {
     }
 }
 /**
- *  The response for a FetchREquest.
+ *  The response for a FetchRequest.
  */
 class FetchResponse {
     #statusCode;
@@ -31718,7 +31828,7 @@ class FetchResponse {
         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);
@@ -31744,8 +31854,23 @@ class FetchResponse {
         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(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}`
+            }
         });
     }
 }
@@ -31892,11 +32017,38 @@ const Padding = new Uint8Array(WordSize);
 // - `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
@@ -31905,6 +32057,9 @@ function throwError(name, error) {
  *  @_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
@@ -31937,20 +32092,22 @@ class Result extends Array {
             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
@@ -31985,39 +32142,44 @@ class Result extends Array {
                 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(name != null, "value at index ${ index } unnamed", "UNSUPPORTED_OPERATION", {
+    toObject(deep) {
+        const names = getNames(this);
+        return names.reduce((accum, name, index) => {
+            assert(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);
         }, {});
     }
     /**
@@ -32045,10 +32207,11 @@ class Result extends Array {
         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);
     }
@@ -32056,6 +32219,7 @@ class Result extends Array {
      *  @_ignore
      */
     filter(callback, thisArg) {
+        const _names = getNames(this);
         const result = [], names = [];
         for (let i = 0; i < this.length; i++) {
             const item = this[i];
@@ -32064,7 +32228,7 @@ class Result extends Array {
             }
             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);
@@ -32092,7 +32256,7 @@ class Result extends Array {
      *  accessible by name.
      */
     getValue(name) {
-        const index = this.#names.indexOf(name);
+        const index = getNames(this).indexOf(name);
         if (index === -1) {
             return undefined;
         }
@@ -32202,15 +32366,35 @@ class Reader {
     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(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) {
@@ -32229,11 +32413,14 @@ class Reader {
     }
     // 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);
@@ -32649,7 +32836,7 @@ class SHA256 extends SHA2 {
  * 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);
@@ -32668,12 +32855,225 @@ function split$1(lst, le = false) {
     }
     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(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, 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.
@@ -32912,6 +33312,43 @@ keccak256.register = function (func) {
 };
 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.
@@ -34727,7 +35164,7 @@ const secp256k1 = createCurve({
             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);
@@ -36481,7 +36918,7 @@ function id(value) {
     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
@@ -36762,7 +37199,7 @@ function compare_arrays(a, b) {
 	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
@@ -36978,6 +37415,7 @@ function init() {
 	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
@@ -37000,13 +37438,20 @@ function init() {
 
 	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}]`;
@@ -37044,6 +37489,7 @@ function init() {
 	});
 
 	// 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 = [];
@@ -37055,34 +37501,37 @@ function init() {
 				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);
@@ -37135,7 +37584,7 @@ function bidi_qq(s) {
 
 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) {
@@ -37169,13 +37618,18 @@ function check_fenced(cps) {
 // 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++) {
@@ -37340,7 +37794,7 @@ function flatten(split) {
 			// 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);
@@ -37594,12 +38048,11 @@ function namehash(name) {
  *  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;
@@ -37671,6 +38124,15 @@ const BN_27 = BigInt(27);
 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;
@@ -37708,6 +38170,13 @@ function formatNumber(_value, name) {
 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);
@@ -37746,18 +38215,18 @@ function _parseLegacy(data) {
             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) {
@@ -37820,14 +38289,12 @@ function _parseEipSignature(tx, fields) {
 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]),
@@ -37839,21 +38306,21 @@ function _parseEip1559(data) {
     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"));
@@ -37880,20 +38347,20 @@ function _parseEip2930(data) {
     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"));
@@ -37902,6 +38369,96 @@ function _serializeEip2930(tx, sig) {
     }
     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
@@ -37928,6 +38485,10 @@ class Transaction {
     #chainId;
     #sig;
     #accessList;
+    #maxFeePerBlobGas;
+    #blobVersionedHashes;
+    #kzg;
+    #blobs;
     /**
      *  The transaction type.
      *
@@ -37954,6 +38515,11 @@ class Transaction {
             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);
         }
@@ -37966,6 +38532,7 @@ class Transaction {
             case 0: return "legacy";
             case 1: return "eip-2930";
             case 2: return "eip-1559";
+            case 3: return "eip-4844";
         }
         return null;
     }
@@ -37973,7 +38540,13 @@ class Transaction {
      *  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);
     }
@@ -38010,7 +38583,7 @@ class Transaction {
     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;
@@ -38027,7 +38600,7 @@ class Transaction {
     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;
@@ -38071,7 +38644,9 @@ class Transaction {
     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;
@@ -38081,6 +38656,122 @@ class Transaction {
     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(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.
      */
@@ -38088,15 +38779,19 @@ class Transaction {
         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``.
@@ -38105,7 +38800,7 @@ class Transaction {
         if (this.signature == null) {
             return null;
         }
-        return keccak256(this.serialized);
+        return keccak256(this.#getSerialized(true, false));
     }
     /**
      *  The pre-image hash of this transaction.
@@ -38141,9 +38836,23 @@ class Transaction {
      *  transaction are non-null.
      */
     isSigned() {
-        //isSigned(): this is SignedTransaction {
         return this.signature != null;
     }
+    #getSerialized(signed, sidecar) {
+        assert(!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(false, "unsupported transaction type", "UNSUPPORTED_OPERATION", { operation: ".serialized" });
+    }
     /**
      *  The serialized transaction.
      *
@@ -38151,16 +38860,7 @@ class Transaction {
      *  use [[unsignedSerialized]].
      */
     get serialized() {
-        assert(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(false, "unsupported transaction type", "UNSUPPORTED_OPERATION", { operation: ".serialized" });
+        return this.#getSerialized(true, true);
     }
     /**
      *  The transaction pre-image.
@@ -38169,22 +38869,20 @@ class Transaction {
      *  authorize this transaction.
      */
     get unsignedSerialized() {
-        switch (this.inferType()) {
-            case 0:
-                return _serializeLegacy(this);
-            case 1:
-                return _serializeEip2930(this);
-            case 2:
-                return _serializeEip1559(this);
-        }
-        assert(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
@@ -38195,6 +38893,7 @@ class Transaction {
         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");
         //}
@@ -38225,10 +38924,14 @@ class Transaction {
                 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();
@@ -38264,6 +38967,16 @@ class Transaction {
     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.
      */
@@ -38312,6 +39025,7 @@ class Transaction {
             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(false, "unsupported transaction type", "UNSUPPORTED_OPERATION", { operation: "from" });
         }
@@ -38337,6 +39051,9 @@ class Transaction {
         if (tx.maxFeePerGas != null) {
             result.maxFeePerGas = tx.maxFeePerGas;
         }
+        if (tx.maxFeePerBlobGas != null) {
+            result.maxFeePerBlobGas = tx.maxFeePerBlobGas;
+        }
         if (tx.data != null) {
             result.data = tx.data;
         }
@@ -38352,12 +39069,24 @@ class Transaction {
         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;
@@ -38424,11 +39153,11 @@ const domainChecks = {
 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) {
@@ -38470,6 +39199,23 @@ function getBaseEncoder(type) {
 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.
@@ -38504,8 +39250,7 @@ class TypedDataEncoder {
      *  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
@@ -38514,26 +39259,39 @@ class TypedDataEncoder {
         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);
@@ -38541,12 +39299,12 @@ class TypedDataEncoder {
         }
         // 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)) {
@@ -38589,12 +39347,12 @@ class TypedDataEncoder {
             }
         }
         // 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);
@@ -38664,10 +39422,10 @@ class TypedDataEncoder {
             }
         }
         // 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];
@@ -38806,6 +39564,8 @@ class TypedDataEncoder {
             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;
@@ -38856,10 +39616,10 @@ function setify(items) {
     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(" "));
@@ -38913,7 +39673,8 @@ class TokenString {
     // 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;
     }
@@ -39145,7 +39906,7 @@ function consumeGas(tokens) {
 }
 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]*)\]$/);
@@ -39293,9 +40054,6 @@ class ParamType {
         }
         else {
             if (this.isTuple()) {
-                if (format !== "sighash") {
-                    result += this.type;
-                }
                 result += "(" + this.components.map((comp) => comp.format(format)).join((format === "full") ? ", " : ",") + ")";
             }
             else {
@@ -39428,7 +40186,7 @@ class ParamType {
      *  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) {
@@ -39837,7 +40595,9 @@ class ConstructorFragment extends Fragment {
             });
         }
         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()}`);
         }
@@ -40183,6 +40943,7 @@ PanicReasons$1.set(0x51, "UNINITIALIZED_FUNCTION_CALL");
 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;
@@ -40319,7 +41080,11 @@ class AbiCoder {
     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]].
@@ -40581,7 +41346,7 @@ class Interface {
                 frags.push(Fragment.from(a));
             }
             catch (error) {
-                console.log("EE", error);
+                console.log(`[Warning] Invalid Fragment ${JSON.stringify(a)}:`, error.message);
             }
         }
         defineProperties(this, {
@@ -41422,7 +42187,11 @@ getSelector(fragment: ErrorFragment | FunctionFragment): string {
         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"));
         }
@@ -41519,7 +42288,7 @@ function copyRequest(req) {
     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;
@@ -41545,6 +42314,20 @@ function copyRequest(req) {
     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;
 }
 /**
@@ -41578,6 +42361,11 @@ class Block {
      *  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.
      *
@@ -41603,11 +42391,35 @@ class Block {
      *  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.
      */
@@ -41640,13 +42452,19 @@ class Block {
             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,
         });
     }
     /**
@@ -41685,7 +42503,7 @@ class Block {
      *  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),
@@ -41693,7 +42511,10 @@ class Block {
             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,
         };
     }
@@ -41951,7 +42772,7 @@ class TransactionReceipt {
      */
     provider;
     /**
-     *  The address the transaction was send to.
+     *  The address the transaction was sent to.
      */
     to;
     /**
@@ -41996,6 +42817,10 @@ class TransactionReceipt {
      *  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``.
@@ -42012,6 +42837,10 @@ class TransactionReceipt {
      *  fee is protocol-enforced.
      */
     gasPrice;
+    /**
+     *  The price paid per BLOB in gas. See [[link-eip-4844]].
+     */
+    blobGasPrice;
     /**
      *  The [[link-eip-2718]] transaction type.
      */
@@ -42059,7 +42888,9 @@ class TransactionReceipt {
             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,
@@ -42084,6 +42915,8 @@ class TransactionReceipt {
             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
         };
@@ -42252,6 +43085,10 @@ class TransactionResponse {
      *  to charge the sender.
      */
     maxFeePerGas;
+    /**
+     *  The [[link-eip-4844]] max fee per BLOb gas.
+     */
+    maxFeePerBlobGas;
     /**
      *  The data.
      */
@@ -42274,6 +43111,10 @@ class TransactionResponse {
      *  support it, otherwise ``null``.
      */
     accessList;
+    /**
+     *  The [[link-eip-4844]] BLOb versioned hashes.
+     */
+    blobVersionedHashes;
     #startBlock;
     /**
      *  @_ignore:
@@ -42294,19 +43135,22 @@ class TransactionResponse {
         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),
@@ -42314,6 +43158,7 @@ class TransactionResponse {
             hash,
             maxFeePerGas: toJson(this.maxFeePerGas),
             maxPriorityFeePerGas: toJson(this.maxPriorityFeePerGas),
+            maxFeePerBlobGas: toJson(this.maxFeePerBlobGas),
             nonce, signature, to, index, type,
             value: toJson(this.value),
         };
@@ -42595,6 +43440,13 @@ class TransactionResponse {
     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.
@@ -42754,8 +43606,8 @@ class ContractTransactionResponse extends TransactionResponse {
      *  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;
         }
@@ -43814,13 +44666,13 @@ class MulticoinProviderPlugin {
         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");
@@ -43900,7 +44752,7 @@ class EnsResolver {
                 info: { funcName }
             });
             params = [
-                dnsEncode(this.name),
+                dnsEncode(this.name, 255),
                 iface.encodeFunctionData(fragment, params)
             ];
             funcName = "resolve(bytes,bytes)";
@@ -44255,8 +45107,11 @@ function allowNull(format, nullValue) {
         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");
         }
@@ -44331,15 +45186,23 @@ function formatLog(value) {
 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);
@@ -44374,6 +45237,7 @@ const _formatTransactionReceipt = object({
     index: getNumber,
     root: allowNull(hexlify),
     gasUsed: getBigInt,
+    blobGasUsed: allowNull(getBigInt, null),
     logsBloom: allowNull(formatData),
     blockHash: formatHash,
     hash: formatHash,
@@ -44382,6 +45246,7 @@ const _formatTransactionReceipt = object({
     //confirmations: allowNull(getNumber, null),
     cumulativeGasUsed: getBigInt,
     effectiveGasPrice: allowNull(getBigInt),
+    blobGasPrice: allowNull(getBigInt, null),
     status: allowNull(getNumber),
     type: allowNull(getNumber, 0)
 }, {
@@ -44400,6 +45265,8 @@ function formatTransactionResponse(value) {
     }
     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;
@@ -44407,15 +45274,16 @@ function formatTransactionResponse(value) {
             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,
@@ -44425,7 +45293,8 @@ function formatTransactionResponse(value) {
         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) {
@@ -44951,23 +45820,6 @@ function getGasStationPlugin(url) {
         }
     });
 }
-// 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() {
@@ -45003,23 +45855,30 @@ function injectCommonNetworks() {
     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: [
@@ -45028,11 +45887,10 @@ function injectCommonNetworks() {
     });
     registerEth("optimism", 10, {
         ensNetwork: 1,
-        plugins: [
-            getPriorityFeePlugin(BigInt("1000000"))
-        ]
+        plugins: []
     });
     registerEth("optimism-goerli", 420, {});
+    registerEth("optimism-sepolia", 11155420, {});
     registerEth("xdai", 100, { ensNetwork: 1 });
 }
 
@@ -45166,6 +46024,34 @@ class OnBlockSubscriber {
     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:
  *
@@ -45364,10 +46250,12 @@ async function getSubscription(_event, provider) {
     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 };
             }
         }
@@ -45665,10 +46553,10 @@ class AbstractProvider {
         switch (blockTag) {
             case "earliest":
                 return "0x0";
+            case "finalized":
             case "latest":
             case "pending":
             case "safe":
-            case "finalized":
                 return blockTag;
         }
         if (isHexString(blockTag)) {
@@ -45772,7 +46660,7 @@ class AbstractProvider {
         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.
      */
@@ -45812,16 +46700,19 @@ class AbstractProvider {
         // 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();
         }
@@ -45851,12 +46742,20 @@ class AbstractProvider {
     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;
@@ -45867,7 +46766,7 @@ class AbstractProvider {
             // 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);
@@ -46245,6 +47144,9 @@ class AbstractProvider {
                 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":
@@ -46795,8 +47697,8 @@ class AbstractSigner {
                     });
                 }
             }
-            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;
@@ -46926,6 +47828,9 @@ class FilterIdSubscriber {
         if (filterIdPromise) {
             this.#filterIdPromise = null;
             filterIdPromise.then((filterId) => {
+                if (this.#provider.destroyed) {
+                    return;
+                }
                 this.#provider.send("eth_uninstallFilter", [filterId]);
             });
         }
@@ -47123,12 +48028,45 @@ class JsonRpcSigner extends AbstractSigner {
         // 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);
@@ -47201,11 +48139,12 @@ class JsonRpcApiProvider extends AbstractProvider {
     #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;
@@ -47276,6 +48215,7 @@ class JsonRpcApiProvider extends AbstractProvider {
         this.#payloads = [];
         this.#drainTimer = null;
         this.#network = null;
+        this.#pendingDetectNetwork = null;
         {
             let resolve = null;
             const promise = new Promise((_resolve) => {
@@ -47283,9 +48223,15 @@ class JsonRpcApiProvider extends AbstractProvider {
             });
             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;
         }
@@ -47318,7 +48264,7 @@ class JsonRpcApiProvider extends AbstractProvider {
         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) {
@@ -47346,30 +48292,56 @@ class JsonRpcApiProvider extends AbstractProvider {
     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
@@ -47471,6 +48443,14 @@ class JsonRpcApiProvider extends AbstractProvider {
         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;
     }
     /**
@@ -47485,6 +48465,8 @@ class JsonRpcApiProvider extends AbstractProvider {
                 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",
@@ -47735,7 +48717,11 @@ class JsonRpcApiPollingProvider extends JsonRpcApiProvider {
     #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);
@@ -51327,7 +52313,7 @@ class EthStateStorage {
         const chainId = getChainId(DID.blockchainFromId(idTyped), DID.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) {
@@ -55345,10 +56331,10 @@ class MessageHandler {
             return null;
         }
         let packerParams = {};
-        const senderDID = context?.senderDID;
-        if (unpackedMediaType === MediaType.ZKPMessage && senderDID) {
+        const senderDid = context?.senderDid;
+        if (unpackedMediaType === MediaType.ZKPMessage && senderDid) {
             packerParams = {
-                senderDID,
+                senderDID: senderDid,
                 provingMethodAlg: proving.provingMethodGroth16AuthV2Instance.methodAlg
             };
             return this._params.packageManager.packMessage(unpackedMediaType, response, packerParams);
@@ -55966,7 +56952,7 @@ class RevocationStatusHandler extends AbstractMessageHandler {
         this._identityWallet = _identityWallet;
     }
     handle(message, context) {
-        if (!context.did) {
+        if (!context.senderDid) {
             throw new Error('DID is required');
         }
         if (!context.mediaType) {
@@ -56008,7 +56994,7 @@ class RevocationStatusHandler extends AbstractMessageHandler {
             type: PROTOCOL_MESSAGE_TYPE.REVOCATION_STATUS_RESPONSE_MESSAGE_TYPE,
             thid: rsRequest.thid ?? guid,
             body: revStatus,
-            from: context.did.string(),
+            from: context.senderDid.string(),
             to: rsRequest.from
         };
         return response;
@@ -56038,7 +57024,7 @@ class RevocationStatusHandler extends AbstractMessageHandler {
         }
         const rsRequest = await this.parseRevocationStatusRequest(request);
         const response = await this.handleRevocationStatusRequestMessage(rsRequest, {
-            did,
+            senderDid: did,
             mediaType: opts.mediaType,
             packerOptions: opts.packerOptions,
             treeState: opts.treeState
@@ -56169,7 +57155,8 @@ class CredentialProposalHandler extends AbstractMessageHandler {
                         }
                     },
                     type: cred.type,
-                    context: cred.context
+                    context: cred.context,
+                    allowedIssuers: [proposalRequest.to]
                 });
             }
             catch (e) {
@@ -57849,7 +58836,7 @@ class IdentityWallet {
      * {@inheritDoc IIdentityWallet.createIdentity}
      */
     async createIdentity(opts) {
-        const tmpIdentifier = opts.seed ? v5(Hex.encode(sha256$3(opts.seed)), nil) : v4();
+        const tmpIdentifier = opts.seed ? v5(Hex.encode(sha256$4(opts.seed)), nil) : v4();
         opts.seed = opts.seed ?? getRandomBytes(32);
         await this._storage.mt.createIdentityMerkleTrees(tmpIdentifier);
         const revNonce = opts.revocationOpts.nonce ?? 0;
@@ -57931,7 +58918,7 @@ class IdentityWallet {
         opts.createBjjCredential = opts.createBjjCredential ?? true;
         let credential;
         const ethSigner = opts.ethSigner;
-        if (!ethSigner) {
+        if (opts.createBjjCredential && !ethSigner) {
             throw new Error('Ethereum signer is required to create Ethereum identities in order to transit state');
         }
         const currentState = ZERO_HASH; // In Ethereum identities we don't have an initial state with the auth credential
@@ -57946,7 +58933,7 @@ class IdentityWallet {
             isStatePublished: false,
             isStateGenesis: true
         });
-        if (opts.createBjjCredential) {
+        if (opts.createBjjCredential && ethSigner) {
             // Old tree state genesis state
             const oldTreeState = {
                 revocationRoot: ZERO_HASH,
@@ -58399,16 +59386,8 @@ class IdentityWallet {
         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 ?? getRandomBytes(32);
-        opts.revocationOpts.nonce =
-            opts.revocationOpts.nonce ??
-                (isOldStateGenesis
-                    ? 0
-                    : opts.revocationOpts.nonce ?? new DataView(getRandomBytes(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(), MerkleTreeType.Claims, hi, hv);
         // Calculate current state after adding credential to merkle tree
@@ -58418,28 +59397,68 @@ class IdentityWallet {
             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: SubjectPosition.None,
-            merklizedRootPosition: MerklizedRootPosition.None,
-            updatable: false,
-            version: 0,
-            merklizeOpts: { documentLoader: cacheLoader() }
+        return this.createAuthBJJCredential(did, pubKey, authClaim, currentState, {
+            id,
+            type
         });
-        await this._credentialWallet.saveAll(credsWithIden3MTPProof);
-        const credRefreshed = await this._credentialWallet.findById(credential.id);
-        if (!credRefreshed) {
-            throw new Error('Credential not found in credential wallet');
-        }
-        credential = credRefreshed;
-        await this.publishRevocationInfoByCredentialStatusType(did, opts.revocationOpts.type, {
-            rhsUrl: opts.revocationOpts.id,
-            onChain: opts.revocationOpts.onChain
+    }
+    /** {@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 ?? getRandomBytes(32);
+        opts.revocationOpts.nonce =
+            opts.revocationOpts.nonce ??
+                (isOldStateGenesis
+                    ? 0
+                    : opts.revocationOpts.nonce ?? new DataView(getRandomBytes(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
         });
-        return credential;
+        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: SubjectPosition.None,
+                merklizedRootPosition: 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}`);
+        }
+        return addMtpToCredAndPublishRevState();
     }
 }