@sentio/sdk-bundle 4.0.1-rc.4 → 4.0.1-rc.5

package/dist/{decode-worker-7st2rUPr.js → decode-worker-C83IoThX.js}

@@ -3,383 +3,121 @@ import { F as Code, P as ConnectError, dn as EthCallParamSchema, oi as create, r
 import * as nc from "node:crypto";
 import { Piscina } from "piscina";
 
-//#region ../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/_assert.js
-function number(n) {
-	if (!Number.isSafeInteger(n) || n < 0) throw new Error(`Wrong positive integer: ${n}`);
-}
-function bytes(b, ...lengths) {
-	if (!(b instanceof Uint8Array)) throw new Error("Expected Uint8Array");
-	if (lengths.length > 0 && !lengths.includes(b.length)) throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
-}
-function hash(hash) {
-	if (typeof hash !== "function" || typeof hash.create !== "function") throw new Error("Hash should be wrapped by utils.wrapConstructor");
-	number(hash.outputLen);
-	number(hash.blockLen);
-}
-function exists(instance, checkFinished = true) {
-	if (instance.destroyed) throw new Error("Hash instance has been destroyed");
-	if (checkFinished && instance.finished) throw new Error("Hash#digest() has already been called");
-}
-function output(out, instance) {
-	bytes(out);
-	const min = instance.outputLen;
-	if (out.length < min) throw new Error(`digestInto() expects output buffer of length at least ${min}`);
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/_u64.js
-const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
-const _32n = /* @__PURE__ */ BigInt(32);
-function fromBig(n, le = false) {
-	if (le) return {
-		h: Number(n & U32_MASK64),
-		l: Number(n >> _32n & U32_MASK64)
-	};
-	return {
-		h: Number(n >> _32n & U32_MASK64) | 0,
-		l: Number(n & U32_MASK64) | 0
+//#region src/eth/ethers-format.ts
+function allowNull(format, nullValue) {
+	return function(value) {
+		if (value == null) return nullValue;
+		return format(value);
 	};
 }
-function split(lst, le = false) {
-	let Ah = new Uint32Array(lst.length);
-	let Al = new Uint32Array(lst.length);
-	for (let i = 0; i < lst.length; i++) {
-		const { h, l } = fromBig(lst[i], le);
-		[Ah[i], Al[i]] = [h, l];
-	}
-	return [Ah, Al];
+function arrayOf(format, allowNull) {
+	return (array) => {
+		if (allowNull && array == null) return null;
+		if (!Array.isArray(array)) throw new Error("not an array");
+		return array.map((i) => format(i));
+	};
 }
-const rotlSH = (h, l, s) => h << s | l >>> 32 - s;
-const rotlSL = (h, l, s) => l << s | h >>> 32 - s;
-const rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
-const rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
 
 //#endregion
-//#region ../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/cryptoNode.js
-const crypto$1 = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : void 0;
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/_version.js
+/**
+*  The current version of Ethers.
+*/
+const version = "6.17.0";
 
 //#endregion
-//#region ../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/utils.js
-/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-const u8a = (a) => a instanceof Uint8Array;
-const u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
-const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-const rotr = (word, shift) => word << 32 - shift | word >>> shift;
-const isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
-if (!isLE) throw new Error("Non little-endian hardware is not supported");
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/utils/properties.js
 /**
-* @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
+*  Property helper functions.
+*
+*  @_subsection api/utils:Properties  [about-properties]
 */
-function utf8ToBytes(str) {
-	if (typeof str !== "string") throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
-	return new Uint8Array(new TextEncoder().encode(str));
+function checkType(value, type, name) {
+	const types = type.split("|").map((t) => t.trim());
+	for (let i = 0; i < types.length; i++) switch (type) {
+		case "any": return;
+		case "bigint":
+		case "boolean":
+		case "number":
+		case "string": if (typeof value === type) return;
+	}
+	const error = /* @__PURE__ */ new Error(`invalid value for type ${type}`);
+	error.code = "INVALID_ARGUMENT";
+	error.argument = `value.${name}`;
+	error.value = value;
+	throw error;
 }
 /**
-* Normalizes (non-hex) string or Uint8Array to Uint8Array.
-* Warning: when Uint8Array is passed, it would NOT get copied.
-* Keep in mind for future mutable operations.
+*  Resolves to a new object that is a copy of %%value%%, but with all
+*  values resolved.
 */
-function toBytes(data) {
-	if (typeof data === "string") data = utf8ToBytes(data);
-	if (!u8a(data)) throw new Error(`expected Uint8Array, got ${typeof data}`);
-	return data;
+async function resolveProperties(value) {
+	const keys = Object.keys(value);
+	return (await Promise.all(keys.map((k) => Promise.resolve(value[k])))).reduce((accum, v, index) => {
+		accum[keys[index]] = v;
+		return accum;
+	}, {});
 }
 /**
-* Copies several Uint8Arrays into one.
+*  Assigns the %%values%% to %%target%% as read-only values.
+*
+*  It %%types%% is specified, the values are checked.
 */
-function concatBytes(...arrays) {
-	const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));
-	let pad = 0;
-	arrays.forEach((a) => {
-		if (!u8a(a)) throw new Error("Uint8Array expected");
-		r.set(a, pad);
-		pad += a.length;
-	});
-	return r;
-}
-var Hash = class {
-	clone() {
-		return this._cloneInto();
+function defineProperties(target, values, types) {
+	for (let key in values) {
+		let value = values[key];
+		const type = types ? types[key] : null;
+		if (type) checkType(value, type, key);
+		Object.defineProperty(target, key, {
+			enumerable: true,
+			value,
+			writable: false
+		});
 	}
-};
-const toStr = {}.toString;
-function wrapConstructor(hashCons) {
-	const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
-	const tmp = hashCons();
-	hashC.outputLen = tmp.outputLen;
-	hashC.blockLen = tmp.blockLen;
-	hashC.create = () => hashCons();
-	return hashC;
-}
-/**
-* Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.
-*/
-function randomBytes(bytesLength = 32) {
-	if (crypto$1 && typeof crypto$1.getRandomValues === "function") return crypto$1.getRandomValues(new Uint8Array(bytesLength));
-	throw new Error("crypto.getRandomValues must be defined");
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/sha3.js
-const [SHA3_PI, SHA3_ROTL, _SHA3_IOTA] = [
-	[],
-	[],
-	[]
-];
-const _0n = /* @__PURE__ */ BigInt(0);
-const _1n = /* @__PURE__ */ BigInt(1);
-const _2n = /* @__PURE__ */ BigInt(2);
-const _7n = /* @__PURE__ */ BigInt(7);
-const _256n = /* @__PURE__ */ BigInt(256);
-const _0x71n = /* @__PURE__ */ BigInt(113);
-for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
-	[x, y] = [y, (2 * x + 3 * y) % 5];
-	SHA3_PI.push(2 * (5 * y + x));
-	SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
-	let t = _0n;
-	for (let j = 0; j < 7; j++) {
-		R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
-		if (R & _2n) t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/utils/errors.js
+/**
+*  All errors in ethers include properties to ensure they are both
+*  human-readable (i.e. ``.message``) and machine-readable (i.e. ``.code``).
+*
+*  The [[isError]] function can be used to check the error ``code`` and
+*  provide a type guard for the properties present on that error interface.
+*
+*  @_section: api/utils/errors:Errors  [about-errors]
+*/
+function stringify(value, seen) {
+	if (value == null) return "null";
+	if (seen == null) seen = /* @__PURE__ */ new Set();
+	if (typeof value === "object") {
+		if (seen.has(value)) return "[Circular]";
+		seen.add(value);
 	}
-	_SHA3_IOTA.push(t);
-}
-const [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);
-const rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
-const rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
-function keccakP(s, rounds = 24) {
-	const B = /* @__PURE__ */ new Uint32Array(10);
-	for (let round = 24 - rounds; round < 24; round++) {
-		for (let x = 0; x < 10; x++) B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
-		for (let x = 0; x < 10; x += 2) {
-			const idx1 = (x + 8) % 10;
-			const idx0 = (x + 2) % 10;
-			const B0 = B[idx0];
-			const B1 = B[idx0 + 1];
-			const Th = rotlH(B0, B1, 1) ^ B[idx1];
-			const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
-			for (let y = 0; y < 50; y += 10) {
-				s[x + y] ^= Th;
-				s[x + y + 1] ^= Tl;
-			}
-		}
-		let curH = s[2];
-		let curL = s[3];
-		for (let t = 0; t < 24; t++) {
-			const shift = SHA3_ROTL[t];
-			const Th = rotlH(curH, curL, shift);
-			const Tl = rotlL(curH, curL, shift);
-			const PI = SHA3_PI[t];
-			curH = s[PI];
-			curL = s[PI + 1];
-			s[PI] = Th;
-			s[PI + 1] = Tl;
+	if (Array.isArray(value)) return "[ " + value.map((v) => stringify(v, seen)).join(", ") + " ]";
+	if (value instanceof Uint8Array) {
+		const HEX = "0123456789abcdef";
+		let result = "0x";
+		for (let i = 0; i < value.length; i++) {
+			result += HEX[value[i] >> 4];
+			result += HEX[value[i] & 15];
 		}
-		for (let y = 0; y < 50; y += 10) {
-			for (let x = 0; x < 10; x++) B[x] = s[y + x];
-			for (let x = 0; x < 10; x++) s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+		return result;
+	}
+	if (typeof value === "object" && typeof value.toJSON === "function") return stringify(value.toJSON(), seen);
+	switch (typeof value) {
+		case "boolean":
+		case "number":
+		case "symbol": return value.toString();
+		case "bigint": return BigInt(value).toString();
+		case "string": return JSON.stringify(value);
+		case "object": {
+			const keys = Object.keys(value);
+			keys.sort();
+			return "{ " + keys.map((k) => `${stringify(k, seen)}: ${stringify(value[k], seen)}`).join(", ") + " }";
 		}
-		s[0] ^= SHA3_IOTA_H[round];
-		s[1] ^= SHA3_IOTA_L[round];
 	}
-	B.fill(0);
-}
-var Keccak = class Keccak extends Hash {
-	constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
-		super();
-		this.blockLen = blockLen;
-		this.suffix = suffix;
-		this.outputLen = outputLen;
-		this.enableXOF = enableXOF;
-		this.rounds = rounds;
-		this.pos = 0;
-		this.posOut = 0;
-		this.finished = false;
-		this.destroyed = false;
-		number(outputLen);
-		if (0 >= this.blockLen || this.blockLen >= 200) throw new Error("Sha3 supports only keccak-f1600 function");
-		this.state = /* @__PURE__ */ new Uint8Array(200);
-		this.state32 = u32(this.state);
-	}
-	keccak() {
-		keccakP(this.state32, this.rounds);
-		this.posOut = 0;
-		this.pos = 0;
-	}
-	update(data) {
-		exists(this);
-		const { blockLen, state } = this;
-		data = toBytes(data);
-		const len = data.length;
-		for (let pos = 0; pos < len;) {
-			const take = Math.min(blockLen - this.pos, len - pos);
-			for (let i = 0; i < take; i++) state[this.pos++] ^= data[pos++];
-			if (this.pos === blockLen) this.keccak();
-		}
-		return this;
-	}
-	finish() {
-		if (this.finished) return;
-		this.finished = true;
-		const { state, suffix, pos, blockLen } = this;
-		state[pos] ^= suffix;
-		if ((suffix & 128) !== 0 && pos === blockLen - 1) this.keccak();
-		state[blockLen - 1] ^= 128;
-		this.keccak();
-	}
-	writeInto(out) {
-		exists(this, false);
-		bytes(out);
-		this.finish();
-		const bufferOut = this.state;
-		const { blockLen } = this;
-		for (let pos = 0, len = out.length; pos < len;) {
-			if (this.posOut >= blockLen) this.keccak();
-			const take = Math.min(blockLen - this.posOut, len - pos);
-			out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
-			this.posOut += take;
-			pos += take;
-		}
-		return out;
-	}
-	xofInto(out) {
-		if (!this.enableXOF) throw new Error("XOF is not possible for this instance");
-		return this.writeInto(out);
-	}
-	xof(bytes) {
-		number(bytes);
-		return this.xofInto(new Uint8Array(bytes));
-	}
-	digestInto(out) {
-		output(out, this);
-		if (this.finished) throw new Error("digest() was already called");
-		this.writeInto(out);
-		this.destroy();
-		return out;
-	}
-	digest() {
-		return this.digestInto(new Uint8Array(this.outputLen));
-	}
-	destroy() {
-		this.destroyed = true;
-		this.state.fill(0);
-	}
-	_cloneInto(to) {
-		const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
-		to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
-		to.state32.set(this.state32);
-		to.pos = this.pos;
-		to.posOut = this.posOut;
-		to.finished = this.finished;
-		to.rounds = rounds;
-		to.suffix = suffix;
-		to.outputLen = outputLen;
-		to.enableXOF = enableXOF;
-		to.destroyed = this.destroyed;
-		return to;
-	}
-};
-const gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
-/**
-* keccak-256 hash function. Different from SHA3-256.
-* @param message - that would be hashed
-*/
-const keccak_256 = /* @__PURE__ */ gen(1, 136, 256 / 8);
-
-//#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/_version.js
-/**
-*  The current version of Ethers.
-*/
-const version = "6.13.1";
-
-//#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/utils/properties.js
-/**
-*  Property helper functions.
-*
-*  @_subsection api/utils:Properties  [about-properties]
-*/
-function checkType(value, type, name) {
-	const types = type.split("|").map((t) => t.trim());
-	for (let i = 0; i < types.length; i++) switch (type) {
-		case "any": return;
-		case "bigint":
-		case "boolean":
-		case "number":
-		case "string": if (typeof value === type) return;
-	}
-	const error = /* @__PURE__ */ new Error(`invalid value for type ${type}`);
-	error.code = "INVALID_ARGUMENT";
-	error.argument = `value.${name}`;
-	error.value = value;
-	throw error;
-}
-/**
-*  Resolves to a new object that is a copy of %%value%%, but with all
-*  values resolved.
-*/
-async function resolveProperties(value) {
-	const keys = Object.keys(value);
-	return (await Promise.all(keys.map((k) => Promise.resolve(value[k])))).reduce((accum, v, index) => {
-		accum[keys[index]] = v;
-		return accum;
-	}, {});
-}
-/**
-*  Assigns the %%values%% to %%target%% as read-only values.
-*
-*  It %%types%% is specified, the values are checked.
-*/
-function defineProperties(target, values, types) {
-	for (let key in values) {
-		let value = values[key];
-		const type = types ? types[key] : null;
-		if (type) checkType(value, type, key);
-		Object.defineProperty(target, key, {
-			enumerable: true,
-			value,
-			writable: false
-		});
-	}
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/utils/errors.js
-/**
-*  All errors in ethers include properties to ensure they are both
-*  human-readable (i.e. ``.message``) and machine-readable (i.e. ``.code``).
-*
-*  The [[isError]] function can be used to check the error ``code`` and
-*  provide a type guard for the properties present on that error interface.
-*
-*  @_section: api/utils/errors:Errors  [about-errors]
-*/
-function stringify(value) {
-	if (value == null) return "null";
-	if (Array.isArray(value)) return "[ " + value.map(stringify).join(", ") + " ]";
-	if (value instanceof Uint8Array) {
-		const HEX = "0123456789abcdef";
-		let result = "0x";
-		for (let i = 0; i < value.length; i++) {
-			result += HEX[value[i] >> 4];
-			result += HEX[value[i] & 15];
-		}
-		return result;
-	}
-	if (typeof value === "object" && typeof value.toJSON === "function") return stringify(value.toJSON());
-	switch (typeof value) {
-		case "boolean":
-		case "symbol": return value.toString();
-		case "bigint": return BigInt(value).toString();
-		case "number": return value.toString();
-		case "string": return JSON.stringify(value);
-		case "object": {
-			const keys = Object.keys(value);
-			keys.sort();
-			return "{ " + keys.map((k) => `${stringify(k)}: ${stringify(value[k])}`).join(", ") + " }";
-		}
-	}
-	return `[ COULD NOT SERIALIZE ]`;
+	return `[ COULD NOT SERIALIZE ]`;
 }
 /**
 *  Returns true if the %%error%% matches an error thrown by ethers
@@ -476,7 +214,7 @@ function assertArgument(check, message, name, value) {
 function assertArgumentCount(count, expectedCount, message) {
 	if (message == null) message = "";
 	if (message) message = ": " + message;
-	assert(count >= expectedCount, "missing arguemnt" + message, "MISSING_ARGUMENT", {
+	assert(count >= expectedCount, "missing argument" + message, "MISSING_ARGUMENT", {
 		count,
 		expectedCount
 	});
@@ -532,7 +270,7 @@ function assertPrivate(givenGuard, guard, className) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/utils/data.js
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/utils/data.js
 /**
 *  Some data helpers.
 *
@@ -544,7 +282,7 @@ function _getBytes(value, name, copy) {
 		if (copy) return new Uint8Array(value);
 		return value;
 	}
-	if (typeof value === "string" && value.match(/^0x(?:[0-9a-f][0-9a-f])*$/i)) {
+	if (typeof value === "string" && value.length % 2 === 0 && value.match(/^0x[0-9a-f]*$/i)) {
 		const result = new Uint8Array((value.length - 2) / 2);
 		let offset = 2;
 		for (let i = 0; i < result.length; i++) {
@@ -678,13 +416,13 @@ function zeroPadBytes(data, length) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/utils/maths.js
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/utils/maths.js
 /**
 *  Some mathematic operations.
 *
 *  @_subsection: api/utils:Math Helpers  [about-maths]
 */
-const BN_0$6 = BigInt(0);
+const BN_0$5 = BigInt(0);
 const BN_1$2 = BigInt(1);
 const maxValue = 9007199254740991;
 /**
@@ -696,7 +434,7 @@ const maxValue = 9007199254740991;
 function fromTwos(_value, _width) {
 	const value = getUint(_value, "value");
 	const width = BigInt(getNumber(_width, "width"));
-	assert(value >> width === BN_0$6, "overflow", "NUMERIC_FAULT", {
+	assert(value >> width === BN_0$5, "overflow", "NUMERIC_FAULT", {
 		operation: "fromTwos",
 		fault: "overflow",
 		value: _value
@@ -717,7 +455,7 @@ function toTwos(_value, _width) {
 	let value = getBigInt(_value, "value");
 	const width = BigInt(getNumber(_width, "width"));
 	const limit = BN_1$2 << width - BN_1$2;
-	if (value < BN_0$6) {
+	if (value < BN_0$5) {
 		value = -value;
 		assert(value <= limit, "too low", "NUMERIC_FAULT", {
 			operation: "toTwos",
@@ -766,7 +504,7 @@ function getBigInt(value, name) {
 */
 function getUint(value, name) {
 	const result = getBigInt(value, name);
-	assert(result >= BN_0$6, "unsigned value cannot be negative", "NUMERIC_FAULT", {
+	assert(result >= BN_0$5, "unsigned value cannot be negative", "NUMERIC_FAULT", {
 		fault: "overflow",
 		operation: "getUint",
 		value
@@ -819,11 +557,13 @@ function toNumber(value) {
 *  %%width%% bytes.
 */
 function toBeHex(_value, _width) {
-	let result = getUint(_value, "value").toString(16);
+	const value = getUint(_value, "value");
+	let result = value.toString(16);
 	if (_width == null) {
 		if (result.length % 2) result = "0" + result;
 	} else {
 		const width = getNumber(_width, "width");
+		if (width === 0 && value === BN_0$5) return "0x";
 		assert(width * 2 >= result.length, `value exceeds width (${width} bytes)`, "NUMERIC_FAULT", {
 			operation: "toBeHex",
 			fault: "overflow",
@@ -836,11 +576,23 @@ function toBeHex(_value, _width) {
 /**
 *  Converts %%value%% to a Big Endian Uint8Array.
 */
-function toBeArray(_value) {
+function toBeArray(_value, _width) {
 	const value = getUint(_value, "value");
-	if (value === BN_0$6) return new Uint8Array([]);
+	if (value === BN_0$5) {
+		const width = _width != null ? getNumber(_width, "width") : 0;
+		return new Uint8Array(width);
+	}
 	let hex = value.toString(16);
 	if (hex.length % 2) hex = "0" + hex;
+	if (_width != null) {
+		const width = getNumber(_width, "width");
+		while (hex.length < width * 2) hex = "00" + hex;
+		assert(width * 2 === hex.length, `value exceeds width (${width} bytes)`, "NUMERIC_FAULT", {
+			operation: "toBeArray",
+			fault: "overflow",
+			value: _value
+		});
+	}
 	const result = new Uint8Array(hex.length / 2);
 	for (let i = 0; i < result.length; i++) {
 		const offset = i * 2;
@@ -863,7 +615,7 @@ function toQuantity(value) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/utils/events.js
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/utils/events.js
 /**
 *  Events allow for applications to use the observer pattern, which
 *  allows subscribing and publishing events, outside the normal
@@ -907,7 +659,7 @@ var EventPayload = class {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/utils/utf8.js
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/utils/utf8.js
 /**
 *  Using strings in Ethereum (or any security-basd system) requires
 *  additional care. These utilities attempt to mitigate some of the
@@ -1073,986 +825,1189 @@ function toUtf8String(bytes, onError) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/utils/rlp-encode.js
-function arrayifyInteger(value) {
-	const result = [];
-	while (value) {
-		result.unshift(value & 255);
-		value >>= 8;
-	}
-	return result;
-}
-function _encode(object) {
-	if (Array.isArray(object)) {
-		let payload = [];
-		object.forEach(function(child) {
-			payload = payload.concat(_encode(child));
-		});
-		if (payload.length <= 55) {
-			payload.unshift(192 + payload.length);
-			return payload;
-		}
-		const length = arrayifyInteger(payload.length);
-		length.unshift(247 + length.length);
-		return length.concat(payload);
-	}
-	const data = Array.prototype.slice.call(getBytes(object, "object"));
-	if (data.length === 1 && data[0] <= 127) return data;
-	else if (data.length <= 55) {
-		data.unshift(128 + data.length);
-		return data;
-	}
-	const length = arrayifyInteger(data.length);
-	length.unshift(183 + length.length);
-	return length.concat(data);
-}
-const nibbles = "0123456789abcdef";
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/abi/coders/abstract-coder.js
 /**
-*  Encodes %%object%% as an RLP-encoded [[DataHexString]].
+* @_ignore:
 */
-function encodeRlp(object) {
-	let result = "0x";
-	for (const v of _encode(object)) {
-		result += nibbles[v >> 4];
-		result += nibbles[v & 15];
-	}
-	return result;
+const WordSize = 32;
+const Padding = new Uint8Array(32);
+const passProperties$1 = ["then"];
+const _guard$2 = {};
+const resultNames = /* @__PURE__ */ new WeakMap();
+function getNames(result) {
+	return resultNames.get(result);
+}
+function setNames(result, names) {
+	resultNames.set(result, names);
+}
+function throwError(name, error) {
+	const wrapped = /* @__PURE__ */ 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;
+	}, {});
 }
-
-//#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/crypto/keccak.js
-/**
-*  Cryptographic hashing functions
-*
-*  @_subsection: api/crypto:Hash Functions [about-crypto-hashing]
-*/
-let locked = false;
-const _keccak256 = function(data) {
-	return keccak_256(data);
-};
-let __keccak256 = _keccak256;
 /**
-*  Compute the cryptographic KECCAK256 hash of %%data%%.
-*
-*  The %%data%% **must** be a data representation, to compute the
-*  hash of UTF-8 data use the [[id]] function.
-*
-*  @returns DataHexstring
-*  @example:
-*    keccak256("0x")
-*    //_result:
-*
-*    keccak256("0x1337")
-*    //_result:
-*
-*    keccak256(new Uint8Array([ 0x13, 0x37 ]))
-*    //_result:
+*  A [[Result]] is a sub-class of Array, which allows accessing any
+*  of its values either positionally by its index or, if keys are
+*  provided by its name.
 *
-*    // Strings are assumed to be DataHexString, otherwise it will
-*    // throw. To hash UTF-8 data, see the note above.
-*    keccak256("Hello World")
-*    //_error:
+*  @_docloc: api/abi
 */
-function keccak256(_data) {
-	const data = getBytes(_data, "data");
-	return hexlify(__keccak256(data));
-}
-keccak256._ = _keccak256;
-keccak256.lock = function() {
-	locked = true;
-};
-keccak256.register = function(func) {
-	if (locked) throw new TypeError("keccak256 is locked");
-	__keccak256 = func;
-};
-Object.freeze(keccak256);
-
-//#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/constants/hashes.js
-/**
-*  A constant for the zero hash.
-*
-*  (**i.e.** ``"0x0000000000000000000000000000000000000000000000000000000000000000"``)
-*/
-const ZeroHash = "0x0000000000000000000000000000000000000000000000000000000000000000";
-
-//#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/crypto/signature.js
-const BN_0$5 = BigInt(0);
-const BN_1$1 = BigInt(1);
-const BN_2 = BigInt(2);
-const BN_27 = BigInt(27);
-const BN_28 = BigInt(28);
-const BN_35 = BigInt(35);
-const _guard$2 = {};
-function toUint256(value) {
-	return zeroPadValue(toBeArray(value), 32);
-}
-/**
-*  A Signature  @TODO
-*
-*
-*  @_docloc: api/crypto:Signing
-*/
-var Signature = class Signature {
-	#r;
-	#s;
-	#v;
-	#networkV;
-	/**
-	*  The ``r`` value for a signautre.
-	*
-	*  This represents the ``x`` coordinate of a "reference" or
-	*  challenge point, from which the ``y`` can be computed.
-	*/
-	get r() {
-		return this.#r;
-	}
-	set r(value) {
-		assertArgument(dataLength(value) === 32, "invalid r", "value", value);
-		this.#r = hexlify(value);
-	}
+var Result = class Result extends Array {
+	#names;
 	/**
-	*  The ``s`` value for a signature.
+	*  @private
 	*/
-	get s() {
-		return this.#s;
-	}
-	set s(_value) {
-		assertArgument(dataLength(_value) === 32, "invalid s", "value", _value);
-		const value = hexlify(_value);
-		assertArgument(parseInt(value.substring(0, 3)) < 8, "non-canonical s", "value", value);
-		this.#s = value;
+	constructor(...args) {
+		const guard = args[0];
+		let items = args[1];
+		let names = (args[2] || []).slice();
+		let wrap = true;
+		if (guard !== _guard$2) {
+			items = args;
+			names = [];
+			wrap = false;
+		}
+		super(items.length);
+		items.forEach((item, index) => {
+			this[index] = item;
+		});
+		const nameCounts = names.reduce((accum, name) => {
+			if (typeof name === "string") accum.set(name, (accum.get(name) || 0) + 1);
+			return accum;
+		}, /* @__PURE__ */ new Map());
+		setNames(this, Object.freeze(items.map((item, index) => {
+			const name = names[index];
+			if (name != null && nameCounts.get(name) === 1) return name;
+			return null;
+		})));
+		this.#names = [];
+		if (this.#names == null) this.#names;
+		if (!wrap) return;
+		Object.freeze(this);
+		const proxy = new Proxy(this, { get: (target, prop, receiver) => {
+			if (typeof prop === "string") {
+				if (prop.match(/^[0-9]+$/)) {
+					const index = getNumber(prop, "%index");
+					if (index < 0 || index >= this.length) throw new RangeError("out of result range");
+					const item = target[index];
+					if (item instanceof Error) throwError(`index ${index}`, item);
+					return item;
+				}
+				if (passProperties$1.indexOf(prop) >= 0) return Reflect.get(target, prop, receiver);
+				const value = target[prop];
+				if (value instanceof Function) return function(...args) {
+					return value.apply(this === receiver ? target : this, args);
+				};
+				else if (!(prop in target)) return target.getValue.apply(this === receiver ? target : this, [prop]);
+			}
+			return Reflect.get(target, prop, receiver);
+		} });
+		setNames(proxy, getNames(this));
+		return proxy;
 	}
 	/**
-	*  The ``v`` value for a signature.
-	*
-	*  Since a given ``x`` value for ``r`` has two possible values for
-	*  its correspondin ``y``, the ``v`` indicates which of the two ``y``
-	*  values to use.
+	*  Returns the Result as a normal Array. If %%deep%%, any children
+	*  which are Result objects are also converted to a normal Array.
 	*
-	*  It is normalized to the values ``27`` or ``28`` for legacy
-	*  purposes.
-	*/
-	get v() {
-		return this.#v;
-	}
-	set v(value) {
-		const v = getNumber(value, "value");
-		assertArgument(v === 27 || v === 28, "invalid v", "v", value);
-		this.#v = v;
-	}
-	/**
-	*  The EIP-155 ``v`` for legacy transactions. For non-legacy
-	*  transactions, this value is ``null``.
-	*/
-	get networkV() {
-		return this.#networkV;
-	}
-	/**
-	*  The chain ID for EIP-155 legacy transactions. For non-legacy
-	*  transactions, this value is ``null``.
+	*  This will throw if there are any outstanding deferred
+	*  errors.
 	*/
-	get legacyChainId() {
-		const v = this.networkV;
-		if (v == null) return null;
-		return Signature.getChainId(v);
+	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;
 	}
 	/**
-	*  The ``yParity`` for the signature.
+	*  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.
 	*
-	*  See ``v`` for more details on how this value is used.
+	*  This will throw if any value is unnamed, or if there are
+	*  any outstanding deferred errors.
 	*/
-	get yParity() {
-		return this.v === 27 ? 0 : 1;
+	toObject(deep) {
+		const names = getNames(this);
+		return names.reduce((accum, name, index) => {
+			assert(name != null, `value at index ${index} unnamed`, "UNSUPPORTED_OPERATION", { operation: "toObject()" });
+			return toObject(names, this, deep);
+		}, {});
 	}
 	/**
-	*  The [[link-eip-2098]] compact representation of the ``yParity``
-	*  and ``s`` compacted into a single ``bytes32``.
+	*  @_ignore
 	*/
-	get yParityAndS() {
-		const yParityAndS = getBytes(this.s);
-		if (this.yParity) yParityAndS[0] |= 128;
-		return hexlify(yParityAndS);
+	slice(start, end) {
+		if (start == null) start = 0;
+		if (start < 0) {
+			start += this.length;
+			if (start < 0) start = 0;
+		}
+		if (end == null) end = this.length;
+		if (end < 0) {
+			end += this.length;
+			if (end < 0) end = 0;
+		}
+		if (end > this.length) end = this.length;
+		const _names = getNames(this);
+		const result = [];
+		const names = [];
+		for (let i = start; i < end; i++) {
+			result.push(this[i]);
+			names.push(_names[i]);
+		}
+		return new Result(_guard$2, result, names);
 	}
 	/**
-	*  The [[link-eip-2098]] compact representation.
+	*  @_ignore
 	*/
-	get compactSerialized() {
-		return concat([this.r, this.yParityAndS]);
+	filter(callback, thisArg) {
+		const _names = getNames(this);
+		const result = [];
+		const names = [];
+		for (let i = 0; i < this.length; i++) {
+			const item = this[i];
+			if (item instanceof Error) throwError(`index ${i}`, item);
+			if (callback.call(thisArg, item, i, this)) {
+				result.push(item);
+				names.push(_names[i]);
+			}
+		}
+		return new Result(_guard$2, result, names);
 	}
 	/**
-	*  The serialized representation.
+	*  @_ignore
 	*/
-	get serialized() {
-		return concat([
-			this.r,
-			this.s,
-			this.yParity ? "0x1c" : "0x1b"
-		]);
+	map(callback, thisArg) {
+		const result = [];
+		for (let i = 0; i < this.length; i++) {
+			const item = this[i];
+			if (item instanceof Error) throwError(`index ${i}`, item);
+			result.push(callback.call(thisArg, item, i, this));
+		}
+		return result;
 	}
 	/**
-	*  @private
+	*  Returns the value for %%name%%.
+	*
+	*  Since it is possible to have a key whose name conflicts with
+	*  a method on a [[Result]] or its superclass Array, or any
+	*  JavaScript keyword, this ensures all named values are still
+	*  accessible by name.
 	*/
-	constructor(guard, r, s, v) {
-		assertPrivate(guard, _guard$2, "Signature");
-		this.#r = r;
-		this.#s = s;
-		this.#v = v;
-		this.#networkV = null;
-	}
-	[Symbol.for("nodejs.util.inspect.custom")]() {
-		return `Signature { r: "${this.r}", s: "${this.s}", yParity: ${this.yParity}, networkV: ${this.networkV} }`;
+	getValue(name) {
+		const index = getNames(this).indexOf(name);
+		if (index === -1) return;
+		const value = this[index];
+		if (value instanceof Error) throwError(`property ${JSON.stringify(name)}`, value.error);
+		return value;
 	}
 	/**
-	*  Returns a new identical [[Signature]].
+	*  Creates a new [[Result]] for %%items%% with each entry
+	*  also accessible by its corresponding name in %%keys%%.
 	*/
-	clone() {
-		const clone = new Signature(_guard$2, this.r, this.s, this.v);
-		if (this.networkV) clone.#networkV = this.networkV;
-		return clone;
+	static fromItems(items, keys) {
+		return new Result(_guard$2, items, keys);
 	}
-	/**
-	*  Returns a representation that is compatible with ``JSON.stringify``.
-	*/
-	toJSON() {
-		const networkV = this.networkV;
-		return {
-			_type: "signature",
-			networkV: networkV != null ? networkV.toString() : null,
-			r: this.r,
-			s: this.s,
-			v: this.v
+};
+function getValue$1(value) {
+	let bytes = toBeArray(value);
+	assert(bytes.length <= 32, "value out-of-bounds", "BUFFER_OVERRUN", {
+		buffer: bytes,
+		length: 32,
+		offset: bytes.length
+	});
+	if (bytes.length !== 32) bytes = getBytesCopy(concat([Padding.slice(bytes.length % 32), bytes]));
+	return bytes;
+}
+__name(getValue$1, "getValue");
+/**
+*  @_ignore
+*/
+var Coder = class {
+	name;
+	type;
+	localName;
+	dynamic;
+	constructor(name, type, localName, dynamic) {
+		defineProperties(this, {
+			name,
+			type,
+			localName,
+			dynamic
+		}, {
+			name: "string",
+			type: "string",
+			localName: "string",
+			dynamic: "boolean"
+		});
+	}
+	_throwError(message, value) {
+		assertArgument(false, message, this.localName, value);
+	}
+};
+/**
+*  @_ignore
+*/
+var Writer = class {
+	#data;
+	#dataLength;
+	constructor() {
+		this.#data = [];
+		this.#dataLength = 0;
+	}
+	get data() {
+		return concat(this.#data);
+	}
+	get length() {
+		return this.#dataLength;
+	}
+	#writeData(data) {
+		this.#data.push(data);
+		this.#dataLength += data.length;
+		return data.length;
+	}
+	appendWriter(writer) {
+		return this.#writeData(getBytesCopy(writer.data));
+	}
+	writeBytes(value) {
+		let bytes = getBytesCopy(value);
+		const paddingOffset = bytes.length % 32;
+		if (paddingOffset) bytes = getBytesCopy(concat([bytes, Padding.slice(paddingOffset)]));
+		return this.#writeData(bytes);
+	}
+	writeValue(value) {
+		return this.#writeData(getValue$1(value));
+	}
+	writeUpdatableValue() {
+		const offset = this.#data.length;
+		this.#data.push(Padding);
+		this.#dataLength += 32;
+		return (value) => {
+			this.#data[offset] = getValue$1(value);
 		};
 	}
-	/**
-	*  Compute the chain ID from the ``v`` in a legacy EIP-155 transactions.
-	*
-	*  @example:
-	*    Signature.getChainId(45)
-	*    //_result:
-	*
-	*    Signature.getChainId(46)
-	*    //_result:
-	*/
-	static getChainId(v) {
-		const bv = getBigInt(v, "v");
-		if (bv == BN_27 || bv == BN_28) return BN_0$5;
-		assertArgument(bv >= BN_35, "invalid EIP-155 v", "v", v);
-		return (bv - BN_35) / BN_2;
+};
+/**
+*  @_ignore
+*/
+var Reader = class Reader {
+	allowLoose;
+	#data;
+	#offset;
+	#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;
 	}
-	/**
-	*  Compute the ``v`` for a chain ID for a legacy EIP-155 transactions.
-	*
-	*  Legacy transactions which use [[link-eip-155]] hijack the ``v``
-	*  property to include the chain ID.
-	*
-	*  @example:
-	*    Signature.getChainIdV(5, 27)
-	*    //_result:
-	*
-	*    Signature.getChainIdV(5, 28)
-	*    //_result:
-	*
-	*/
-	static getChainIdV(chainId, v) {
-		return getBigInt(chainId) * BN_2 + BigInt(35 + v - 27);
+	get data() {
+		return hexlify(this.#data);
 	}
-	/**
-	*  Compute the normalized legacy transaction ``v`` from a ``yParirty``,
-	*  a legacy transaction ``v`` or a legacy [[link-eip-155]] transaction.
-	*
-	*  @example:
-	*    // The values 0 and 1 imply v is actually yParity
-	*    Signature.getNormalizedV(0)
-	*    //_result:
-	*
-	*    // Legacy non-EIP-1559 transaction (i.e. 27 or 28)
-	*    Signature.getNormalizedV(27)
-	*    //_result:
-	*
-	*    // Legacy EIP-155 transaction (i.e. >= 35)
-	*    Signature.getNormalizedV(46)
-	*    //_result:
-	*
-	*    // Invalid values throw
-	*    Signature.getNormalizedV(5)
-	*    //_error:
-	*/
-	static getNormalizedV(v) {
-		const bv = getBigInt(v);
-		if (bv === BN_0$5 || bv === BN_27) return 27;
-		if (bv === BN_1$1 || bv === BN_28) return 28;
-		assertArgument(bv >= BN_35, "invalid v", "v", v);
-		return bv & BN_1$1 ? 27 : 28;
+	get dataLength() {
+		return this.#data.length;
 	}
-	/**
-	*  Creates a new [[Signature]].
-	*
-	*  If no %%sig%% is provided, a new [[Signature]] is created
-	*  with default values.
-	*
-	*  If %%sig%% is a string, it is parsed.
-	*/
-	static from(sig) {
-		function assertError(check, message) {
-			assertArgument(check, message, "signature", sig);
-		}
-		if (sig == null) return new Signature(_guard$2, ZeroHash, ZeroHash, 27);
-		if (typeof sig === "string") {
-			const bytes = getBytes(sig, "signature");
-			if (bytes.length === 64) {
-				const r = hexlify(bytes.slice(0, 32));
-				const s = bytes.slice(32, 64);
-				const v = s[0] & 128 ? 28 : 27;
-				s[0] &= 127;
-				return new Signature(_guard$2, r, hexlify(s), v);
-			}
-			if (bytes.length === 65) {
-				const r = hexlify(bytes.slice(0, 32));
-				const s = bytes.slice(32, 64);
-				assertError((s[0] & 128) === 0, "non-canonical s");
-				const v = Signature.getNormalizedV(bytes[64]);
-				return new Signature(_guard$2, r, hexlify(s), v);
-			}
-			assertError(false, "invalid raw signature length");
-		}
-		if (sig instanceof Signature) return sig.clone();
-		const _r = sig.r;
-		assertError(_r != null, "missing r");
-		const r = toUint256(_r);
-		const s = (function(s, yParityAndS) {
-			if (s != null) return toUint256(s);
-			if (yParityAndS != null) {
-				assertError(isHexString(yParityAndS, 32), "invalid yParityAndS");
-				const bytes = getBytes(yParityAndS);
-				bytes[0] &= 127;
-				return hexlify(bytes);
-			}
-			assertError(false, "missing s");
-		})(sig.s, sig.yParityAndS);
-		assertError((getBytes(s)[0] & 128) == 0, "non-canonical s");
-		const { networkV, v } = (function(_v, yParityAndS, yParity) {
-			if (_v != null) {
-				const v = getBigInt(_v);
-				return {
-					networkV: v >= BN_35 ? v : void 0,
-					v: Signature.getNormalizedV(v)
-				};
-			}
-			if (yParityAndS != null) {
-				assertError(isHexString(yParityAndS, 32), "invalid yParityAndS");
-				return { v: getBytes(yParityAndS)[0] & 128 ? 28 : 27 };
-			}
-			if (yParity != null) {
-				switch (getNumber(yParity, "sig.yParity")) {
-					case 0: return { v: 27 };
-					case 1: return { v: 28 };
-				}
-				assertError(false, "invalid yParity");
+	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;
+		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
 			}
-			assertError(false, "missing v");
-		})(sig.v, sig.yParityAndS, sig.yParity);
-		const result = new Signature(_guard$2, r, s, v);
-		if (networkV) result.#networkV = networkV;
-		assertError(sig.yParity == null || getNumber(sig.yParity, "sig.yParity") === result.yParity, "yParity mismatch");
-		assertError(sig.yParityAndS == null || sig.yParityAndS === result.yParityAndS, "yParityAndS mismatch");
-		return result;
+		});
+	}
+	#peekBytes(offset, length, loose) {
+		let alignedLength = Math.ceil(length / 32) * 32;
+		if (this.#offset + alignedLength > this.#data.length) if (this.allowLoose && loose && this.#offset + length <= this.#data.length) alignedLength = length;
+		else assert(false, "data out-of-bounds", "BUFFER_OVERRUN", {
+			buffer: getBytesCopy(this.#data),
+			length: this.#data.length,
+			offset: this.#offset + alignedLength
+		});
+		return this.#data.slice(this.#offset, this.#offset + alignedLength);
+	}
+	subReader(offset) {
+		const reader = new Reader(this.#data.slice(this.#offset + offset), this.allowLoose, this.#maxInflation);
+		reader.#parent = this;
+		return reader;
+	}
+	readBytes(length, loose) {
+		let bytes = this.#peekBytes(0, length, !!loose);
+		this.#incrementBytesRead(length);
+		this.#offset += bytes.length;
+		return bytes.slice(0, length);
+	}
+	readValue() {
+		return toBigInt(this.readBytes(32));
+	}
+	readIndex() {
+		return toNumber(this.readBytes(32));
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/_assert.js
+function number(n) {
+	if (!Number.isSafeInteger(n) || n < 0) throw new Error(`Wrong positive integer: ${n}`);
+}
+function bytes(b, ...lengths) {
+	if (!(b instanceof Uint8Array)) throw new Error("Expected Uint8Array");
+	if (lengths.length > 0 && !lengths.includes(b.length)) throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
+}
+function hash(hash) {
+	if (typeof hash !== "function" || typeof hash.create !== "function") throw new Error("Hash should be wrapped by utils.wrapConstructor");
+	number(hash.outputLen);
+	number(hash.blockLen);
+}
+function exists(instance, checkFinished = true) {
+	if (instance.destroyed) throw new Error("Hash instance has been destroyed");
+	if (checkFinished && instance.finished) throw new Error("Hash#digest() has already been called");
+}
+function output(out, instance) {
+	bytes(out);
+	const min = instance.outputLen;
+	if (out.length < min) throw new Error(`digestInto() expects output buffer of length at least ${min}`);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/_u64.js
+const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+const _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+	if (le) return {
+		h: Number(n & U32_MASK64),
+		l: Number(n >> _32n & U32_MASK64)
+	};
+	return {
+		h: Number(n >> _32n & U32_MASK64) | 0,
+		l: Number(n & U32_MASK64) | 0
+	};
+}
+function split(lst, le = false) {
+	let Ah = new Uint32Array(lst.length);
+	let Al = new Uint32Array(lst.length);
+	for (let i = 0; i < lst.length; i++) {
+		const { h, l } = fromBig(lst[i], le);
+		[Ah[i], Al[i]] = [h, l];
 	}
-};
+	return [Ah, Al];
+}
+const rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+const rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+const rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+const rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/address/address.js
-const BN_0$4 = BigInt(0);
-const BN_36 = BigInt(36);
-function getChecksumAddress(address) {
-	address = address.toLowerCase();
-	const chars = address.substring(2).split("");
-	const expanded = /* @__PURE__ */ new Uint8Array(40);
-	for (let i = 0; i < 40; i++) expanded[i] = chars[i].charCodeAt(0);
-	const hashed = getBytes(keccak256(expanded));
-	for (let i = 0; i < 40; i += 2) {
-		if (hashed[i >> 1] >> 4 >= 8) chars[i] = chars[i].toUpperCase();
-		if ((hashed[i >> 1] & 15) >= 8) chars[i + 1] = chars[i + 1].toUpperCase();
-	}
-	return "0x" + chars.join("");
+//#region ../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/cryptoNode.js
+const crypto$1 = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : void 0;
+
+//#endregion
+//#region ../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/utils.js
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const u8a = (a) => a instanceof Uint8Array;
+const u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+const rotr = (word, shift) => word << 32 - shift | word >>> shift;
+const isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+if (!isLE) throw new Error("Non little-endian hardware is not supported");
+/**
+* @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
+*/
+function utf8ToBytes(str) {
+	if (typeof str !== "string") throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+	return new Uint8Array(new TextEncoder().encode(str));
 }
-const ibanLookup = {};
-for (let i = 0; i < 10; i++) ibanLookup[String(i)] = String(i);
-for (let i = 0; i < 26; i++) ibanLookup[String.fromCharCode(65 + i)] = String(10 + i);
-const safeDigits = 15;
-function ibanChecksum(address) {
-	address = address.toUpperCase();
-	address = address.substring(4) + address.substring(0, 2) + "00";
-	let expanded = address.split("").map((c) => {
-		return ibanLookup[c];
-	}).join("");
-	while (expanded.length >= safeDigits) {
-		let block = expanded.substring(0, safeDigits);
-		expanded = parseInt(block, 10) % 97 + expanded.substring(block.length);
-	}
-	let checksum = String(98 - parseInt(expanded, 10) % 97);
-	while (checksum.length < 2) checksum = "0" + checksum;
-	return checksum;
+/**
+* Normalizes (non-hex) string or Uint8Array to Uint8Array.
+* Warning: when Uint8Array is passed, it would NOT get copied.
+* Keep in mind for future mutable operations.
+*/
+function toBytes(data) {
+	if (typeof data === "string") data = utf8ToBytes(data);
+	if (!u8a(data)) throw new Error(`expected Uint8Array, got ${typeof data}`);
+	return data;
 }
-const Base36 = (function() {
-	const result = {};
-	for (let i = 0; i < 36; i++) {
-		const key = "0123456789abcdefghijklmnopqrstuvwxyz"[i];
-		result[key] = BigInt(i);
+/**
+* Copies several Uint8Arrays into one.
+*/
+function concatBytes(...arrays) {
+	const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));
+	let pad = 0;
+	arrays.forEach((a) => {
+		if (!u8a(a)) throw new Error("Uint8Array expected");
+		r.set(a, pad);
+		pad += a.length;
+	});
+	return r;
+}
+var Hash = class {
+	clone() {
+		return this._cloneInto();
 	}
-	return result;
-})();
-function fromBase36(value) {
-	value = value.toLowerCase();
-	let result = BN_0$4;
-	for (let i = 0; i < value.length; i++) result = result * BN_36 + Base36[value[i]];
-	return result;
+};
+const toStr = {}.toString;
+function wrapConstructor(hashCons) {
+	const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+	const tmp = hashCons();
+	hashC.outputLen = tmp.outputLen;
+	hashC.blockLen = tmp.blockLen;
+	hashC.create = () => hashCons();
+	return hashC;
 }
 /**
-*  Returns a normalized and checksumed address for %%address%%.
-*  This accepts non-checksum addresses, checksum addresses and
-*  [[getIcapAddress]] formats.
-*
-*  The checksum in Ethereum uses the capitalization (upper-case
-*  vs lower-case) of the characters within an address to encode
-*  its checksum, which offers, on average, a checksum of 15-bits.
-*
-*  If %%address%% contains both upper-case and lower-case, it is
-*  assumed to already be a checksum address and its checksum is
-*  validated, and if the address fails its expected checksum an
-*  error is thrown.
-*
-*  If you wish the checksum of %%address%% to be ignore, it should
-*  be converted to lower-case (i.e. ``.toLowercase()``) before
-*  being passed in. This should be a very rare situation though,
-*  that you wish to bypass the safegaurds in place to protect
-*  against an address that has been incorrectly copied from another
-*  source.
-*
-*  @example:
-*    // Adds the checksum (via upper-casing specific letters)
-*    getAddress("0x8ba1f109551bd432803012645ac136ddd64dba72")
-*    //_result:
-*
-*    // Converts ICAP address and adds checksum
-*    getAddress("XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36");
-*    //_result:
-*
-*    // Throws an error if an address contains mixed case,
-*    // but the checksum fails
-*    getAddress("0x8Ba1f109551bD432803012645Ac136ddd64DBA72")
-*    //_error:
+* Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.
 */
-function getAddress(address) {
-	assertArgument(typeof address === "string", "invalid address", "address", address);
-	if (address.match(/^(0x)?[0-9a-fA-F]{40}$/)) {
-		if (!address.startsWith("0x")) address = "0x" + address;
-		const result = getChecksumAddress(address);
-		assertArgument(!address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) || result === address, "bad address checksum", "address", address);
-		return result;
+function randomBytes(bytesLength = 32) {
+	if (crypto$1 && typeof crypto$1.getRandomValues === "function") return crypto$1.getRandomValues(new Uint8Array(bytesLength));
+	throw new Error("crypto.getRandomValues must be defined");
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@noble+hashes@1.3.2/node_modules/@noble/hashes/esm/sha3.js
+const [SHA3_PI, SHA3_ROTL, _SHA3_IOTA] = [
+	[],
+	[],
+	[]
+];
+const _0n = /* @__PURE__ */ BigInt(0);
+const _1n = /* @__PURE__ */ BigInt(1);
+const _2n = /* @__PURE__ */ BigInt(2);
+const _7n = /* @__PURE__ */ BigInt(7);
+const _256n = /* @__PURE__ */ BigInt(256);
+const _0x71n = /* @__PURE__ */ BigInt(113);
+for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+	[x, y] = [y, (2 * x + 3 * y) % 5];
+	SHA3_PI.push(2 * (5 * y + x));
+	SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
+	let t = _0n;
+	for (let j = 0; j < 7; j++) {
+		R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
+		if (R & _2n) t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
+	}
+	_SHA3_IOTA.push(t);
+}
+const [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);
+const rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
+const rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
+function keccakP(s, rounds = 24) {
+	const B = /* @__PURE__ */ new Uint32Array(10);
+	for (let round = 24 - rounds; round < 24; round++) {
+		for (let x = 0; x < 10; x++) B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+		for (let x = 0; x < 10; x += 2) {
+			const idx1 = (x + 8) % 10;
+			const idx0 = (x + 2) % 10;
+			const B0 = B[idx0];
+			const B1 = B[idx0 + 1];
+			const Th = rotlH(B0, B1, 1) ^ B[idx1];
+			const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+			for (let y = 0; y < 50; y += 10) {
+				s[x + y] ^= Th;
+				s[x + y + 1] ^= Tl;
+			}
+		}
+		let curH = s[2];
+		let curL = s[3];
+		for (let t = 0; t < 24; t++) {
+			const shift = SHA3_ROTL[t];
+			const Th = rotlH(curH, curL, shift);
+			const Tl = rotlL(curH, curL, shift);
+			const PI = SHA3_PI[t];
+			curH = s[PI];
+			curL = s[PI + 1];
+			s[PI] = Th;
+			s[PI + 1] = Tl;
+		}
+		for (let y = 0; y < 50; y += 10) {
+			for (let x = 0; x < 10; x++) B[x] = s[y + x];
+			for (let x = 0; x < 10; x++) s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+		}
+		s[0] ^= SHA3_IOTA_H[round];
+		s[1] ^= SHA3_IOTA_L[round];
+	}
+	B.fill(0);
+}
+var Keccak = class Keccak extends Hash {
+	constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+		super();
+		this.blockLen = blockLen;
+		this.suffix = suffix;
+		this.outputLen = outputLen;
+		this.enableXOF = enableXOF;
+		this.rounds = rounds;
+		this.pos = 0;
+		this.posOut = 0;
+		this.finished = false;
+		this.destroyed = false;
+		number(outputLen);
+		if (0 >= this.blockLen || this.blockLen >= 200) throw new Error("Sha3 supports only keccak-f1600 function");
+		this.state = /* @__PURE__ */ new Uint8Array(200);
+		this.state32 = u32(this.state);
+	}
+	keccak() {
+		keccakP(this.state32, this.rounds);
+		this.posOut = 0;
+		this.pos = 0;
+	}
+	update(data) {
+		exists(this);
+		const { blockLen, state } = this;
+		data = toBytes(data);
+		const len = data.length;
+		for (let pos = 0; pos < len;) {
+			const take = Math.min(blockLen - this.pos, len - pos);
+			for (let i = 0; i < take; i++) state[this.pos++] ^= data[pos++];
+			if (this.pos === blockLen) this.keccak();
+		}
+		return this;
 	}
-	if (address.match(/^XE[0-9]{2}[0-9A-Za-z]{30,31}$/)) {
-		assertArgument(address.substring(2, 4) === ibanChecksum(address), "bad icap checksum", "address", address);
-		let result = fromBase36(address.substring(4)).toString(16);
-		while (result.length < 40) result = "0" + result;
-		return getChecksumAddress("0x" + result);
+	finish() {
+		if (this.finished) return;
+		this.finished = true;
+		const { state, suffix, pos, blockLen } = this;
+		state[pos] ^= suffix;
+		if ((suffix & 128) !== 0 && pos === blockLen - 1) this.keccak();
+		state[blockLen - 1] ^= 128;
+		this.keccak();
 	}
-	assertArgument(false, "invalid address", "address", address);
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/address/contract-address.js
+	writeInto(out) {
+		exists(this, false);
+		bytes(out);
+		this.finish();
+		const bufferOut = this.state;
+		const { blockLen } = this;
+		for (let pos = 0, len = out.length; pos < len;) {
+			if (this.posOut >= blockLen) this.keccak();
+			const take = Math.min(blockLen - this.posOut, len - pos);
+			out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+			this.posOut += take;
+			pos += take;
+		}
+		return out;
+	}
+	xofInto(out) {
+		if (!this.enableXOF) throw new Error("XOF is not possible for this instance");
+		return this.writeInto(out);
+	}
+	xof(bytes) {
+		number(bytes);
+		return this.xofInto(new Uint8Array(bytes));
+	}
+	digestInto(out) {
+		output(out, this);
+		if (this.finished) throw new Error("digest() was already called");
+		this.writeInto(out);
+		this.destroy();
+		return out;
+	}
+	digest() {
+		return this.digestInto(new Uint8Array(this.outputLen));
+	}
+	destroy() {
+		this.destroyed = true;
+		this.state.fill(0);
+	}
+	_cloneInto(to) {
+		const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+		to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+		to.state32.set(this.state32);
+		to.pos = this.pos;
+		to.posOut = this.posOut;
+		to.finished = this.finished;
+		to.rounds = rounds;
+		to.suffix = suffix;
+		to.outputLen = outputLen;
+		to.enableXOF = enableXOF;
+		to.destroyed = this.destroyed;
+		return to;
+	}
+};
+const gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
 /**
-*  Returns the address that would result from a ``CREATE`` for %%tx%%.
-*
-*  This can be used to compute the address a contract will be
-*  deployed to by an EOA when sending a deployment transaction (i.e.
-*  when the ``to`` address is ``null``).
-*
-*  This can also be used to compute the address a contract will be
-*  deployed to by a contract, by using the contract's address as the
-*  ``to`` and the contract's nonce.
-*
-*  @example
-*    from = "0x8ba1f109551bD432803012645Ac136ddd64DBA72";
-*    nonce = 5;
-*
-*    getCreateAddress({ from, nonce });
-*    //_result:
+* keccak-256 hash function. Different from SHA3-256.
+* @param message - that would be hashed
 */
-function getCreateAddress(tx) {
-	const from = getAddress(tx.from);
-	let nonceHex = getBigInt(tx.nonce, "tx.nonce").toString(16);
-	if (nonceHex === "0") nonceHex = "0x";
-	else if (nonceHex.length % 2) nonceHex = "0x0" + nonceHex;
-	else nonceHex = "0x" + nonceHex;
-	return getAddress(dataSlice(keccak256(encodeRlp([from, nonceHex])), 12));
-}
+const keccak_256 = /* @__PURE__ */ gen(1, 136, 256 / 8);
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/address/checks.js
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/crypto/keccak.js
 /**
-*  Returns true if %%value%% is an object which implements the
-*  [[Addressable]] interface.
-*
-*  @example:
-*    // Wallets and AbstractSigner sub-classes
-*    isAddressable(Wallet.createRandom())
-*    //_result:
+*  Cryptographic hashing functions
 *
-*    // Contracts
-*    contract = new Contract("dai.tokens.ethers.eth", [ ], provider)
-*    isAddressable(contract)
-*    //_result:
+*  @_subsection: api/crypto:Hash Functions [about-crypto-hashing]
 */
-function isAddressable(value) {
-	return value && typeof value.getAddress === "function";
-}
-async function checkAddress(target, promise) {
-	const result = await promise;
-	if (result == null || result === "0x0000000000000000000000000000000000000000") {
-		assert(typeof target !== "string", "unconfigured name", "UNCONFIGURED_NAME", { value: target });
-		assertArgument(false, "invalid AddressLike value; did not resolve to a value address", "target", target);
-	}
-	return getAddress(result);
-}
+let locked = false;
+const _keccak256 = function(data) {
+	return keccak_256(data);
+};
+let __keccak256 = _keccak256;
 /**
-*  Resolves to an address for the %%target%%, which may be any
-*  supported address type, an [[Addressable]] or a Promise which
-*  resolves to an address.
+*  Compute the cryptographic KECCAK256 hash of %%data%%.
 *
-*  If an ENS name is provided, but that name has not been correctly
-*  configured a [[UnconfiguredNameError]] is thrown.
+*  The %%data%% **must** be a data representation, to compute the
+*  hash of UTF-8 data use the [[id]] function.
 *
+*  @returns DataHexstring
 *  @example:
-*    addr = "0x6B175474E89094C44Da98b954EedeAC495271d0F"
-*
-*    // Addresses are return synchronously
-*    resolveAddress(addr, provider)
-*    //_result:
-*
-*    // Address promises are resolved asynchronously
-*    resolveAddress(Promise.resolve(addr))
+*    keccak256("0x")
 *    //_result:
 *
-*    // ENS names are resolved asynchronously
-*    resolveAddress("dai.tokens.ethers.eth", provider)
+*    keccak256("0x1337")
 *    //_result:
 *
-*    // Addressable objects are resolved asynchronously
-*    contract = new Contract(addr, [ ])
-*    resolveAddress(contract, provider)
+*    keccak256(new Uint8Array([ 0x13, 0x37 ]))
 *    //_result:
 *
-*    // Unconfigured ENS names reject
-*    resolveAddress("nothing-here.ricmoo.eth", provider)
-*    //_error:
-*
-*    // ENS names require a NameResolver object passed in
-*    // (notice the provider was omitted)
-*    resolveAddress("nothing-here.ricmoo.eth")
+*    // Strings are assumed to be DataHexString, otherwise it will
+*    // throw. To hash UTF-8 data, see the note above.
+*    keccak256("Hello World")
 *    //_error:
 */
-function resolveAddress(target, resolver) {
-	if (typeof target === "string") {
-		if (target.match(/^0x[0-9a-f]{40}$/i)) return getAddress(target);
-		assert(resolver != null, "ENS resolution requires a provider", "UNSUPPORTED_OPERATION", { operation: "resolveName" });
-		return checkAddress(target, resolver.resolveName(target));
-	} else if (isAddressable(target)) return checkAddress(target, target.getAddress());
-	else if (target && typeof target.then === "function") return checkAddress(target, target);
-	assertArgument(false, "unsupported addressable value", "target", target);
+function keccak256(_data) {
+	const data = getBytes(_data, "data");
+	return hexlify(__keccak256(data));
 }
+keccak256._ = _keccak256;
+keccak256.lock = function() {
+	locked = true;
+};
+keccak256.register = function(func) {
+	if (locked) throw new TypeError("keccak256 is locked");
+	__keccak256 = func;
+};
+Object.freeze(keccak256);
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/transaction/accesslist.js
-function accessSetify(addr, storageKeys) {
-	return {
-		address: getAddress(addr),
-		storageKeys: storageKeys.map((storageKey, index) => {
-			assertArgument(isHexString(storageKey, 32), "invalid slot", `storageKeys[${index}]`, storageKey);
-			return storageKey.toLowerCase();
-		})
-	};
-}
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/constants/hashes.js
 /**
-*  Returns a [[AccessList]] from any ethers-supported access-list structure.
+*  A constant for the zero hash.
+*
+*  (**i.e.** ``"0x0000000000000000000000000000000000000000000000000000000000000000"``)
 */
-function accessListify(value) {
-	if (Array.isArray(value)) return value.map((set, index) => {
-		if (Array.isArray(set)) {
-			assertArgument(set.length === 2, "invalid slot set", `value[${index}]`, set);
-			return accessSetify(set[0], set[1]);
-		}
-		assertArgument(set != null && typeof set === "object", "invalid address-slot set", "value", value);
-		return accessSetify(set.address, set.storageKeys);
-	});
-	assertArgument(value != null && typeof value === "object", "invalid access list", "value", value);
-	const result = Object.keys(value).map((addr) => {
-		const storageKeys = value[addr].reduce((accum, storageKey) => {
-			accum[storageKey] = true;
-			return accum;
-		}, {});
-		return accessSetify(addr, Object.keys(storageKeys).sort());
-	});
-	result.sort((a, b) => a.address.localeCompare(b.address));
-	return result;
-}
+const ZeroHash = "0x0000000000000000000000000000000000000000000000000000000000000000";
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/abi/coders/abstract-coder.js
-/**
-* @_ignore:
-*/
-const WordSize = 32;
-const Padding = new Uint8Array(32);
-const passProperties$1 = ["then"];
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/crypto/signature.js
+const BN_0$4 = BigInt(0);
+const BN_1$1 = BigInt(1);
+const BN_2 = BigInt(2);
+const BN_27 = BigInt(27);
+const BN_28 = BigInt(28);
+const BN_35 = BigInt(35);
+const BN_N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
+const BN_N_2 = BN_N / BN_2;
+const inspect = Symbol.for("nodejs.util.inspect.custom");
 const _guard$1 = {};
-const resultNames = /* @__PURE__ */ new WeakMap();
-function getNames(result) {
-	return resultNames.get(result);
-}
-function setNames(result, names) {
-	resultNames.set(result, names);
-}
-function throwError(name, error) {
-	const wrapped = /* @__PURE__ */ 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;
-	}, {});
+function toUint256(value) {
+	return zeroPadValue(toBeArray(value), 32);
 }
 /**
-*  A [[Result]] is a sub-class of Array, which allows accessing any
-*  of its values either positionally by its index or, if keys are
-*  provided by its name.
+*  A Signature  @TODO
 *
-*  @_docloc: api/abi
+*
+*  @_docloc: api/crypto:Signing
 */
-var Result = class Result extends Array {
-	#names;
+var Signature = class Signature {
+	#r;
+	#s;
+	#v;
+	#networkV;
 	/**
-	*  @private
+	*  The ``r`` value for a signature.
+	*
+	*  This represents the ``x`` coordinate of a "reference" or
+	*  challenge point, from which the ``y`` can be computed.
 	*/
-	constructor(...args) {
-		const guard = args[0];
-		let items = args[1];
-		let names = (args[2] || []).slice();
-		let wrap = true;
-		if (guard !== _guard$1) {
-			items = args;
-			names = [];
-			wrap = false;
-		}
-		super(items.length);
-		items.forEach((item, index) => {
-			this[index] = item;
-		});
-		const nameCounts = names.reduce((accum, name) => {
-			if (typeof name === "string") accum.set(name, (accum.get(name) || 0) + 1);
-			return accum;
-		}, /* @__PURE__ */ new Map());
-		setNames(this, Object.freeze(items.map((item, index) => {
-			const name = names[index];
-			if (name != null && nameCounts.get(name) === 1) return name;
-			return null;
-		})));
-		this.#names = [];
-		if (this.#names == null) this.#names;
-		if (!wrap) return;
-		Object.freeze(this);
-		const proxy = new Proxy(this, { get: (target, prop, receiver) => {
-			if (typeof prop === "string") {
-				if (prop.match(/^[0-9]+$/)) {
-					const index = getNumber(prop, "%index");
-					if (index < 0 || index >= this.length) throw new RangeError("out of result range");
-					const item = target[index];
-					if (item instanceof Error) throwError(`index ${index}`, item);
-					return item;
-				}
-				if (passProperties$1.indexOf(prop) >= 0) return Reflect.get(target, prop, receiver);
-				const value = target[prop];
-				if (value instanceof Function) return function(...args) {
-					return value.apply(this === receiver ? target : this, args);
-				};
-				else if (!(prop in target)) return target.getValue.apply(this === receiver ? target : this, [prop]);
-			}
-			return Reflect.get(target, prop, receiver);
-		} });
-		setNames(proxy, getNames(this));
-		return proxy;
+	get r() {
+		return this.#r;
+	}
+	set r(value) {
+		assertArgument(dataLength(value) === 32, "invalid r", "value", value);
+		this.#r = hexlify(value);
 	}
 	/**
-	*  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.
+	*  The ``s`` value for a signature.
 	*/
-	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;
+	get s() {
+		assertArgument(parseInt(this.#s.substring(0, 3)) < 8, "non-canonical s; use ._s", "s", this.#s);
+		return this.#s;
+	}
+	set s(_value) {
+		assertArgument(dataLength(_value) === 32, "invalid s", "value", _value);
+		this.#s = hexlify(_value);
 	}
 	/**
-	*  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.
+	*  Return the s value, unchecked for EIP-2 compliance.
 	*
-	*  This will throw if any value is unnamed, or if there are
-	*  any outstanding deferred errors.
+	*  This should generally not be used and is for situations where
+	*  a non-canonical S value might be relevant, such as Frontier blocks
+	*  that were mined prior to EIP-2 or invalid Authorization List
+	*  signatures.
 	*/
-	toObject(deep) {
-		const names = getNames(this);
-		return names.reduce((accum, name, index) => {
-			assert(name != null, `value at index ${index} unnamed`, "UNSUPPORTED_OPERATION", { operation: "toObject()" });
-			return toObject(names, this, deep);
-		}, {});
+	get _s() {
+		return this.#s;
 	}
 	/**
-	*  @_ignore
+	*  Returns true if the Signature is valid for [[link-eip-2]] signatures.
 	*/
-	slice(start, end) {
-		if (start == null) start = 0;
-		if (start < 0) {
-			start += this.length;
-			if (start < 0) start = 0;
-		}
-		if (end == null) end = this.length;
-		if (end < 0) {
-			end += this.length;
-			if (end < 0) end = 0;
-		}
-		if (end > this.length) end = this.length;
-		const _names = getNames(this);
-		const result = [];
-		const names = [];
-		for (let i = start; i < end; i++) {
-			result.push(this[i]);
-			names.push(_names[i]);
-		}
-		return new Result(_guard$1, result, names);
+	isValid() {
+		return BigInt(this.#s) <= BN_N_2;
 	}
 	/**
-	*  @_ignore
+	*  The ``v`` value for a signature.
+	*
+	*  Since a given ``x`` value for ``r`` has two possible values for
+	*  its correspondin ``y``, the ``v`` indicates which of the two ``y``
+	*  values to use.
+	*
+	*  It is normalized to the values ``27`` or ``28`` for legacy
+	*  purposes.
 	*/
-	filter(callback, thisArg) {
-		const _names = getNames(this);
-		const result = [];
-		const names = [];
-		for (let i = 0; i < this.length; i++) {
-			const item = this[i];
-			if (item instanceof Error) throwError(`index ${i}`, item);
-			if (callback.call(thisArg, item, i, this)) {
-				result.push(item);
-				names.push(_names[i]);
-			}
-		}
-		return new Result(_guard$1, result, names);
+	get v() {
+		return this.#v;
+	}
+	set v(value) {
+		const v = getNumber(value, "value");
+		assertArgument(v === 27 || v === 28, "invalid v", "v", value);
+		this.#v = v;
 	}
 	/**
-	*  @_ignore
+	*  The EIP-155 ``v`` for legacy transactions. For non-legacy
+	*  transactions, this value is ``null``.
 	*/
-	map(callback, thisArg) {
-		const result = [];
-		for (let i = 0; i < this.length; i++) {
-			const item = this[i];
-			if (item instanceof Error) throwError(`index ${i}`, item);
-			result.push(callback.call(thisArg, item, i, this));
-		}
-		return result;
+	get networkV() {
+		return this.#networkV;
 	}
 	/**
-	*  Returns the value for %%name%%.
-	*
-	*  Since it is possible to have a key whose name conflicts with
-	*  a method on a [[Result]] or its superclass Array, or any
-	*  JavaScript keyword, this ensures all named values are still
-	*  accessible by name.
+	*  The chain ID for EIP-155 legacy transactions. For non-legacy
+	*  transactions, this value is ``null``.
 	*/
-	getValue(name) {
-		const index = getNames(this).indexOf(name);
-		if (index === -1) return;
-		const value = this[index];
-		if (value instanceof Error) throwError(`property ${JSON.stringify(name)}`, value.error);
-		return value;
+	get legacyChainId() {
+		const v = this.networkV;
+		if (v == null) return null;
+		return Signature.getChainId(v);
 	}
 	/**
-	*  Creates a new [[Result]] for %%items%% with each entry
-	*  also accessible by its corresponding name in %%keys%%.
+	*  The ``yParity`` for the signature.
+	*
+	*  See ``v`` for more details on how this value is used.
 	*/
-	static fromItems(items, keys) {
-		return new Result(_guard$1, items, keys);
-	}
-};
-function getValue$1(value) {
-	let bytes = toBeArray(value);
-	assert(bytes.length <= 32, "value out-of-bounds", "BUFFER_OVERRUN", {
-		buffer: bytes,
-		length: 32,
-		offset: bytes.length
-	});
-	if (bytes.length !== 32) bytes = getBytesCopy(concat([Padding.slice(bytes.length % 32), bytes]));
-	return bytes;
-}
-__name(getValue$1, "getValue");
-/**
-*  @_ignore
-*/
-var Coder = class {
-	name;
-	type;
-	localName;
-	dynamic;
-	constructor(name, type, localName, dynamic) {
-		defineProperties(this, {
-			name,
-			type,
-			localName,
-			dynamic
-		}, {
-			name: "string",
-			type: "string",
-			localName: "string",
-			dynamic: "boolean"
-		});
-	}
-	_throwError(message, value) {
-		assertArgument(false, message, this.localName, value);
-	}
-};
-/**
-*  @_ignore
-*/
-var Writer = class {
-	#data;
-	#dataLength;
-	constructor() {
-		this.#data = [];
-		this.#dataLength = 0;
+	get yParity() {
+		return this.v === 27 ? 0 : 1;
 	}
-	get data() {
-		return concat(this.#data);
+	/**
+	*  The [[link-eip-2098]] compact representation of the ``yParity``
+	*  and ``s`` compacted into a single ``bytes32``.
+	*/
+	get yParityAndS() {
+		const yParityAndS = getBytes(this.s);
+		if (this.yParity) yParityAndS[0] |= 128;
+		return hexlify(yParityAndS);
 	}
-	get length() {
-		return this.#dataLength;
+	/**
+	*  The [[link-eip-2098]] compact representation.
+	*/
+	get compactSerialized() {
+		return concat([this.r, this.yParityAndS]);
 	}
-	#writeData(data) {
-		this.#data.push(data);
-		this.#dataLength += data.length;
-		return data.length;
+	/**
+	*  The serialized representation.
+	*/
+	get serialized() {
+		return concat([
+			this.r,
+			this.s,
+			this.yParity ? "0x1c" : "0x1b"
+		]);
 	}
-	appendWriter(writer) {
-		return this.#writeData(getBytesCopy(writer.data));
+	/**
+	*  @private
+	*/
+	constructor(guard, r, s, v) {
+		assertPrivate(guard, _guard$1, "Signature");
+		this.#r = r;
+		this.#s = s;
+		this.#v = v;
+		this.#networkV = null;
 	}
-	writeBytes(value) {
-		let bytes = getBytesCopy(value);
-		const paddingOffset = bytes.length % 32;
-		if (paddingOffset) bytes = getBytesCopy(concat([bytes, Padding.slice(paddingOffset)]));
-		return this.#writeData(bytes);
+	/**
+	*  Returns the canonical signature.
+	*
+	*  This is only necessary when dealing with legacy transaction which
+	*  did not enforce canonical S values (i.e. [[link-eip-2]]. Most
+	*  developers should never require this.
+	*/
+	getCanonical() {
+		if (this.isValid()) return this;
+		const s = BN_N - BigInt(this._s);
+		const v = 55 - this.v;
+		const result = new Signature(_guard$1, this.r, toUint256(s), v);
+		if (this.networkV) result.#networkV = this.networkV;
+		return result;
 	}
-	writeValue(value) {
-		return this.#writeData(getValue$1(value));
+	/**
+	*  Returns a new identical [[Signature]].
+	*/
+	clone() {
+		const clone = new Signature(_guard$1, this.r, this._s, this.v);
+		if (this.networkV) clone.#networkV = this.networkV;
+		return clone;
 	}
-	writeUpdatableValue() {
-		const offset = this.#data.length;
-		this.#data.push(Padding);
-		this.#dataLength += 32;
-		return (value) => {
-			this.#data[offset] = getValue$1(value);
+	/**
+	*  Returns a representation that is compatible with ``JSON.stringify``.
+	*/
+	toJSON() {
+		const networkV = this.networkV;
+		return {
+			_type: "signature",
+			networkV: networkV != null ? networkV.toString() : null,
+			r: this.r,
+			s: this._s,
+			v: this.v
 		};
 	}
-};
-/**
-*  @_ignore
-*/
-var Reader = class Reader {
-	allowLoose;
-	#data;
-	#offset;
-	#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;
+	[inspect]() {
+		return this.toString();
 	}
-	get data() {
-		return hexlify(this.#data);
+	toString() {
+		if (this.isValid()) return `Signature { r: ${this.r}, s: ${this._s}, v: ${this.v} }`;
+		return `Signature { r: ${this.r}, s: ${this._s}, v: ${this.v}, valid: false }`;
 	}
-	get dataLength() {
-		return this.#data.length;
+	/**
+	*  Compute the chain ID from the ``v`` in a legacy EIP-155 transactions.
+	*
+	*  @example:
+	*    Signature.getChainId(45)
+	*    //_result:
+	*
+	*    Signature.getChainId(46)
+	*    //_result:
+	*/
+	static getChainId(v) {
+		const bv = getBigInt(v, "v");
+		if (bv == BN_27 || bv == BN_28) return BN_0$4;
+		assertArgument(bv >= BN_35, "invalid EIP-155 v", "v", v);
+		return (bv - BN_35) / BN_2;
 	}
-	get consumed() {
-		return this.#offset;
+	/**
+	*  Compute the ``v`` for a chain ID for a legacy EIP-155 transactions.
+	*
+	*  Legacy transactions which use [[link-eip-155]] hijack the ``v``
+	*  property to include the chain ID.
+	*
+	*  @example:
+	*    Signature.getChainIdV(5, 27)
+	*    //_result:
+	*
+	*    Signature.getChainIdV(5, 28)
+	*    //_result:
+	*
+	*/
+	static getChainIdV(chainId, v) {
+		return getBigInt(chainId) * BN_2 + BigInt(35 + v - 27);
 	}
-	get bytes() {
-		return new Uint8Array(this.#data);
+	/**
+	*  Compute the normalized legacy transaction ``v`` from a ``yParirty``,
+	*  a legacy transaction ``v`` or a legacy [[link-eip-155]] transaction.
+	*
+	*  @example:
+	*    // The values 0 and 1 imply v is actually yParity
+	*    Signature.getNormalizedV(0)
+	*    //_result:
+	*
+	*    // Legacy non-EIP-1559 transaction (i.e. 27 or 28)
+	*    Signature.getNormalizedV(27)
+	*    //_result:
+	*
+	*    // Legacy EIP-155 transaction (i.e. >= 35)
+	*    Signature.getNormalizedV(46)
+	*    //_result:
+	*
+	*    // Invalid values throw
+	*    Signature.getNormalizedV(5)
+	*    //_error:
+	*/
+	static getNormalizedV(v) {
+		const bv = getBigInt(v);
+		if (bv === BN_0$4 || bv === BN_27) return 27;
+		if (bv === BN_1$1 || bv === BN_28) return 28;
+		assertArgument(bv >= BN_35, "invalid v", "v", v);
+		return bv & BN_1$1 ? 27 : 28;
 	}
-	#incrementBytesRead(count) {
-		if (this.#parent) return this.#parent.#incrementBytesRead(count);
-		this.#bytesRead += count;
-		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
+	/**
+	*  Creates a new [[Signature]].
+	*
+	*  If no %%sig%% is provided, a new [[Signature]] is created
+	*  with default values.
+	*
+	*  If %%sig%% is a string, it is parsed.
+	*/
+	static from(sig) {
+		function assertError(check, message) {
+			assertArgument(check, message, "signature", sig);
+		}
+		if (sig == null) return new Signature(_guard$1, ZeroHash, ZeroHash, 27);
+		if (typeof sig === "string") {
+			const bytes = getBytes(sig, "signature");
+			if (bytes.length === 64) {
+				const r = hexlify(bytes.slice(0, 32));
+				const s = bytes.slice(32, 64);
+				const v = s[0] & 128 ? 28 : 27;
+				s[0] &= 127;
+				return new Signature(_guard$1, r, hexlify(s), v);
 			}
-		});
+			if (bytes.length === 65) return new Signature(_guard$1, hexlify(bytes.slice(0, 32)), hexlify(bytes.slice(32, 64)), Signature.getNormalizedV(bytes[64]));
+			assertError(false, "invalid raw signature length");
+		}
+		if (sig instanceof Signature) return sig.clone();
+		const _r = sig.r;
+		assertError(_r != null, "missing r");
+		const r = toUint256(_r);
+		const s = (function(s, yParityAndS) {
+			if (s != null) return toUint256(s);
+			if (yParityAndS != null) {
+				assertError(isHexString(yParityAndS, 32), "invalid yParityAndS");
+				const bytes = getBytes(yParityAndS);
+				bytes[0] &= 127;
+				return hexlify(bytes);
+			}
+			assertError(false, "missing s");
+		})(sig.s, sig.yParityAndS);
+		const { networkV, v } = (function(_v, yParityAndS, yParity) {
+			if (_v != null) {
+				const v = getBigInt(_v);
+				return {
+					networkV: v >= BN_35 ? v : void 0,
+					v: Signature.getNormalizedV(v)
+				};
+			}
+			if (yParityAndS != null) {
+				assertError(isHexString(yParityAndS, 32), "invalid yParityAndS");
+				return { v: getBytes(yParityAndS)[0] & 128 ? 28 : 27 };
+			}
+			if (yParity != null) {
+				switch (getNumber(yParity, "sig.yParity")) {
+					case 0: return { v: 27 };
+					case 1: return { v: 28 };
+				}
+				assertError(false, "invalid yParity");
+			}
+			assertError(false, "missing v");
+		})(sig.v, sig.yParityAndS, sig.yParity);
+		const result = new Signature(_guard$1, r, s, v);
+		if (networkV) result.#networkV = networkV;
+		assertError(sig.yParity == null || getNumber(sig.yParity, "sig.yParity") === result.yParity, "yParity mismatch");
+		assertError(sig.yParityAndS == null || sig.yParityAndS === result.yParityAndS, "yParityAndS mismatch");
+		return result;
 	}
-	#peekBytes(offset, length, loose) {
-		let alignedLength = Math.ceil(length / 32) * 32;
-		if (this.#offset + alignedLength > this.#data.length) if (this.allowLoose && loose && this.#offset + length <= this.#data.length) alignedLength = length;
-		else assert(false, "data out-of-bounds", "BUFFER_OVERRUN", {
-			buffer: getBytesCopy(this.#data),
-			length: this.#data.length,
-			offset: this.#offset + alignedLength
-		});
-		return this.#data.slice(this.#offset, this.#offset + alignedLength);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/address/address.js
+const BN_0$3 = BigInt(0);
+const BN_36 = BigInt(36);
+function getChecksumAddress(address) {
+	address = address.toLowerCase();
+	const chars = address.substring(2).split("");
+	const expanded = /* @__PURE__ */ new Uint8Array(40);
+	for (let i = 0; i < 40; i++) expanded[i] = chars[i].charCodeAt(0);
+	const hashed = getBytes(keccak256(expanded));
+	for (let i = 0; i < 40; i += 2) {
+		if (hashed[i >> 1] >> 4 >= 8) chars[i] = chars[i].toUpperCase();
+		if ((hashed[i >> 1] & 15) >= 8) chars[i + 1] = chars[i + 1].toUpperCase();
 	}
-	subReader(offset) {
-		const reader = new Reader(this.#data.slice(this.#offset + offset), this.allowLoose, this.#maxInflation);
-		reader.#parent = this;
-		return reader;
+	return "0x" + chars.join("");
+}
+const ibanLookup = {};
+for (let i = 0; i < 10; i++) ibanLookup[String(i)] = String(i);
+for (let i = 0; i < 26; i++) ibanLookup[String.fromCharCode(65 + i)] = String(10 + i);
+const safeDigits = 15;
+function ibanChecksum(address) {
+	address = address.toUpperCase();
+	address = address.substring(4) + address.substring(0, 2) + "00";
+	let expanded = address.split("").map((c) => {
+		return ibanLookup[c];
+	}).join("");
+	while (expanded.length >= safeDigits) {
+		let block = expanded.substring(0, safeDigits);
+		expanded = parseInt(block, 10) % 97 + expanded.substring(block.length);
 	}
-	readBytes(length, loose) {
-		let bytes = this.#peekBytes(0, length, !!loose);
-		this.#incrementBytesRead(length);
-		this.#offset += bytes.length;
-		return bytes.slice(0, length);
+	let checksum = String(98 - parseInt(expanded, 10) % 97);
+	while (checksum.length < 2) checksum = "0" + checksum;
+	return checksum;
+}
+const Base36 = (function() {
+	const result = {};
+	for (let i = 0; i < 36; i++) {
+		const key = "0123456789abcdefghijklmnopqrstuvwxyz"[i];
+		result[key] = BigInt(i);
+	}
+	return result;
+})();
+function fromBase36(value) {
+	value = value.toLowerCase();
+	let result = BN_0$3;
+	for (let i = 0; i < value.length; i++) result = result * BN_36 + Base36[value[i]];
+	return result;
+}
+/**
+*  Returns a normalized and checksumed address for %%address%%.
+*  This accepts non-checksum addresses, checksum addresses and
+*  [[getIcapAddress]] formats.
+*
+*  The checksum in Ethereum uses the capitalization (upper-case
+*  vs lower-case) of the characters within an address to encode
+*  its checksum, which offers, on average, a checksum of 15-bits.
+*
+*  If %%address%% contains both upper-case and lower-case, it is
+*  assumed to already be a checksum address and its checksum is
+*  validated, and if the address fails its expected checksum an
+*  error is thrown.
+*
+*  If you wish the checksum of %%address%% to be ignore, it should
+*  be converted to lower-case (i.e. ``.toLowercase()``) before
+*  being passed in. This should be a very rare situation though,
+*  that you wish to bypass the safegaurds in place to protect
+*  against an address that has been incorrectly copied from another
+*  source.
+*
+*  @example:
+*    // Adds the checksum (via upper-casing specific letters)
+*    getAddress("0x8ba1f109551bd432803012645ac136ddd64dba72")
+*    //_result:
+*
+*    // Converts ICAP address and adds checksum
+*    getAddress("XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36");
+*    //_result:
+*
+*    // Throws an error if an address contains mixed case,
+*    // but the checksum fails
+*    getAddress("0x8Ba1f109551bD432803012645Ac136ddd64DBA72")
+*    //_error:
+*/
+function getAddress(address) {
+	assertArgument(typeof address === "string", "invalid address", "address", address);
+	if (address.match(/^(0x)?[0-9a-fA-F]{40}$/)) {
+		if (!address.startsWith("0x")) address = "0x" + address;
+		const result = getChecksumAddress(address);
+		assertArgument(!address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) || result === address, "bad address checksum", "address", address);
+		return result;
 	}
-	readValue() {
-		return toBigInt(this.readBytes(32));
+	if (address.match(/^XE[0-9]{2}[0-9A-Za-z]{30,31}$/)) {
+		assertArgument(address.substring(2, 4) === ibanChecksum(address), "bad icap checksum", "address", address);
+		let result = fromBase36(address.substring(4)).toString(16);
+		while (result.length < 40) result = "0" + result;
+		return getChecksumAddress("0x" + result);
 	}
-	readIndex() {
-		return toNumber(this.readBytes(32));
+	assertArgument(false, "invalid address", "address", address);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/address/checks.js
+/**
+*  Returns true if %%value%% is an object which implements the
+*  [[Addressable]] interface.
+*
+*  @example:
+*    // Wallets and AbstractSigner sub-classes
+*    isAddressable(Wallet.createRandom())
+*    //_result:
+*
+*    // Contracts
+*    contract = new Contract("dai.tokens.ethers.eth", [ ], provider)
+*    isAddressable(contract)
+*    //_result:
+*/
+function isAddressable(value) {
+	return value && typeof value.getAddress === "function";
+}
+async function checkAddress(target, promise) {
+	const result = await promise;
+	if (result == null || result === "0x0000000000000000000000000000000000000000") {
+		assert(typeof target !== "string", "unconfigured name", "UNCONFIGURED_NAME", { value: target });
+		assertArgument(false, "invalid AddressLike value; did not resolve to a value address", "target", target);
 	}
-};
+	return getAddress(result);
+}
+/**
+*  Resolves to an address for the %%target%%, which may be any
+*  supported address type, an [[Addressable]] or a Promise which
+*  resolves to an address.
+*
+*  If an ENS name is provided, but that name has not been correctly
+*  configured a [[UnconfiguredNameError]] is thrown.
+*
+*  @example:
+*    addr = "0x6B175474E89094C44Da98b954EedeAC495271d0F"
+*
+*    // Addresses are return synchronously
+*    resolveAddress(addr, provider)
+*    //_result:
+*
+*    // Address promises are resolved asynchronously
+*    resolveAddress(Promise.resolve(addr))
+*    //_result:
+*
+*    // ENS names are resolved asynchronously
+*    resolveAddress("dai.tokens.ethers.eth", provider)
+*    //_result:
+*
+*    // Addressable objects are resolved asynchronously
+*    contract = new Contract(addr, [ ])
+*    resolveAddress(contract, provider)
+*    //_result:
+*
+*    // Unconfigured ENS names reject
+*    resolveAddress("nothing-here.ricmoo.eth", provider)
+*    //_error:
+*
+*    // ENS names require a NameResolver object passed in
+*    // (notice the provider was omitted)
+*    resolveAddress("nothing-here.ricmoo.eth")
+*    //_error:
+*/
+function resolveAddress(target, resolver) {
+	if (typeof target === "string") {
+		if (target.match(/^0x[0-9a-f]{40}$/i)) return getAddress(target);
+		assert(resolver != null, "ENS resolution requires a provider", "UNSUPPORTED_OPERATION", { operation: "resolveName" });
+		return checkAddress(target, resolver.resolveName(target));
+	} else if (isAddressable(target)) return checkAddress(target, target.getAddress());
+	else if (target && typeof target.then === "function") return checkAddress(target, target);
+	assertArgument(false, "unsupported addressable value", "target", target);
+}
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/abi/typed.js
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/abi/typed.js
 /**
 *  A Typed object allows a value to have its type explicitly
 *  specified.
@@ -2836,7 +2791,7 @@ var Typed = class Typed {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/abi/coders/address.js
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/abi/coders/address.js
 /**
 *  @_ignore
 */
@@ -2862,7 +2817,7 @@ var AddressCoder = class extends Coder {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/abi/coders/anonymous.js
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/abi/coders/anonymous.js
 /**
 *  Clones the functionality of an existing Coder, but without a localName
 *
@@ -2886,7 +2841,7 @@ var AnonymousCoder = class extends Coder {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/abi/coders/array.js
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/abi/coders/array.js
 /**
 *  @_ignore
 */
@@ -3020,7 +2975,7 @@ var ArrayCoder = class extends Coder {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/abi/coders/boolean.js
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/abi/coders/boolean.js
 /**
 *  @_ignore
 */
@@ -3041,7 +2996,7 @@ var BooleanCoder = class extends Coder {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/abi/coders/bytes.js
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/abi/coders/bytes.js
 /**
 *  @_ignore
 */
@@ -3075,7 +3030,7 @@ var BytesCoder = class extends DynamicBytesCoder {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/abi/coders/fixed-bytes.js
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/abi/coders/fixed-bytes.js
 /**
 *  @_ignore
 */
@@ -3100,7 +3055,7 @@ var FixedBytesCoder = class extends Coder {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/abi/coders/null.js
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/abi/coders/null.js
 const Empty = new Uint8Array([]);
 /**
 *  @_ignore
@@ -3123,8 +3078,8 @@ var NullCoder = class extends Coder {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/abi/coders/number.js
-const BN_0$3 = BigInt(0);
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/abi/coders/number.js
+const BN_0$2 = BigInt(0);
 const BN_1 = BigInt(1);
 const BN_MAX_UINT256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 /**
@@ -3154,7 +3109,7 @@ var NumberCoder = class extends Coder {
 			let bounds = mask(maxUintValue, this.size * 8 - 1);
 			if (value > bounds || value < -(bounds + BN_1)) this._throwError("value out-of-bounds", _value);
 			value = toTwos(value, 8 * 32);
-		} else if (value < BN_0$3 || value > mask(maxUintValue, this.size * 8)) this._throwError("value out-of-bounds", _value);
+		} else if (value < BN_0$2 || value > mask(maxUintValue, this.size * 8)) this._throwError("value out-of-bounds", _value);
 		return writer.writeValue(value);
 	}
 	decode(reader) {
@@ -3165,7 +3120,7 @@ var NumberCoder = class extends Coder {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/abi/coders/string.js
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/abi/coders/string.js
 /**
 *  @_ignore
 */
@@ -3185,7 +3140,7 @@ var StringCoder = class extends DynamicBytesCoder {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/abi/coders/tuple.js
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/abi/coders/tuple.js
 /**
 *  @_ignore
 */
@@ -3234,7 +3189,7 @@ var TupleCoder = class extends Coder {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/hash/id.js
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/hash/id.js
 /**
 *  A simple hashing function which operates on UTF-8 strings to
 *  compute an 32-byte identifier.
@@ -3251,7 +3206,42 @@ function id(value) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/abi/fragments.js
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/transaction/accesslist.js
+function accessSetify(addr, storageKeys) {
+	return {
+		address: getAddress(addr),
+		storageKeys: storageKeys.map((storageKey, index) => {
+			assertArgument(isHexString(storageKey, 32), "invalid slot", `storageKeys[${index}]`, storageKey);
+			return storageKey.toLowerCase();
+		})
+	};
+}
+/**
+*  Returns a [[AccessList]] from any ethers-supported access-list structure.
+*/
+function accessListify(value) {
+	if (Array.isArray(value)) return value.map((set, index) => {
+		if (Array.isArray(set)) {
+			assertArgument(set.length === 2, "invalid slot set", `value[${index}]`, set);
+			return accessSetify(set[0], set[1]);
+		}
+		assertArgument(set != null && typeof set === "object", "invalid address-slot set", "value", value);
+		return accessSetify(set.address, set.storageKeys);
+	});
+	assertArgument(value != null && typeof value === "object", "invalid access list", "value", value);
+	const result = Object.keys(value).map((addr) => {
+		const storageKeys = value[addr].reduce((accum, storageKey) => {
+			accum[storageKey] = true;
+			return accum;
+		}, {});
+		return accessSetify(addr, Object.keys(storageKeys).sort());
+	});
+	result.sort((a, b) => a.address.localeCompare(b.address));
+	return result;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/abi/fragments.js
 /**
 *  A fragment is a single item from an ABI, which may represent any of:
 *
@@ -3792,10 +3782,10 @@ var ParamType = class ParamType {
 		const name = obj.name;
 		assertArgument(!name || typeof name === "string" && name.match(regexId), "invalid name", "obj.name", name);
 		let indexed = obj.indexed;
-		if (indexed == true) {
+		if (indexed != null) {
 			assertArgument(allowIndexed, "parameter cannot be indexed", "obj.indexed", obj.indexed);
-			indexed = true;
-		} else indexed = false;
+			indexed = !!indexed;
+		}
 		let type = obj.type;
 		let arrayMatch = type.match(regexArrayType);
 		if (arrayMatch) {
@@ -4364,7 +4354,7 @@ var StructFragment = class StructFragment extends NamedFragment {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/abi/abi-coder.js
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/abi/abi-coder.js
 /**
 *  When sending values to or receiving values from a [[Contract]], the
 *  data is generally encoded using the [ABI standard](link-solc-abi).
@@ -4528,7 +4518,7 @@ var AbiCoder = class AbiCoder {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/abi/interface.js
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/abi/interface.js
 /**
 *  The Interface class is a low-level class that accepts an
 *  ABI and provides all the necessary functionality to encode
@@ -5379,8 +5369,8 @@ var Interface = class Interface {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/providers/provider.js
-const BN_0$2 = BigInt(0);
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/providers/provider.js
+const BN_0$1 = BigInt(0);
 function getValue(value) {
 	if (value == null) return null;
 	return value;
@@ -5465,11 +5455,13 @@ function copyRequest(req) {
 		result[key] = getNumber(req[key], `request.${key}`);
 	}
 	if (req.accessList) result.accessList = accessListify(req.accessList);
+	if (req.authorizationList) result.authorizationList = req.authorizationList.slice();
 	if ("blockTag" in req) result.blockTag = req.blockTag;
 	if ("enableCcipRead" in req) result.enableCcipRead = !!req.enableCcipRead;
 	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 ("blobWrapperVersion" in req) result.blobWrapperVersion = req.blobWrapperVersion;
 	if ("blobs" in req && req.blobs) result.blobs = req.blobs.map((b) => {
 		if (isBytesLike(b)) return hexlify(b);
 		return Object.assign({}, b);
@@ -5547,6 +5539,10 @@ var Block = class {
 	*/
 	receiptsRoot;
 	/**
+	*  The hash of the transactions.
+	*/
+	transactionsRoot;
+	/**
 	*  The total amount of blob gas consumed by the transactions
 	*  within the block. See [[link-eip-4844]].
 	*/
@@ -5608,7 +5604,8 @@ var Block = class {
 			extraData: block.extraData,
 			baseFeePerGas: getValue(block.baseFeePerGas),
 			stateRoot: block.stateRoot,
-			receiptsRoot: block.receiptsRoot
+			receiptsRoot: block.receiptsRoot,
+			transactionsRoot: block.transactionsRoot
 		});
 	}
 	/**
@@ -5639,7 +5636,7 @@ var Block = class {
 	*  Returns a JSON-friendly value.
 	*/
 	toJSON() {
-		const { baseFeePerGas, difficulty, extraData, gasLimit, gasUsed, hash, miner, prevRandao, nonce, number, parentHash, parentBeaconBlockRoot, stateRoot, receiptsRoot, timestamp, transactions } = this;
+		const { baseFeePerGas, difficulty, extraData, gasLimit, gasUsed, hash, miner, prevRandao, nonce, number, parentHash, parentBeaconBlockRoot, stateRoot, receiptsRoot, transactionsRoot, timestamp, transactions } = this;
 		return {
 			_type: "Block",
 			baseFeePerGas: toJson(baseFeePerGas),
@@ -5659,6 +5656,7 @@ var Block = class {
 			parentBeaconBlockRoot,
 			stateRoot,
 			receiptsRoot,
+			transactionsRoot,
 			transactions
 		};
 	}
@@ -5702,7 +5700,7 @@ var Block = class {
 				tx = v;
 				break;
 			} else {
-				if (v.hash === hash) continue;
+				if (v.hash !== hash) continue;
 				tx = v;
 				break;
 			}
@@ -5980,7 +5978,7 @@ var TransactionReceipt = class {
 		this.#logs = Object.freeze(tx.logs.map((log) => {
 			return new Log(log, provider);
 		}));
-		let gasPrice = BN_0$2;
+		let gasPrice = BN_0$1;
 		if (tx.effectiveGasPrice != null) gasPrice = tx.effectiveGasPrice;
 		else if (tx.gasPrice != null) gasPrice = tx.gasPrice;
 		defineProperties(this, {
@@ -6228,6 +6226,10 @@ var TransactionResponse = class TransactionResponse {
 	*  The [[link-eip-4844]] BLOb versioned hashes.
 	*/
 	blobVersionedHashes;
+	/**
+	*  The [[link-eip-7702]] authorizations (if any).
+	*/
+	authorizationList;
 	#startBlock;
 	/**
 	*  @_ignore:
@@ -6253,6 +6255,7 @@ var TransactionResponse = class TransactionResponse {
 		this.signature = tx.signature;
 		this.accessList = tx.accessList != null ? tx.accessList : null;
 		this.blobVersionedHashes = tx.blobVersionedHashes != null ? tx.blobVersionedHashes : null;
+		this.authorizationList = tx.authorizationList != null ? tx.authorizationList : null;
 		this.#startBlock = -1;
 	}
 	/**
@@ -6367,7 +6370,7 @@ var TransactionResponse = class TransactionResponse {
 						if (blockNumber - receipt.blockNumber + 1 < confirms) return;
 						let reason = "replaced";
 						if (tx.data === this.data && tx.to === this.to && tx.value === this.value) reason = "repriced";
-						else if (tx.data === "0x" && tx.from === tx.to && tx.value === BN_0$2) reason = "cancelled";
+						else if (tx.data === "0x" && tx.from === tx.to && tx.value === BN_0$1) reason = "cancelled";
 						assert(false, "transaction was replaced", "TRANSACTION_REPLACED", {
 							cancelled: reason === "replaced" || reason === "cancelled",
 							reason,
@@ -6399,7 +6402,7 @@ var TransactionResponse = class TransactionResponse {
 		const receipt = await this.provider.getTransactionReceipt(this.hash);
 		if (confirms === 0) return checkReceipt(receipt);
 		if (receipt) {
-			if (await receipt.confirmations() >= confirms) return checkReceipt(receipt);
+			if (confirms === 1 || await receipt.confirmations() >= confirms) return checkReceipt(receipt);
 		} else {
 			await checkReplacement();
 			if (confirms === 0) return null;
@@ -6575,7 +6578,7 @@ function createRemovedLogFilter(log) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/contract/wrappers.js
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/contract/wrappers.js
 /**
 *  An **EventLog** contains additional properties parsed from the [[Log]].
 */
@@ -6756,8 +6759,8 @@ var ContractEventPayload = class extends ContractUnknownEventPayload {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/contract/contract.js
-const BN_0$1 = BigInt(0);
+//#region ../../node_modules/.pnpm/ethers@6.17.0_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/ethers/lib.esm/contract/contract.js
+const BN_0 = BigInt(0);
 function canCall(value) {
 	return value && typeof value.call === "function";
 }
@@ -6844,7 +6847,7 @@ function buildWrappedFallback(contract) {
 		tx.to = await contract.getAddress();
 		if (tx.from) tx.from = await resolveAddress(tx.from, getResolver(contract.runner));
 		const iface = contract.interface;
-		const noValue = getBigInt(tx.value || BN_0$1, "overrides.value") === BN_0$1;
+		const noValue = getBigInt(tx.value || BN_0, "overrides.value") === BN_0;
 		const noData = (tx.data || "0x") === "0x";
 		if (iface.fallback && !iface.fallback.payable && iface.receive && !noData && !noValue) assertArgument(false, "cannot send data to receive or send value to non-payable fallback", "overrides", overrides);
 		assertArgument(iface.fallback || noData, "cannot send data to receive-only contract", "overrides.data", tx.data);
@@ -6933,14 +6936,7 @@ function buildWrappedMethod(contract, key) {
 	const staticCallResult = async function(...args) {
 		const runner = getRunner(contract.runner, "call");
 		assert(canCall(runner), "contract runner does not support calling", "UNSUPPORTED_OPERATION", { operation: "call" });
-		let tx;
-		try {
-			tx = await populateTransaction(...args);
-		} catch (e) {
-			const blockNumber = args.at(-1).blockTag;
-			if (blockNumber) e.blockNumber = blockNumber;
-			throw e;
-		}
+		const tx = await populateTransaction(...args);
 		let result = "0x";
 		try {
 			result = await runner.call(tx);
@@ -7159,7 +7155,7 @@ var BaseContract = class BaseContract {
 	*  The target to connect to.
 	*
 	*  This can be an address, ENS name or any [[Addressable]], such as
-	*  another contract. To get the resovled address, use the ``getAddress``
+	*  another contract. To get the resolved address, use the ``getAddress``
 	*  method.
 	*/
 	target;
@@ -7331,7 +7327,7 @@ var BaseContract = class BaseContract {
 	/**
 	*  Return the function for a given name. This is useful when a contract
 	*  method name conflicts with a JavaScript name such as ``prototype`` or
-	*  when using a Contract programatically.
+	*  when using a Contract programmatically.
 	*/
 	getFunction(key) {
 		if (typeof key !== "string") key = key.format();
@@ -7340,7 +7336,7 @@ var BaseContract = class BaseContract {
 	/**
 	*  Return the event for a given name. This is useful when a contract
 	*  event name conflicts with a JavaScript name such as ``prototype`` or
-	*  when using a Contract programatically.
+	*  when using a Contract programmatically.
 	*/
 	getEvent(key) {
 		if (typeof key !== "string") key = key.format();
@@ -7522,190 +7518,6 @@ function _ContractBase() {
 */
 var Contract = class extends _ContractBase() {};
 
-//#endregion
-//#region ../../node_modules/.pnpm/@sentio+ethers@6.13.1-patch.6_bufferutil@4.0.8_utf-8-validate@5.0.10/node_modules/@sentio/ethers/lib.esm/providers/format.js
-/**
-*  @_ignore
-*/
-const BN_0 = BigInt(0);
-function allowNull(format, nullValue) {
-	return (function(value) {
-		if (value == null) return nullValue;
-		return format(value);
-	});
-}
-function arrayOf(format, allowNull) {
-	return ((array) => {
-		if (allowNull && array == null) return null;
-		if (!Array.isArray(array)) throw new Error("not an array");
-		return array.map((i) => format(i));
-	});
-}
-function object(format, altNames) {
-	return ((value) => {
-		const result = {};
-		for (const key in format) {
-			let srcKey = key;
-			if (altNames && key in altNames && !(srcKey in value)) {
-				for (const altKey of altNames[key]) if (altKey in value) {
-					srcKey = altKey;
-					break;
-				}
-			}
-			try {
-				const nv = format[key](value[srcKey]);
-				if (nv !== void 0) result[key] = nv;
-			} catch (error) {
-				assert(false, `invalid value for value.${key} (${error instanceof Error ? error.message : "not-an-error"})`, "BAD_DATA", { value });
-			}
-		}
-		return result;
-	});
-}
-function formatBoolean(value) {
-	switch (value) {
-		case true:
-		case "true": return true;
-		case false:
-		case "false": return false;
-	}
-	assertArgument(false, `invalid boolean; ${JSON.stringify(value)}`, "value", value);
-}
-function formatData(value) {
-	assertArgument(isHexString(value, true), "invalid data", "value", value);
-	return value;
-}
-function formatHash(value) {
-	assertArgument(isHexString(value, 32), "invalid hash", "value", value);
-	return value;
-}
-const _formatLog = object({
-	address: getAddress,
-	blockHash: formatHash,
-	blockNumber: getNumber,
-	data: formatData,
-	index: getNumber,
-	removed: allowNull(formatBoolean, false),
-	topics: arrayOf(formatHash),
-	transactionHash: formatHash,
-	transactionIndex: getNumber
-}, { index: ["logIndex"] });
-function formatLog$1(value) {
-	return _formatLog(value);
-}
-__name(formatLog$1, "formatLog");
-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);
-	result.transactions = value.transactions.map((tx) => {
-		if (typeof tx === "string") return tx;
-		return formatTransactionResponse$1(tx);
-	});
-	return result;
-}
-const _formatReceiptLog = object({
-	transactionIndex: getNumber,
-	blockNumber: getNumber,
-	transactionHash: formatHash,
-	address: getAddress,
-	topics: arrayOf(formatHash),
-	data: formatData,
-	index: getNumber,
-	blockHash: formatHash
-}, { index: ["logIndex"] });
-function formatReceiptLog(value) {
-	return _formatReceiptLog(value);
-}
-const _formatTransactionReceipt = object({
-	to: allowNull(getAddress, null),
-	from: allowNull(getAddress, null),
-	contractAddress: allowNull(getAddress, null),
-	index: getNumber,
-	root: allowNull(hexlify),
-	gasUsed: getBigInt,
-	blobGasUsed: allowNull(getBigInt, null),
-	logsBloom: allowNull(formatData),
-	blockHash: formatHash,
-	hash: formatHash,
-	logs: arrayOf(formatReceiptLog),
-	blockNumber: getNumber,
-	cumulativeGasUsed: getBigInt,
-	effectiveGasPrice: allowNull(getBigInt),
-	blobGasPrice: allowNull(getBigInt, null),
-	l1Fee: allowNull(getBigInt, null),
-	status: allowNull(getNumber),
-	type: allowNull(getNumber, 0)
-}, {
-	effectiveGasPrice: ["gasPrice"],
-	hash: ["transactionHash"],
-	index: ["transactionIndex"]
-});
-function formatTransactionReceipt$1(value) {
-	return _formatTransactionReceipt(value);
-}
-__name(formatTransactionReceipt$1, "formatTransactionReceipt");
-function formatTransactionResponse$1(value) {
-	if (value.to && getBigInt(value.to) === BN_0) value.to = "0x0000000000000000000000000000000000000000";
-	const result = object({
-		hash: formatHash,
-		index: allowNull(getNumber, void 0),
-		type: (value) => {
-			if (value === "0x" || value == null) return 0;
-			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),
-		from: getAddress,
-		gasPrice: allowNull(getBigInt),
-		maxPriorityFeePerGas: allowNull(getBigInt),
-		maxFeePerGas: allowNull(getBigInt),
-		maxFeePerBlobGas: allowNull(getBigInt, null),
-		gasLimit: getBigInt,
-		to: allowNull(getAddress, null),
-		value: getBigInt,
-		nonce: getNumber,
-		data: formatData,
-		creates: allowNull(getAddress, null),
-		chainId: allowNull(getBigInt, null)
-	}, {
-		data: ["input"],
-		gasLimit: ["gas"],
-		index: ["transactionIndex"]
-	})(value);
-	if (result.to == null && result.creates == null) result.creates = getCreateAddress(result);
-	if ((value.type === 1 || value.type === 2) && value.accessList == null) result.accessList = [];
-	if (value.signature) result.signature = Signature.from(value.signature);
-	else result.signature = Signature.from(value);
-	if (result.chainId == null) {
-		const chainId = result.signature.legacyChainId;
-		if (chainId != null) result.chainId = chainId;
-	}
-	if (result.blockHash && getBigInt(result.blockHash) === BN_0) result.blockHash = null;
-	return result;
-}
-__name(formatTransactionResponse$1, "formatTransactionResponse");
-
 //#endregion
 //#region src/eth/eth.ts
 var SimpleEthersError = class extends Error {
@@ -7989,17 +7801,93 @@ var FormattedTransactionResponse = class {
 	get blobVersionedHashes() {
 		return this.raw.blobVersionedHashes ?? null;
 	}
+	get authorizationList() {
+		return this.raw.authorizationList ?? null;
+	}
 };
 function formatTransactionResponse(value) {
 	return new FormattedTransactionResponse(value);
 }
+var FormattedBlock = class {
+	raw;
+	constructor(raw) {
+		this.raw = raw;
+	}
+	get hash() {
+		return this.raw.hash ?? null;
+	}
+	get number() {
+		return getNumber(this.raw.number);
+	}
+	get timestamp() {
+		return getNumber(this.raw.timestamp);
+	}
+	get parentHash() {
+		return this.raw.parentHash;
+	}
+	get parentBeaconBlockRoot() {
+		return this.raw.parentBeaconBlockRoot ?? null;
+	}
+	get nonce() {
+		return this.raw.nonce;
+	}
+	_difficulty;
+	get difficulty() {
+		return this._difficulty ?? (this._difficulty = getBigInt(this.raw.difficulty));
+	}
+	_gasLimit;
+	get gasLimit() {
+		return this._gasLimit ?? (this._gasLimit = getBigInt(this.raw.gasLimit));
+	}
+	_gasUsed;
+	get gasUsed() {
+		return this._gasUsed ?? (this._gasUsed = getBigInt(this.raw.gasUsed));
+	}
+	get blobGasUsed() {
+		return allowNull(getBigInt, null)(this.raw.blobGasUsed);
+	}
+	get excessBlobGas() {
+		return allowNull(getBigInt, null)(this.raw.excessBlobGas);
+	}
+	_miner;
+	get miner() {
+		return this._miner ?? (this._miner = allowNull(getAddress)(this.raw.miner));
+	}
+	get prevRandao() {
+		return this.raw.prevRandao ?? this.raw.mixHash ?? null;
+	}
+	get extraData() {
+		return this.raw.extraData;
+	}
+	_baseFeePerGas;
+	get baseFeePerGas() {
+		return this._baseFeePerGas !== void 0 ? this._baseFeePerGas : this._baseFeePerGas = allowNull(getBigInt, null)(this.raw.baseFeePerGas);
+	}
+	get stateRoot() {
+		return this.raw.stateRoot ?? null;
+	}
+	get receiptsRoot() {
+		return this.raw.receiptsRoot ?? null;
+	}
+	get transactionsRoot() {
+		return this.raw.transactionsRoot ?? null;
+	}
+	_transactions;
+	get transactions() {
+		return this._transactions ?? (this._transactions = (this.raw.transactions ?? []).map((tx) => typeof tx === "string" ? tx : formatTransactionResponse(tx)));
+	}
+	get traces() {
+		return this.raw.traces;
+	}
+	_transactionReceipts;
+	get transactionReceipts() {
+		if (this._transactionReceipts !== void 0) return this._transactionReceipts;
+		if (!this.raw.transactionReceipts) return;
+		return this._transactionReceipts = this.raw.transactionReceipts.map((t) => formatTransactionReceipt(t));
+	}
+};
 function formatRichBlock(block) {
-	block = {
-		...block,
-		...formatBlock(block)
-	};
-	if (block.transactionReceipts) block.transactionReceipts = block.transactionReceipts.map((t) => formatTransactionReceipt(t));
-	return block;
+	return new FormattedBlock(block);
 }
 function isNullAddress(address) {
 	try {
@@ -8024,10 +7912,41 @@ function encodeCallData(context, name, funcABI, values) {
 	}
 }
 function newContract(target, abi, runner) {
-	return new Contract(target, abi, runner);
+	return new Contract(target, abi instanceof Interface ? abi : sanitizeAbi(abi), runner);
 }
 function newInterface(fragments) {
-	return new Interface(fragments);
+	return new Interface(sanitizeAbi(fragments));
+}
+/**
+* Recursively drop `indexed: false` from ABI fragment objects.
+*
+* Upstream ethers' `ParamType.from` throws "parameter cannot be indexed" when a
+* non-event parameter (function/error/constructor input) carries an explicit
+* `indexed: false` — some real-world ABIs do. The retired @sentio/ethers fork
+* tolerated this; we replicate it here by stripping the redundant flag before the
+* ABI reaches ethers. Dropping `indexed: false` is safe: it is the default for
+* event params (non-indexed) and meaningless elsewhere; `indexed: true` is kept.
+*/
+function sanitizeAbi(abi) {
+	if (typeof abi === "string") try {
+		return dropFalseIndexed(JSON.parse(abi));
+	} catch {
+		return abi;
+	}
+	if (Array.isArray(abi)) return dropFalseIndexed(abi);
+	return abi;
+}
+function dropFalseIndexed(node) {
+	if (Array.isArray(node)) return node.map(dropFalseIndexed);
+	if (node && typeof node === "object") {
+		const out = {};
+		for (const [key, value] of Object.entries(node)) {
+			if (key === "indexed" && value === false) continue;
+			out[key] = dropFalseIndexed(value);
+		}
+		return out;
+	}
+	return node;
 }
 
 //#endregion
@@ -8089,5 +8008,5 @@ var decode_worker_default = {
 };
 
 //#endregion
-export { concat as $, TransactionResponse as A, keccak256 as B, formatTransactionResponse$1 as C, exists as Ct, FeeData as D, Block as E, Result as F, getBigInt as G, toUtf8Bytes as H, accessListify as I, toBeArray as J, getNumber as K, resolveAddress as L, LogDescription as M, AbiCoder as N, Log as O, id as P, toTwos as Q, getAddress as R, formatTransactionReceipt$1 as S, bytes as St, Contract as T, output as Tt, toUtf8String as U, encodeRlp as V, EventPayload as W, toBigInt as X, toBeHex as Y, toQuantity as Z, transformEtherError as _, createView as _t, parseLogInline as a, isBytesLike as at, formatBlock as b, toBytes as bt, TypedEvent as c, assert as ct, formatEthData as d, isError as dt, dataLength as et, formatRichBlock as f, makeError as ft, newInterface as g, concatBytes as gt, newContract as h, Hash as ht, parseLog as i, hexlify as it, copyRequest as j, TransactionReceipt as k, encodeCallData as l, assertArgument as lt, isNullAddress as m, resolveProperties as mt, decodeTraceInline as n, getBytes as nt, FormattedLog as o, isHexString as ot, formatTransactionResponse as p, defineProperties as pt, mask as q, decode_worker_default as r, getBytesCopy as rt, SimpleEthersError as s, zeroPadValue as st, decodeTrace as t, dataSlice as tt, fixEmptyKey as u, isCallException as ut, validateAndNormalizeAddress as v, randomBytes as vt, BaseContract as w, hash as wt, formatLog$1 as x, wrapConstructor as xt, allowNull as y, rotr as yt, Signature as z };
-//# sourceMappingURL=decode-worker-7st2rUPr.js.map
+export { mask as $, accessListify as A, rotr as B, FeeData as C, copyRequest as D, TransactionResponse as E, keccak256 as F, hash as G, wrapConstructor as H, Hash as I, toUtf8Bytes as J, output as K, concatBytes as L, resolveAddress as M, getAddress as N, LogDescription as O, Signature as P, getNumber as Q, createView as R, Block as S, TransactionReceipt as T, bytes as U, toBytes as V, exists as W, EventPayload as X, toUtf8String as Y, getBigInt as Z, sanitizeAbi as _, isError as _t, parseLogInline as a, concat as at, BaseContract as b, resolveProperties as bt, TypedEvent as c, getBytes as ct, formatEthData as d, isBytesLike as dt, toBeArray as et, formatRichBlock as f, isHexString as ft, newInterface as g, isCallException as gt, newContract as h, assertArgument as ht, parseLog as i, toTwos as it, id as j, AbiCoder as k, encodeCallData as l, getBytesCopy as lt, isNullAddress as m, assert as mt, decodeTraceInline as n, toBigInt as nt, FormattedLog as o, dataLength as ot, formatTransactionResponse as p, zeroPadValue as pt, Result as q, decode_worker_default as r, toQuantity as rt, SimpleEthersError as s, dataSlice as st, decodeTrace as t, toBeHex as tt, fixEmptyKey as u, hexlify as ut, transformEtherError as v, makeError as vt, Log as w, Contract as x, allowNull as xt, validateAndNormalizeAddress as y, defineProperties as yt, randomBytes as z };
+//# sourceMappingURL=decode-worker-C83IoThX.js.map