@toruslabs/ethereum-controllers 7.0.0-alpha.3 → 7.0.0

package/dist/ethereumControllers.cjs.js

@@ -79,7 +79,7 @@ const functionModifiers = new Set([
 ]);
 //# sourceMappingURL=signatures.js.map
 ;// ../../node_modules/abitype/dist/esm/version.js
-const version = '1.0.6';
+const version = '1.0.7';
 //# sourceMappingURL=version.js.map
 ;// ../../node_modules/abitype/dist/esm/errors.js
 
@@ -378,9 +378,20 @@ class InvalidParenthesisError extends BaseError {
  * @param type ABI parameter type
  * @returns Cache key for {@link parameterCache}
  */
-function getParameterCacheKey(param, type) {
+function getParameterCacheKey(param, type, structs) {
+    let structKey = '';
+    if (structs)
+        for (const struct of Object.entries(structs)) {
+            if (!struct)
+                continue;
+            let propertyKey = '';
+            for (const property of struct[1]) {
+                propertyKey += `[${property.type}${property.name ? `:${property.name}` : ''}]`;
+            }
+            structKey += `(${struct[0]}{${propertyKey}})`;
+        }
     if (type)
-        return `${type}:${param}`;
+        return `${type}:${param}${structKey}`;
     return param;
 }
 /**
@@ -544,7 +555,7 @@ const abiParameterWithTupleRegex = /^\((?<type>.+?)\)(?<array>(?:\[\d*?\])+?)?(?
 const dynamicIntegerRegex = /^u?int$/;
 function parseAbiParameter(param, options) {
     // optional namespace cache by `type`
-    const parameterCacheKey = getParameterCacheKey(param, options?.type);
+    const parameterCacheKey = getParameterCacheKey(param, options?.type, options?.structs);
     if (parameterCache.has(parameterCacheKey))
         return parameterCache.get(parameterCacheKey);
     const isTuple = regex/* isTupleRegex */.wj.test(param);
@@ -3644,7 +3655,7 @@ __webpack_require__.d(__webpack_exports__, {
 // UNUSED EXPORTS: setErrorConfig
 
 ;// ../../node_modules/viem/_esm/errors/version.js
-const version = '2.21.51';
+const version = '2.21.55';
 //# sourceMappingURL=version.js.map
 ;// ../../node_modules/viem/_esm/errors/base.js
 
@@ -4101,7 +4112,7 @@ class InvalidBytesLengthError extends _base_js__WEBPACK_IMPORTED_MODULE_0__/* .B
 
 /***/ }),
 
-/***/ 675:
+/***/ 704:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
@@ -4731,7 +4742,7 @@ function trim(hexOrBytes, { dir = 'left' } = {}) {
 }
 //# sourceMappingURL=trim.js.map
 // EXTERNAL MODULE: ../../node_modules/viem/_esm/errors/encoding.js
-var encoding = __webpack_require__(675);
+var encoding = __webpack_require__(704);
 // EXTERNAL MODULE: ../../node_modules/viem/_esm/utils/encoding/fromHex.js
 var fromHex = __webpack_require__(756);
 // EXTERNAL MODULE: ../../node_modules/viem/_esm/utils/encoding/toHex.js
@@ -5199,14 +5210,18 @@ function decodeFunctionResult(parameters) {
 /* harmony export */   k: () => (/* binding */ getArrayComponents)
 /* harmony export */ });
 /* harmony import */ var _errors_abi_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(663);
-/* harmony import */ var _errors_address_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(77);
-/* harmony import */ var _errors_base_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(323);
-/* harmony import */ var _address_isAddress_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(68);
-/* harmony import */ var _data_concat_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(666);
-/* harmony import */ var _data_pad_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(577);
-/* harmony import */ var _data_size_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(943);
-/* harmony import */ var _data_slice_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(846);
-/* harmony import */ var _encoding_toHex_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(903);
+/* harmony import */ var _errors_address_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(77);
+/* harmony import */ var _errors_base_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(323);
+/* harmony import */ var _errors_encoding_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(704);
+/* harmony import */ var _address_isAddress_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(68);
+/* harmony import */ var _data_concat_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(666);
+/* harmony import */ var _data_pad_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(577);
+/* harmony import */ var _data_size_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(943);
+/* harmony import */ var _data_slice_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(846);
+/* harmony import */ var _encoding_toHex_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(903);
+/* harmony import */ var _regex_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(976);
+
+
 
 
 
@@ -5293,7 +5308,11 @@ function prepareParam({ param, value, }) {
     }
     if (param.type.startsWith('uint') || param.type.startsWith('int')) {
         const signed = param.type.startsWith('int');
-        return encodeNumber(value, { signed });
+        const [, , size = '256'] = _regex_js__WEBPACK_IMPORTED_MODULE_1__/* .integerRegex */ .Ge.exec(param.type) ?? [];
+        return encodeNumber(value, {
+            signed,
+            size: Number(size),
+        });
     }
     if (param.type.startsWith('bytes')) {
         return encodeBytes(value, { param });
@@ -5313,7 +5332,7 @@ function encodeParams(preparedParams) {
         if (dynamic)
             staticSize += 32;
         else
-            staticSize += (0,_data_size_js__WEBPACK_IMPORTED_MODULE_1__/* .size */ .E)(encoded);
+            staticSize += (0,_data_size_js__WEBPACK_IMPORTED_MODULE_2__/* .size */ .E)(encoded);
     }
     // 2. Split the parameters into static and dynamic parts.
     const staticParams = [];
@@ -5322,21 +5341,21 @@ function encodeParams(preparedParams) {
     for (let i = 0; i < preparedParams.length; i++) {
         const { dynamic, encoded } = preparedParams[i];
         if (dynamic) {
-            staticParams.push((0,_encoding_toHex_js__WEBPACK_IMPORTED_MODULE_2__/* .numberToHex */ .cK)(staticSize + dynamicSize, { size: 32 }));
+            staticParams.push((0,_encoding_toHex_js__WEBPACK_IMPORTED_MODULE_3__/* .numberToHex */ .cK)(staticSize + dynamicSize, { size: 32 }));
             dynamicParams.push(encoded);
-            dynamicSize += (0,_data_size_js__WEBPACK_IMPORTED_MODULE_1__/* .size */ .E)(encoded);
+            dynamicSize += (0,_data_size_js__WEBPACK_IMPORTED_MODULE_2__/* .size */ .E)(encoded);
         }
         else {
             staticParams.push(encoded);
         }
     }
     // 3. Concatenate static and dynamic parts.
-    return (0,_data_concat_js__WEBPACK_IMPORTED_MODULE_3__/* .concat */ .xW)([...staticParams, ...dynamicParams]);
+    return (0,_data_concat_js__WEBPACK_IMPORTED_MODULE_4__/* .concat */ .xW)([...staticParams, ...dynamicParams]);
 }
 function encodeAddress(value) {
-    if (!(0,_address_isAddress_js__WEBPACK_IMPORTED_MODULE_4__/* .isAddress */ .P)(value))
-        throw new _errors_address_js__WEBPACK_IMPORTED_MODULE_5__/* .InvalidAddressError */ .M({ address: value });
-    return { dynamic: false, encoded: (0,_data_pad_js__WEBPACK_IMPORTED_MODULE_6__/* .padHex */ .db)(value.toLowerCase()) };
+    if (!(0,_address_isAddress_js__WEBPACK_IMPORTED_MODULE_5__/* .isAddress */ .P)(value))
+        throw new _errors_address_js__WEBPACK_IMPORTED_MODULE_6__/* .InvalidAddressError */ .M({ address: value });
+    return { dynamic: false, encoded: (0,_data_pad_js__WEBPACK_IMPORTED_MODULE_7__/* .padHex */ .db)(value.toLowerCase()) };
 }
 function encodeArray(value, { length, param, }) {
     const dynamic = length === null;
@@ -5359,10 +5378,10 @@ function encodeArray(value, { length, param, }) {
     if (dynamic || dynamicChild) {
         const data = encodeParams(preparedParams);
         if (dynamic) {
-            const length = (0,_encoding_toHex_js__WEBPACK_IMPORTED_MODULE_2__/* .numberToHex */ .cK)(preparedParams.length, { size: 32 });
+            const length = (0,_encoding_toHex_js__WEBPACK_IMPORTED_MODULE_3__/* .numberToHex */ .cK)(preparedParams.length, { size: 32 });
             return {
                 dynamic: true,
-                encoded: preparedParams.length > 0 ? (0,_data_concat_js__WEBPACK_IMPORTED_MODULE_3__/* .concat */ .xW)([length, data]) : length,
+                encoded: preparedParams.length > 0 ? (0,_data_concat_js__WEBPACK_IMPORTED_MODULE_4__/* .concat */ .xW)([length, data]) : length,
             };
         }
         if (dynamicChild)
@@ -5370,24 +5389,24 @@ function encodeArray(value, { length, param, }) {
     }
     return {
         dynamic: false,
-        encoded: (0,_data_concat_js__WEBPACK_IMPORTED_MODULE_3__/* .concat */ .xW)(preparedParams.map(({ encoded }) => encoded)),
+        encoded: (0,_data_concat_js__WEBPACK_IMPORTED_MODULE_4__/* .concat */ .xW)(preparedParams.map(({ encoded }) => encoded)),
     };
 }
 function encodeBytes(value, { param }) {
     const [, paramSize] = param.type.split('bytes');
-    const bytesSize = (0,_data_size_js__WEBPACK_IMPORTED_MODULE_1__/* .size */ .E)(value);
+    const bytesSize = (0,_data_size_js__WEBPACK_IMPORTED_MODULE_2__/* .size */ .E)(value);
     if (!paramSize) {
         let value_ = value;
         // If the size is not divisible by 32 bytes, pad the end
         // with empty bytes to the ceiling 32 bytes.
         if (bytesSize % 32 !== 0)
-            value_ = (0,_data_pad_js__WEBPACK_IMPORTED_MODULE_6__/* .padHex */ .db)(value_, {
+            value_ = (0,_data_pad_js__WEBPACK_IMPORTED_MODULE_7__/* .padHex */ .db)(value_, {
                 dir: 'right',
                 size: Math.ceil((value.length - 2) / 2 / 32) * 32,
             });
         return {
             dynamic: true,
-            encoded: (0,_data_concat_js__WEBPACK_IMPORTED_MODULE_3__/* .concat */ .xW)([(0,_data_pad_js__WEBPACK_IMPORTED_MODULE_6__/* .padHex */ .db)((0,_encoding_toHex_js__WEBPACK_IMPORTED_MODULE_2__/* .numberToHex */ .cK)(bytesSize, { size: 32 })), value_]),
+            encoded: (0,_data_concat_js__WEBPACK_IMPORTED_MODULE_4__/* .concat */ .xW)([(0,_data_pad_js__WEBPACK_IMPORTED_MODULE_7__/* .padHex */ .db)((0,_encoding_toHex_js__WEBPACK_IMPORTED_MODULE_3__/* .numberToHex */ .cK)(bytesSize, { size: 32 })), value_]),
         };
     }
     if (bytesSize !== Number.parseInt(paramSize))
@@ -5395,35 +5414,47 @@ function encodeBytes(value, { param }) {
             expectedSize: Number.parseInt(paramSize),
             value,
         });
-    return { dynamic: false, encoded: (0,_data_pad_js__WEBPACK_IMPORTED_MODULE_6__/* .padHex */ .db)(value, { dir: 'right' }) };
+    return { dynamic: false, encoded: (0,_data_pad_js__WEBPACK_IMPORTED_MODULE_7__/* .padHex */ .db)(value, { dir: 'right' }) };
 }
 function encodeBool(value) {
     if (typeof value !== 'boolean')
-        throw new _errors_base_js__WEBPACK_IMPORTED_MODULE_7__/* .BaseError */ .C(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
-    return { dynamic: false, encoded: (0,_data_pad_js__WEBPACK_IMPORTED_MODULE_6__/* .padHex */ .db)((0,_encoding_toHex_js__WEBPACK_IMPORTED_MODULE_2__/* .boolToHex */ .$P)(value)) };
-}
-function encodeNumber(value, { signed }) {
+        throw new _errors_base_js__WEBPACK_IMPORTED_MODULE_8__/* .BaseError */ .C(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
+    return { dynamic: false, encoded: (0,_data_pad_js__WEBPACK_IMPORTED_MODULE_7__/* .padHex */ .db)((0,_encoding_toHex_js__WEBPACK_IMPORTED_MODULE_3__/* .boolToHex */ .$P)(value)) };
+}
+function encodeNumber(value, { signed, size = 256 }) {
+    if (typeof size === 'number') {
+        const max = 2n ** (BigInt(size) - (signed ? 1n : 0n)) - 1n;
+        const min = signed ? -max - 1n : 0n;
+        if (value > max || value < min)
+            throw new _errors_encoding_js__WEBPACK_IMPORTED_MODULE_9__/* .IntegerOutOfRangeError */ .Ty({
+                max: max.toString(),
+                min: min.toString(),
+                signed,
+                size: size / 8,
+                value: value.toString(),
+            });
+    }
     return {
         dynamic: false,
-        encoded: (0,_encoding_toHex_js__WEBPACK_IMPORTED_MODULE_2__/* .numberToHex */ .cK)(value, {
+        encoded: (0,_encoding_toHex_js__WEBPACK_IMPORTED_MODULE_3__/* .numberToHex */ .cK)(value, {
             size: 32,
             signed,
         }),
     };
 }
 function encodeString(value) {
-    const hexValue = (0,_encoding_toHex_js__WEBPACK_IMPORTED_MODULE_2__/* .stringToHex */ .i3)(value);
-    const partsLength = Math.ceil((0,_data_size_js__WEBPACK_IMPORTED_MODULE_1__/* .size */ .E)(hexValue) / 32);
+    const hexValue = (0,_encoding_toHex_js__WEBPACK_IMPORTED_MODULE_3__/* .stringToHex */ .i3)(value);
+    const partsLength = Math.ceil((0,_data_size_js__WEBPACK_IMPORTED_MODULE_2__/* .size */ .E)(hexValue) / 32);
     const parts = [];
     for (let i = 0; i < partsLength; i++) {
-        parts.push((0,_data_pad_js__WEBPACK_IMPORTED_MODULE_6__/* .padHex */ .db)((0,_data_slice_js__WEBPACK_IMPORTED_MODULE_8__/* .slice */ .di)(hexValue, i * 32, (i + 1) * 32), {
+        parts.push((0,_data_pad_js__WEBPACK_IMPORTED_MODULE_7__/* .padHex */ .db)((0,_data_slice_js__WEBPACK_IMPORTED_MODULE_10__/* .slice */ .di)(hexValue, i * 32, (i + 1) * 32), {
             dir: 'right',
         }));
     }
     return {
         dynamic: true,
-        encoded: (0,_data_concat_js__WEBPACK_IMPORTED_MODULE_3__/* .concat */ .xW)([
-            (0,_data_pad_js__WEBPACK_IMPORTED_MODULE_6__/* .padHex */ .db)((0,_encoding_toHex_js__WEBPACK_IMPORTED_MODULE_2__/* .numberToHex */ .cK)((0,_data_size_js__WEBPACK_IMPORTED_MODULE_1__/* .size */ .E)(hexValue), { size: 32 })),
+        encoded: (0,_data_concat_js__WEBPACK_IMPORTED_MODULE_4__/* .concat */ .xW)([
+            (0,_data_pad_js__WEBPACK_IMPORTED_MODULE_7__/* .padHex */ .db)((0,_encoding_toHex_js__WEBPACK_IMPORTED_MODULE_3__/* .numberToHex */ .cK)((0,_data_size_js__WEBPACK_IMPORTED_MODULE_2__/* .size */ .E)(hexValue), { size: 32 })),
             ...parts,
         ]),
     };
@@ -5446,7 +5477,7 @@ function encodeTuple(value, { param }) {
         dynamic,
         encoded: dynamic
             ? encodeParams(preparedParams)
-            : (0,_data_concat_js__WEBPACK_IMPORTED_MODULE_3__/* .concat */ .xW)(preparedParams.map(({ encoded }) => encoded)),
+            : (0,_data_concat_js__WEBPACK_IMPORTED_MODULE_4__/* .concat */ .xW)(preparedParams.map(({ encoded }) => encoded)),
     };
 }
 function getArrayComponents(type) {
@@ -5739,7 +5770,7 @@ function getAmbiguousTypes(sourceParameters, targetParameters, args) {
 /* harmony export */ });
 /* unused harmony export getAddress */
 /* harmony import */ var _encoding_toBytes_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(421);
-/* harmony import */ var _hash_keccak256_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(849);
+/* harmony import */ var _hash_keccak256_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(859);
 /* harmony import */ var _lru_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(394);
 
 
@@ -6046,7 +6077,7 @@ function sliceHex(value_, start, end, { strict } = {}) {
 /* harmony export */   uU: () => (/* binding */ hexToBigInt)
 /* harmony export */ });
 /* unused harmony exports fromHex, hexToBool, hexToString */
-/* harmony import */ var _errors_encoding_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(675);
+/* harmony import */ var _errors_encoding_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(704);
 /* harmony import */ var _data_size_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(943);
 
 
@@ -6422,7 +6453,7 @@ function stringToBytes(value, opts = {}) {
 /* harmony export */   i3: () => (/* binding */ stringToHex),
 /* harmony export */   nj: () => (/* binding */ toHex)
 /* harmony export */ });
-/* harmony import */ var _errors_encoding_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(675);
+/* harmony import */ var _errors_encoding_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(704);
 /* harmony import */ var _data_pad_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(577);
 /* harmony import */ var _fromHex_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(756);
 
@@ -6603,7 +6634,7 @@ function stringToHex(value_, opts = {}) {
 
 /***/ }),
 
-/***/ 849:
+/***/ 859:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 
@@ -6612,53 +6643,55 @@ __webpack_require__.d(__webpack_exports__, {
   S: () => (/* binding */ keccak256)
 });
 
-;// ../../node_modules/@noble/hashes/esm/_assert.js
-function number(n) {
+;// ../../node_modules/viem/node_modules/@noble/hashes/esm/_assert.js
+function anumber(n) {
     if (!Number.isSafeInteger(n) || n < 0)
-        throw new Error(`positive integer expected, not ${n}`);
-}
-function bool(b) {
-    if (typeof b !== 'boolean')
-        throw new Error(`boolean expected, not ${b}`);
+        throw new Error('positive integer expected, got ' + n);
 }
 // copied from utils
 function isBytes(a) {
-    return (a instanceof Uint8Array ||
-        (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
+    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
 }
-function bytes(b, ...lengths) {
+function _assert_abytes(b, ...lengths) {
     if (!isBytes(b))
         throw new Error('Uint8Array expected');
     if (lengths.length > 0 && !lengths.includes(b.length))
-        throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
+        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
 }
-function hash(h) {
+function ahash(h) {
     if (typeof h !== 'function' || typeof h.create !== 'function')
         throw new Error('Hash should be wrapped by utils.wrapConstructor');
-    number(h.outputLen);
-    number(h.blockLen);
+    anumber(h.outputLen);
+    anumber(h.blockLen);
 }
-function exists(instance, checkFinished = true) {
+function aexists(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);
+function aoutput(out, instance) {
+    _assert_abytes(out);
     const min = instance.outputLen;
     if (out.length < min) {
-        throw new Error(`digestInto() expects output buffer of length at least ${min}`);
+        throw new Error('digestInto() expects output buffer of length at least ' + min);
     }
 }
 
-const assert = { number, bool, bytes, hash, exists, output };
+const assert = {
+    number: anumber,
+    bytes: _assert_abytes,
+    hash: ahash,
+    exists: aexists,
+    output: aoutput,
+};
 /* harmony default export */ const _assert = ((/* unused pure expression or super */ null && (assert)));
 //# sourceMappingURL=_assert.js.map
-;// ../../node_modules/@noble/hashes/esm/_u64.js
+;// ../../node_modules/viem/node_modules/@noble/hashes/esm/_u64.js
 const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
 const _32n = /* @__PURE__ */ BigInt(32);
-// We are not using BigUint64Array, because they are extremely slow as per 2022
+// BigUint64Array is too slow as per 2024, so we implement it using Uint32Array.
+// TODO: re-check https://issues.chromium.org/issues/42212588
 function fromBig(n, le = false) {
     if (le)
         return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };
@@ -6718,7 +6751,7 @@ const u64 = {
 };
 /* harmony default export */ const _u64 = ((/* unused pure expression or super */ null && (u64)));
 //# sourceMappingURL=_u64.js.map
-;// ../../node_modules/@noble/hashes/esm/utils.js
+;// ../../node_modules/viem/node_modules/@noble/hashes/esm/utils.js
 /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 // We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.
 // node.js versions earlier than v19 don't declare it in global scope.
@@ -6731,8 +6764,7 @@ const u64 = {
 // export { isBytes } from './_assert.js';
 // We can't reuse isBytes from _assert, because somehow this causes huge perf issues
 function utils_isBytes(a) {
-    return (a instanceof Uint8Array ||
-        (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
+    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
 }
 // Cast array to different type
 const u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
@@ -6743,7 +6775,7 @@ const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLen
 const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);
 // The rotate left (circular left shift) operation for uint32
 const rotl = (word, shift) => (word << shift) | ((word >>> (32 - shift)) >>> 0);
-const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
+const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();
 // The byte swap operation for uint32
 const byteSwap = (word) => ((word << 24) & 0xff000000) |
     ((word << 8) & 0xff0000) |
@@ -6772,14 +6804,14 @@ function bytesToHex(bytes) {
     return hex;
 }
 // We use optimized technique to convert hex string to byte array
-const asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
-function asciiToBase16(char) {
-    if (char >= asciis._0 && char <= asciis._9)
-        return char - asciis._0;
-    if (char >= asciis._A && char <= asciis._F)
-        return char - (asciis._A - 10);
-    if (char >= asciis._a && char <= asciis._f)
-        return char - (asciis._a - 10);
+const asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+function asciiToBase16(ch) {
+    if (ch >= asciis._0 && ch <= asciis._9)
+        return ch - asciis._0; // '2' => 50-48
+    if (ch >= asciis.A && ch <= asciis.F)
+        return ch - (asciis.A - 10); // 'B' => 66-(65-10)
+    if (ch >= asciis.a && ch <= asciis.f)
+        return ch - (asciis.a - 10); // 'b' => 98-(97-10)
     return;
 }
 /**
@@ -6791,7 +6823,7 @@ function hexToBytes(hex) {
     const hl = hex.length;
     const al = hl / 2;
     if (hl % 2)
-        throw new Error('padded hex string expected, got unpadded hex of length ' + hl);
+        throw new Error('hex string expected, got unpadded hex of length ' + hl);
     const array = new Uint8Array(al);
     for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
         const n1 = asciiToBase16(hex.charCodeAt(hi));
@@ -6800,7 +6832,7 @@ function hexToBytes(hex) {
             const char = hex[hi] + hex[hi + 1];
             throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
         }
-        array[ai] = n1 * 16 + n2;
+        array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163
     }
     return array;
 }
@@ -6826,7 +6858,7 @@ async function asyncLoop(iters, tick, cb) {
  */
 function utf8ToBytes(str) {
     if (typeof str !== 'string')
-        throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+        throw new Error('utf8ToBytes expected string, got ' + typeof str);
     return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
 }
 /**
@@ -6837,7 +6869,7 @@ function utf8ToBytes(str) {
 function toBytes(data) {
     if (typeof data === 'string')
         data = utf8ToBytes(data);
-    bytes(data);
+    _assert_abytes(data);
     return data;
 }
 /**
@@ -6865,9 +6897,8 @@ class Hash {
         return this._cloneInto();
     }
 }
-const toStr = {}.toString;
 function checkOpts(defaults, opts) {
-    if (opts !== undefined && toStr.call(opts) !== '[object Object]')
+    if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')
         throw new Error('Options should be object or undefined');
     const merged = Object.assign(defaults, opts);
     return merged;
@@ -6910,7 +6941,7 @@ function randomBytes(bytesLength = 32) {
     throw new Error('crypto.getRandomValues must be defined');
 }
 //# sourceMappingURL=utils.js.map
-;// ../../node_modules/@noble/hashes/esm/sha3.js
+;// ../../node_modules/viem/node_modules/@noble/hashes/esm/sha3.js
 
 
 
@@ -7005,7 +7036,7 @@ class Keccak extends Hash {
         this.finished = false;
         this.destroyed = false;
         // Can be passed from user as dkLen
-        number(outputLen);
+        anumber(outputLen);
         // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes
         if (0 >= this.blockLen || this.blockLen >= 200)
             throw new Error('Sha3 supports only keccak-f1600 function');
@@ -7022,7 +7053,7 @@ class Keccak extends Hash {
         this.pos = 0;
     }
     update(data) {
-        exists(this);
+        aexists(this);
         const { blockLen, state } = this;
         data = toBytes(data);
         const len = data.length;
@@ -7048,8 +7079,8 @@ class Keccak extends Hash {
         this.keccak();
     }
     writeInto(out) {
-        exists(this, false);
-        bytes(out);
+        aexists(this, false);
+        _assert_abytes(out);
         this.finish();
         const bufferOut = this.state;
         const { blockLen } = this;
@@ -7070,11 +7101,11 @@ class Keccak extends Hash {
         return this.writeInto(out);
     }
     xof(bytes) {
-        number(bytes);
+        anumber(bytes);
         return this.xofInto(new Uint8Array(bytes));
     }
     digestInto(out) {
-        output(out, this);
+        aoutput(out, this);
         if (this.finished)
             throw new Error('digest() was already called');
         this.writeInto(out);
@@ -7181,7 +7212,7 @@ __webpack_require__.d(__webpack_exports__, {
 // EXTERNAL MODULE: ../../node_modules/viem/_esm/utils/encoding/toBytes.js
 var toBytes = __webpack_require__(421);
 // EXTERNAL MODULE: ../../node_modules/viem/_esm/utils/hash/keccak256.js + 4 modules
-var keccak256 = __webpack_require__(849);
+var keccak256 = __webpack_require__(859);
 ;// ../../node_modules/viem/_esm/utils/hash/hashSignature.js
 
 
@@ -7272,7 +7303,7 @@ function formatAbiItem(abiItem) {
     if (abiItem.type === 'function')
         return `function ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability && abiItem.stateMutability !== 'nonpayable'
             ? ` ${abiItem.stateMutability}`
-            : ''}${abiItem.outputs.length
+            : ''}${abiItem.outputs?.length
             ? ` returns (${formatAbiParameters(abiItem.outputs)})`
             : ''}`;
     if (abiItem.type === 'event')
@@ -7282,7 +7313,7 @@ function formatAbiItem(abiItem) {
     if (abiItem.type === 'constructor')
         return `constructor(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability === 'payable' ? ' payable' : ''}`;
     if (abiItem.type === 'fallback')
-        return 'fallback()';
+        return `fallback() external${abiItem.stateMutability === 'payable' ? ' payable' : ''}`;
     return 'receive() external payable';
 }
 //# sourceMappingURL=formatAbiItem.js.map
@@ -7426,6 +7457,25 @@ class LruMap extends Map {
 
 /***/ }),
 
+/***/ 976:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   BD: () => (/* binding */ bytesRegex),
+/* harmony export */   Ge: () => (/* binding */ integerRegex)
+/* harmony export */ });
+/* unused harmony export arrayRegex */
+const arrayRegex = /^(.*)\[([0-9]*)\]$/;
+// `bytes<M>`: binary type of `M` bytes, `0 < M <= 32`
+// https://regexr.com/6va55
+const bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
+// `(u)int<M>`: (un)signed integer type of `M` bits, `0 < M <= 256`, `M % 8 == 0`
+// https://regexr.com/6v8hp
+const integerRegex = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
+//# sourceMappingURL=regex.js.map
+
+/***/ }),
+
 /***/ 274:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
@@ -11250,7 +11300,7 @@ function src_formatUserOperation(parameters) {
 /**
  * Retrieves information about a User Operation given a hash.
  *
- * - Docs: https://viem.sh/docs/actions/bundler/getUserOperation
+ * - Docs: https://viem.sh/account-abstraction/actions/bundler/getUserOperation
  *
  * @param client - Client to use
  * @param parameters - {@link GetUserOperationParameters}
@@ -11489,8 +11539,11 @@ function src_observe(observerId, callbacks, fn) {
         src_listenersCache.set(observerId, listeners.filter((cb) => cb.id !== callbackId));
     };
     const unwatch = () => {
+        const listeners = getListeners();
+        if (!listeners.some((cb) => cb.id === callbackId))
+            return;
         const cleanup = src_cleanupCache.get(observerId);
-        if (getListeners().length === 1 && cleanup)
+        if (listeners.length === 1 && cleanup)
             cleanup();
         unsubscribe();
     };
@@ -13978,7 +14031,7 @@ async function src_toSmartAccount(implementation) {
 // EXTERNAL MODULE: ../../node_modules/viem/_esm/utils/data/pad.js
 var src_pad = __webpack_require__(577);
 // EXTERNAL MODULE: ../../node_modules/viem/_esm/utils/hash/keccak256.js + 4 modules
-var src_keccak256 = __webpack_require__(849);
+var src_keccak256 = __webpack_require__(859);
 ;// ../../node_modules/viem/_esm/account-abstraction/utils/userOperation/getUserOperationHash.js
 
 
@@ -14263,15 +14316,8 @@ class src_InvalidStructTypeError extends src_base/* BaseError */.C {
 //# sourceMappingURL=typedData.js.map
 // EXTERNAL MODULE: ../../node_modules/viem/_esm/utils/data/size.js
 var src_data_size = __webpack_require__(943);
-;// ../../node_modules/viem/_esm/utils/regex.js
-const src_arrayRegex = /^(.*)\[([0-9]*)\]$/;
-// `bytes<M>`: binary type of `M` bytes, `0 < M <= 32`
-// https://regexr.com/6va55
-const src_bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
-// `(u)int<M>`: (un)signed integer type of `M` bits, `0 < M <= 256`, `M % 8 == 0`
-// https://regexr.com/6v8hp
-const src_integerRegex = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
-//# sourceMappingURL=regex.js.map
+// EXTERNAL MODULE: ../../node_modules/viem/_esm/utils/regex.js
+var src_regex = __webpack_require__(976);
 ;// ../../node_modules/viem/_esm/utils/typedData.js
 
 
@@ -14313,7 +14359,7 @@ function src_validateTypedData(parameters) {
         for (const param of struct) {
             const { name, type } = param;
             const value = data[name];
-            const integerMatch = type.match(src_integerRegex);
+            const integerMatch = type.match(src_regex/* integerRegex */.Ge);
             if (integerMatch &&
                 (typeof value === 'number' || typeof value === 'bigint')) {
                 const [_type, base, size_] = integerMatch;
@@ -14326,7 +14372,7 @@ function src_validateTypedData(parameters) {
             }
             if (type === 'address' && typeof value === 'string' && !(0,src_isAddress/* isAddress */.P)(value))
                 throw new src_address/* InvalidAddressError */.M({ address: value });
-            const bytesMatch = type.match(src_bytesRegex);
+            const bytesMatch = type.match(src_regex/* bytesRegex */.BD);
             if (bytesMatch) {
                 const [_type, size_] = bytesMatch;
                 if (size_ && (0,src_data_size/* size */.E)(value) !== Number.parseInt(size_))
@@ -14919,6 +14965,321 @@ class src_BiconomySmartAccount {
     }));
   }
 }
+;// ../../node_modules/@noble/hashes/esm/_assert.js
+function src_anumber(n) {
+    if (!Number.isSafeInteger(n) || n < 0)
+        throw new Error('positive integer expected, got ' + n);
+}
+// copied from utils
+function src_isBytes(a) {
+    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
+}
+function src_assert_abytes(b, ...lengths) {
+    if (!src_isBytes(b))
+        throw new Error('Uint8Array expected');
+    if (lengths.length > 0 && !lengths.includes(b.length))
+        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
+}
+function src_ahash(h) {
+    if (typeof h !== 'function' || typeof h.create !== 'function')
+        throw new Error('Hash should be wrapped by utils.wrapConstructor');
+    src_anumber(h.outputLen);
+    src_anumber(h.blockLen);
+}
+function src_aexists(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 src_aoutput(out, instance) {
+    src_assert_abytes(out);
+    const min = instance.outputLen;
+    if (out.length < min) {
+        throw new Error('digestInto() expects output buffer of length at least ' + min);
+    }
+}
+
+const src_assert = {
+    number: src_anumber,
+    bytes: src_assert_abytes,
+    hash: src_ahash,
+    exists: src_aexists,
+    output: src_aoutput,
+};
+/* harmony default export */ const src_assert_0 = ((/* unused pure expression or super */ null && (src_assert)));
+//# sourceMappingURL=_assert.js.map
+;// ../../node_modules/@noble/hashes/esm/utils.js
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.
+// node.js versions earlier than v19 don't declare it in global scope.
+// For node.js, package.json#exports field mapping rewrites import
+// from `crypto` to `cryptoNode`, which imports native module.
+// Makes the utils un-importable in browsers without a bundler.
+// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
+
+
+// export { isBytes } from './_assert.js';
+// We can't reuse isBytes from _assert, because somehow this causes huge perf issues
+function src_utils_isBytes(a) {
+    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
+}
+// Cast array to different type
+const src_u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+const src_u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+// Cast array to view
+const src_createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+// The rotate right (circular right shift) operation for uint32
+const src_rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);
+// The rotate left (circular left shift) operation for uint32
+const src_rotl = (word, shift) => (word << shift) | ((word >>> (32 - shift)) >>> 0);
+const src_isLE = /* @__PURE__ */ (/* unused pure expression or super */ null && ((() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)()));
+// The byte swap operation for uint32
+const src_byteSwap = (word) => ((word << 24) & 0xff000000) |
+    ((word << 8) & 0xff0000) |
+    ((word >>> 8) & 0xff00) |
+    ((word >>> 24) & 0xff);
+// Conditionally byte swap if on a big-endian platform
+const src_byteSwapIfBE = (/* unused pure expression or super */ null && (src_isLE ? (n) => n : (n) => src_byteSwap(n)));
+// In place byte swap for Uint32Array
+function src_byteSwap32(arr) {
+    for (let i = 0; i < arr.length; i++) {
+        arr[i] = src_byteSwap(arr[i]);
+    }
+}
+// Array where index 0xf0 (240) is mapped to string 'f0'
+const src_hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+/**
+ * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+ */
+function src_utils_bytesToHex(bytes) {
+    src_assert_abytes(bytes);
+    // pre-caching improves the speed 6x
+    let hex = '';
+    for (let i = 0; i < bytes.length; i++) {
+        hex += src_hexes[bytes[i]];
+    }
+    return hex;
+}
+// We use optimized technique to convert hex string to byte array
+const src_asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+function src_asciiToBase16(ch) {
+    if (ch >= src_asciis._0 && ch <= src_asciis._9)
+        return ch - src_asciis._0; // '2' => 50-48
+    if (ch >= src_asciis.A && ch <= src_asciis.F)
+        return ch - (src_asciis.A - 10); // 'B' => 66-(65-10)
+    if (ch >= src_asciis.a && ch <= src_asciis.f)
+        return ch - (src_asciis.a - 10); // 'b' => 98-(97-10)
+    return;
+}
+/**
+ * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
+ */
+function src_utils_hexToBytes(hex) {
+    if (typeof hex !== 'string')
+        throw new Error('hex string expected, got ' + typeof hex);
+    const hl = hex.length;
+    const al = hl / 2;
+    if (hl % 2)
+        throw new Error('padded hex string expected, got unpadded hex of length ' + hl);
+    const array = new Uint8Array(al);
+    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+        const n1 = src_asciiToBase16(hex.charCodeAt(hi));
+        const n2 = src_asciiToBase16(hex.charCodeAt(hi + 1));
+        if (n1 === undefined || n2 === undefined) {
+            const char = hex[hi] + hex[hi + 1];
+            throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+        }
+        array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163
+    }
+    return array;
+}
+// There is no setImmediate in browser and setTimeout is slow.
+// call of async fn will return Promise, which will be fullfiled only on
+// next scheduler queue processing step and this is exactly what we need.
+const src_nextTick = async () => { };
+// Returns control to thread each 'tick' ms to avoid blocking
+async function src_asyncLoop(iters, tick, cb) {
+    let ts = Date.now();
+    for (let i = 0; i < iters; i++) {
+        cb(i);
+        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too
+        const diff = Date.now() - ts;
+        if (diff >= 0 && diff < tick)
+            continue;
+        await src_nextTick();
+        ts += diff;
+    }
+}
+/**
+ * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
+ */
+function src_utf8ToBytes(str) {
+    if (typeof str !== 'string')
+        throw new Error('utf8ToBytes expected string, got ' + typeof str);
+    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
+}
+/**
+ * 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 src_utils_toBytes(data) {
+    if (typeof data === 'string')
+        data = src_utf8ToBytes(data);
+    abytes(data);
+    return data;
+}
+/**
+ * Copies several Uint8Arrays into one.
+ */
+function src_concatBytes(...arrays) {
+    let sum = 0;
+    for (let i = 0; i < arrays.length; i++) {
+        const a = arrays[i];
+        abytes(a);
+        sum += a.length;
+    }
+    const res = new Uint8Array(sum);
+    for (let i = 0, pad = 0; i < arrays.length; i++) {
+        const a = arrays[i];
+        res.set(a, pad);
+        pad += a.length;
+    }
+    return res;
+}
+// For runtime check if class implements interface
+class src_Hash {
+    // Safe version that clones internal state
+    clone() {
+        return this._cloneInto();
+    }
+}
+function src_checkOpts(defaults, opts) {
+    if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')
+        throw new Error('Options should be object or undefined');
+    const merged = Object.assign(defaults, opts);
+    return merged;
+}
+function src_wrapConstructor(hashCons) {
+    const hashC = (msg) => hashCons().update(src_utils_toBytes(msg)).digest();
+    const tmp = hashCons();
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = () => hashCons();
+    return hashC;
+}
+function src_wrapConstructorWithOpts(hashCons) {
+    const hashC = (msg, opts) => hashCons(opts).update(src_utils_toBytes(msg)).digest();
+    const tmp = hashCons({});
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = (opts) => hashCons(opts);
+    return hashC;
+}
+function src_wrapXOFConstructorWithOpts(hashCons) {
+    const hashC = (msg, opts) => hashCons(opts).update(src_utils_toBytes(msg)).digest();
+    const tmp = hashCons({});
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = (opts) => hashCons(opts);
+    return hashC;
+}
+/**
+ * Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.
+ */
+function src_randomBytes(bytesLength = 32) {
+    if (crypto && typeof crypto.getRandomValues === 'function') {
+        return crypto.getRandomValues(new Uint8Array(bytesLength));
+    }
+    // Legacy Node.js compatibility
+    if (crypto && typeof crypto.randomBytes === 'function') {
+        return crypto.randomBytes(bytesLength);
+    }
+    throw new Error('crypto.getRandomValues must be defined');
+}
+//# sourceMappingURL=utils.js.map
+;// ../../node_modules/webauthn-p256/_esm/utils.js
+
+function src_esm_utils_bytesToHex(bytes) {
+    return `0x${src_utils_bytesToHex(bytes)}`;
+}
+function src_esm_utils_hexToBytes(value) {
+    return src_utils_hexToBytes(value.slice(2));
+}
+function src_utils_base64UrlToBytes(base64Url) {
+    const base64 = src_base64UrlToBase64(base64Url);
+    const utf8 = src_base64ToUtf8(base64);
+    return Uint8Array.from(utf8, (c) => c.charCodeAt(0));
+}
+function src_utils_bytesToBase64Url(bytes) {
+    const base64 = src_utf8ToBase64(String.fromCharCode(...bytes));
+    return src_base64ToBase64Url(base64);
+}
+function src_base64UrlToBase64(base64Url) {
+    return base64Url.replaceAll('-', '+').replaceAll('_', '/');
+}
+function src_base64ToBase64Url(base64) {
+    return base64.replaceAll('+', '-').replaceAll('/', '_').replace(/=+$/, '');
+}
+function src_base64ToUtf8(base64) {
+    return atob(base64);
+}
+function src_utf8ToBase64(base64) {
+    return btoa(base64);
+}
+async function src_utils_bytesToCryptoKey(bytes) {
+    return await crypto.subtle.importKey('spki', bytes, {
+        name: 'ECDSA',
+        namedCurve: 'P-256',
+        hash: 'SHA-256',
+    }, true, ['verify']);
+}
+async function src_utils_cryptoKeyToBytes(key) {
+    return new Uint8Array(await crypto.subtle.exportKey('raw', key));
+}
+//# sourceMappingURL=utils.js.map
+;// ../../node_modules/webauthn-p256/_esm/publicKey.js
+
+
+/**
+ * Parses a public key into x and y coordinates from the public key
+ * defined on the credential.
+ */
+async function src_parseCredentialPublicKey(cPublicKey) {
+    const base64Url = bytesToBase64Url(new Uint8Array(cPublicKey));
+    const bytes = base64UrlToBytes(base64Url);
+    const cryptoKey = await bytesToCryptoKey(bytes);
+    const publicKey = await cryptoKeyToBytes(cryptoKey);
+    return src_parsePublicKey(publicKey);
+}
+/**
+ * Parses a serialized public key into x and y coordinates.
+ */
+function src_parsePublicKey(publicKey) {
+    const bytes = typeof publicKey === 'string' ? src_esm_utils_hexToBytes(publicKey) : publicKey;
+    const offset = bytes.length === 65 ? 1 : 0;
+    const x = bytes.slice(offset, 32 + offset);
+    const y = bytes.slice(32 + offset, 64 + offset);
+    return {
+        prefix: bytes.length === 65 ? bytes[0] : undefined,
+        x: BigInt(src_esm_utils_bytesToHex(x)),
+        y: BigInt(src_esm_utils_bytesToHex(y)),
+    };
+}
+/**
+ * Serializes a public key into a hex string or bytes.
+ */
+function src_serializePublicKey(publicKey, options = {}) {
+    const { compressed = false, to = 'hex' } = options;
+    const result = Uint8Array.from([
+        ...(publicKey.prefix && !compressed ? [publicKey.prefix] : []),
+        ...numberToBytesBE(publicKey.x, 32),
+        ...numberToBytesBE(publicKey.y, 32),
+    ]);
+    return (to === 'hex' ? bytesToHex(result) : result);
+}
+//# sourceMappingURL=publicKey.js.map
 ;// ../../node_modules/permissionless/_esm/actions/public/getSenderAddress.js
 
 
@@ -16177,6 +16538,129 @@ const src_getNonceKeyWithEncoding = (kernelVersion, validatorAddress, nonceKey =
     return BigInt(encoding);
 };
 //# sourceMappingURL=getNonceKey.js.map
+;// ../../node_modules/permissionless/_esm/accounts/kernel/utils/isWebAuthnAccount.js
+const src_isWebAuthnAccount = (owner) => {
+    return owner.type === "webAuthn";
+};
+//# sourceMappingURL=isWebAuthnAccount.js.map
+;// ../../node_modules/webauthn-p256/_esm/sign.js
+
+
+
+/**
+ * Signs a hash using a stored credential. If no credential is provided,
+ * a prompt will be displayed for the user to select an existing credential
+ * that was previously registered.
+ *
+ * @example
+ * ```ts
+ * import { credential } from './credential'
+ *
+ * const signature = await sign({
+ *   credentialId: credential.id,
+ *   hash: '0x...',
+ * })
+ * ```
+ */
+async function src_sign(parameters) {
+    const { getFn = window.navigator.credentials.get.bind(window.navigator.credentials), ...rest } = parameters;
+    const options = src_getCredentialSignRequestOptions(rest);
+    try {
+        const credential = (await getFn(options));
+        if (!credential)
+            throw new Error('credential request failed.');
+        const response = credential.response;
+        const clientDataJSON = String.fromCharCode(...new Uint8Array(response.clientDataJSON));
+        const challengeIndex = clientDataJSON.indexOf('"challenge"');
+        const typeIndex = clientDataJSON.indexOf('"type"');
+        const signature = src_parseAsn1Signature(base64UrlToBytes(bytesToBase64Url(new Uint8Array(response.signature))));
+        return {
+            signature: src_serializeSignature(signature),
+            webauthn: {
+                authenticatorData: bytesToHex(new Uint8Array(response.authenticatorData)),
+                clientDataJSON,
+                challengeIndex,
+                typeIndex,
+                userVerificationRequired: options.publicKey.userVerification === 'required',
+            },
+            raw: credential,
+        };
+    }
+    catch (error) {
+        throw new Error('credential request failed.', { cause: error });
+    }
+}
+/**
+ * Returns the request options to sign a hash using a stored credential
+ * with a P256 public key.
+ *
+ * @example
+ * ```ts
+ * const options = getCredentialSignRequestOptions({ hash: '0x...' })
+ * const credentials = window.navigator.credentials.get(options)
+ * ```
+ */
+function src_getCredentialSignRequestOptions(parameters) {
+    const { credentialId, hash, rpId = window.location.hostname, userVerification = 'required', } = parameters;
+    const challenge = base64UrlToBytes(bytesToBase64Url(hexToBytes(hash)));
+    return {
+        publicKey: {
+            ...(credentialId
+                ? {
+                    allowCredentials: [
+                        {
+                            id: base64UrlToBytes(credentialId),
+                            type: 'public-key',
+                        },
+                    ],
+                }
+                : {}),
+            challenge,
+            rpId,
+            userVerification,
+        },
+    };
+}
+/**
+ * @internal
+ * Parses an ASN.1 signature into a r and s value.
+ */
+function src_parseAsn1Signature(bytes) {
+    const r_start = bytes[4] === 0 ? 5 : 4;
+    const r_end = r_start + 32;
+    const s_start = bytes[r_end + 2] === 0 ? r_end + 3 : r_end + 2;
+    const r = BigInt(bytesToHex(bytes.slice(r_start, r_end)));
+    const s = BigInt(bytesToHex(bytes.slice(s_start)));
+    const n = p256.CURVE.n;
+    return {
+        r,
+        s: s > n / 2n ? n - s : s,
+    };
+}
+/**
+ * Parses a serialized signature into r and s values.
+ */
+function src_parseSignature(signature) {
+    const bytes = typeof signature === 'string' ? src_esm_utils_hexToBytes(signature) : signature;
+    const r = bytes.slice(0, 32);
+    const s = bytes.slice(32, 64);
+    return {
+        r: BigInt(src_esm_utils_bytesToHex(r)),
+        s: BigInt(src_esm_utils_bytesToHex(s)),
+    };
+}
+/**
+ * Serializes a signature into a hex string or bytes.
+ */
+function src_serializeSignature(signature, options = {}) {
+    const { to = 'hex' } = options;
+    const result = new Uint8Array([
+        ...numberToBytesBE(signature.r, 32),
+        ...numberToBytesBE(signature.s, 32),
+    ]);
+    return (to === 'hex' ? bytesToHex(result) : result);
+}
+//# sourceMappingURL=sign.js.map
 ;// ../../node_modules/permissionless/_esm/accounts/kernel/utils/wrapMessageHash.js
 
 
@@ -16201,7 +16685,55 @@ const src_wrapMessageHash = (messageHash, { accountAddress, kernelVersion, chain
 
 
 
+
+
 async function src_signMessage_signMessage({ message, owner, accountAddress, kernelVersion: accountVersion, chainId }) {
+    if (src_isWebAuthnAccount(owner)) {
+        let messageContent;
+        if (typeof message === "string") {
+            // message is a string
+            messageContent = src_wrapMessageHash((0,src_external_viem_namespaceObject.hashMessage)(message), {
+                kernelVersion: accountVersion,
+                accountAddress,
+                chainId
+                // chainId: client.chain
+                //     ? client.chain.id
+                //     : await client.extend(publicActions).getChainId()
+            });
+        }
+        else if ("raw" in message && typeof message.raw === "string") {
+            // message.raw is a Hex string
+            messageContent = message.raw;
+        }
+        else if ("raw" in message && message.raw instanceof Uint8Array) {
+            // message.raw is a ByteArray
+            messageContent = message.raw.toString();
+        }
+        else {
+            throw new Error("Unsupported message format");
+        }
+        const { signature: signatureData, webauthn } = await owner.sign({
+            hash: messageContent
+        });
+        const signature = src_parseSignature(signatureData);
+        // encode signature
+        const encodedSignature = (0,src_external_viem_namespaceObject.encodeAbiParameters)([
+            { name: "authenticatorData", type: "bytes" },
+            { name: "clientDataJSON", type: "string" },
+            { name: "responseTypeLocation", type: "uint256" },
+            { name: "r", type: "uint256" },
+            { name: "s", type: "uint256" },
+            { name: "usePrecompiled", type: "bool" }
+        ], [
+            webauthn.authenticatorData,
+            webauthn.clientDataJSON,
+            BigInt(webauthn.typeIndex),
+            BigInt(signature.r),
+            BigInt(signature.s),
+            false // TODO: check if it is a RIP 7212 supported network
+        ]);
+        return encodedSignature;
+    }
     if (accountVersion === "0.2.1" || accountVersion === "0.2.2") {
         return owner.signMessage({
             message
@@ -16223,9 +16755,12 @@ async function src_signMessage_signMessage({ message, owner, accountAddress, ker
 ;// ../../node_modules/permissionless/_esm/accounts/kernel/utils/signTypedData.js
 
 
+
+
 async function src_signTypedData_signTypedData(parameters) {
     const { owner, accountAddress, kernelVersion: accountVersion, chainId, ...typedData } = parameters;
-    if (accountVersion === "0.2.1" || accountVersion === "0.2.2") {
+    if ((accountVersion === "0.2.1" || accountVersion === "0.2.2") &&
+        !src_isWebAuthnAccount(owner)) {
         return owner.signTypedData({
             ...typedData
         });
@@ -16251,12 +16786,23 @@ async function src_signTypedData_signTypedData(parameters) {
         accountAddress,
         chainId: chainId
     });
+    if (src_isWebAuthnAccount(owner)) {
+        return src_signMessage_signMessage({
+            message: { raw: wrappedMessageHash },
+            owner,
+            accountAddress,
+            kernelVersion: accountVersion,
+            chainId
+        });
+    }
     return owner.signMessage({
         message: { raw: wrappedMessageHash }
     });
 }
 //# sourceMappingURL=signTypedData.js.map
-;// ../../node_modules/permissionless/_esm/accounts/kernel/toEcdsaKernelSmartAccount.js
+;// ../../node_modules/permissionless/_esm/accounts/kernel/toKernelSmartAccount.js
+
+
 
 
 
@@ -16335,13 +16881,15 @@ const src_KERNEL_VERSION_TO_ADDRESSES_MAP = {
         ECDSA_VALIDATOR: "0x8104e3Ad430EA6d354d013A6789fDFc71E671c43",
         ACCOUNT_LOGIC: "0x94F097E1ebEB4ecA3AAE54cabb08905B239A7D27",
         FACTORY_ADDRESS: "0x6723b44Abeec4E71eBE3232BD5B455805baDD22f",
-        META_FACTORY_ADDRESS: "0xd703aaE79538628d27099B8c4f621bE4CCd142d5"
+        META_FACTORY_ADDRESS: "0xd703aaE79538628d27099B8c4f621bE4CCd142d5",
+        WEB_AUTHN_VALIDATOR: "0xbA45a2BFb8De3D24cA9D7F1B551E14dFF5d690Fd"
     },
     "0.3.1": {
         ECDSA_VALIDATOR: "0x845ADb2C711129d4f3966735eD98a9F09fC4cE57",
         ACCOUNT_LOGIC: "0xBAC849bB641841b44E965fB01A4Bf5F074f84b4D",
         FACTORY_ADDRESS: "0xaac5D4240AF87249B3f71BC8E4A2cae074A3E419",
-        META_FACTORY_ADDRESS: "0xd703aaE79538628d27099B8c4f621bE4CCd142d5"
+        META_FACTORY_ADDRESS: "0xd703aaE79538628d27099B8c4f621bE4CCd142d5",
+        WEB_AUTHN_VALIDATOR: "0xbA45a2BFb8De3D24cA9D7F1B551E14dFF5d690Fd"
     }
 };
 /**
@@ -16362,14 +16910,15 @@ const src_getDefaultKernelVersion = (entryPointVersion, version) => {
  * @param factoryAddress
  * @param metaFactoryAddress
  */
-const src_getDefaultAddresses = ({ ecdsaValidatorAddress: _ecdsaValidatorAddress, accountLogicAddress: _accountLogicAddress, factoryAddress: _factoryAddress, metaFactoryAddress: _metaFactoryAddress, kernelVersion }) => {
+const src_getDefaultAddresses = ({ validatorAddress: _validatorAddress, accountLogicAddress: _accountLogicAddress, factoryAddress: _factoryAddress, metaFactoryAddress: _metaFactoryAddress, kernelVersion, isWebAuthn }) => {
     const addresses = src_KERNEL_VERSION_TO_ADDRESSES_MAP[kernelVersion];
-    const ecdsaValidatorAddress = _ecdsaValidatorAddress ?? addresses.ECDSA_VALIDATOR;
+    const validatorAddress = _validatorAddress ??
+        (isWebAuthn ? addresses.WEB_AUTHN_VALIDATOR : addresses.ECDSA_VALIDATOR);
     const accountLogicAddress = _accountLogicAddress ?? addresses.ACCOUNT_LOGIC;
     const factoryAddress = _factoryAddress ?? addresses.FACTORY_ADDRESS;
     const metaFactoryAddress = _metaFactoryAddress ?? addresses?.META_FACTORY_ADDRESS ?? src_external_viem_namespaceObject.zeroAddress; // Meta Factory doesn't exists for Kernel v2.2
     return {
-        ecdsaValidatorAddress,
+        validatorAddress,
         accountLogicAddress,
         factoryAddress,
         metaFactoryAddress
@@ -16384,12 +16933,12 @@ const src_getEcdsaRootIdentifierForKernelV3 = (validatorAddress) => {
  * @param owner
  * @param ecdsaValidatorAddress
  */
-const src_getInitializationData = ({ entryPoint: { version: entryPointVersion }, kernelVersion, owner, ecdsaValidatorAddress }) => {
+const src_getInitializationData = ({ entryPoint: { version: entryPointVersion }, kernelVersion, validatorData, validatorAddress }) => {
     if (entryPointVersion === "0.6") {
         return (0,src_external_viem_namespaceObject.encodeFunctionData)({
             abi: src_KernelInitAbi,
             functionName: "initialize",
-            args: [ecdsaValidatorAddress, owner]
+            args: [validatorAddress, validatorData]
         });
     }
     if (kernelVersion === "0.3.0-beta") {
@@ -16397,9 +16946,9 @@ const src_getInitializationData = ({ entryPoint: { version: entryPointVersion },
             abi: src_KernelV3InitAbi,
             functionName: "initialize",
             args: [
-                src_getEcdsaRootIdentifierForKernelV3(ecdsaValidatorAddress),
+                src_getEcdsaRootIdentifierForKernelV3(validatorAddress),
                 src_external_viem_namespaceObject.zeroAddress,
-                owner,
+                validatorData,
                 "0x"
             ]
         });
@@ -16408,14 +16957,44 @@ const src_getInitializationData = ({ entryPoint: { version: entryPointVersion },
         abi: src_KernelV3_1AccountAbi,
         functionName: "initialize",
         args: [
-            src_getEcdsaRootIdentifierForKernelV3(ecdsaValidatorAddress),
+            src_getEcdsaRootIdentifierForKernelV3(validatorAddress),
             src_external_viem_namespaceObject.zeroAddress,
-            owner,
+            validatorData,
             "0x",
             []
         ]
     });
 };
+const src_getValidatorData = async (owner) => {
+    if (owner.type === "local") {
+        return owner.address;
+    }
+    if (src_isWebAuthnAccount(owner)) {
+        const parsedPublicKey = src_parsePublicKey(owner.publicKey);
+        const authenticatorIdHash = (0,src_external_viem_namespaceObject.keccak256)(src_esm_utils_bytesToHex(src_utils_base64UrlToBytes(owner.id)));
+        return (0,src_external_viem_namespaceObject.encodeAbiParameters)([
+            {
+                components: [
+                    { name: "x", type: "uint256" },
+                    { name: "y", type: "uint256" }
+                ],
+                name: "webAuthnData",
+                type: "tuple"
+            },
+            {
+                name: "authenticatorIdHash",
+                type: "bytes32"
+            }
+        ], [
+            {
+                x: parsedPublicKey.x,
+                y: parsedPublicKey.y
+            },
+            authenticatorIdHash
+        ]);
+    }
+    throw new Error("Invalid owner type");
+};
 /**
  * Get the account initialization code for a kernel smart account
  * @param entryPoint
@@ -16425,13 +17004,13 @@ const src_getInitializationData = ({ entryPoint: { version: entryPointVersion },
  * @param accountLogicAddress
  * @param ecdsaValidatorAddress
  */
-const src_toEcdsaKernelSmartAccount_getAccountInitCode = async ({ entryPointVersion, kernelVersion, owner, index, factoryAddress, accountLogicAddress, ecdsaValidatorAddress }) => {
+const src_toKernelSmartAccount_getAccountInitCode = async ({ entryPointVersion, kernelVersion, validatorData, index, factoryAddress, accountLogicAddress, validatorAddress }) => {
     // Build the account initialization data
     const initializationData = src_getInitializationData({
         entryPoint: { version: entryPointVersion },
         kernelVersion,
-        ecdsaValidatorAddress,
-        owner
+        validatorAddress,
+        validatorData
     });
     // Build the account init code
     if (entryPointVersion === "0.6") {
@@ -16448,18 +17027,23 @@ const src_toEcdsaKernelSmartAccount_getAccountInitCode = async ({ entryPointVers
     });
 };
 /**
- * Build a kernel smart account from a private key, that use the ECDSA signer behind the scene
+ * Build a kernel smart account from a private key, that use the ECDSA or passkeys signer behind the scene
  * @param client
  * @param privateKey
  * @param entryPoint
  * @param index
  * @param factoryAddress
  * @param accountLogicAddress
- * @param ecdsaValidatorAddress
+ * @param validatorAddress
  */
-async function src_toEcdsaKernelSmartAccount(parameters) {
-    const { client, address, index = 0n, owners, version, ecdsaValidatorAddress: _ecdsaValidatorAddress, factoryAddress: _factoryAddress, metaFactoryAddress: _metaFactoryAddress, accountLogicAddress: _accountLogicAddress } = parameters;
-    const localOwner = await src_toOwner({ owner: owners[0] });
+async function src_toKernelSmartAccount(parameters) {
+    const { client, address, index = 0n, owners, version, validatorAddress: _validatorAddress, factoryAddress: _factoryAddress, metaFactoryAddress: _metaFactoryAddress, accountLogicAddress: _accountLogicAddress } = parameters;
+    const isWebAuthn = owners[0].type === "webAuthn";
+    const owner = isWebAuthn
+        ? owners[0]
+        : await src_toOwner({
+            owner: owners[0]
+        });
     const entryPoint = {
         address: parameters.entryPoint?.address ?? src_entryPoint07Address,
         abi: (parameters.entryPoint?.version ?? "0.7") === "0.6"
@@ -16468,22 +17052,26 @@ async function src_toEcdsaKernelSmartAccount(parameters) {
         version: parameters.entryPoint?.version ?? "0.7"
     };
     const kernelVersion = src_getDefaultKernelVersion(entryPoint.version, version);
-    const { accountLogicAddress, ecdsaValidatorAddress, factoryAddress, metaFactoryAddress } = src_getDefaultAddresses({
-        ecdsaValidatorAddress: _ecdsaValidatorAddress,
+    const { accountLogicAddress, validatorAddress, factoryAddress, metaFactoryAddress } = src_getDefaultAddresses({
+        validatorAddress: _validatorAddress,
         accountLogicAddress: _accountLogicAddress,
         factoryAddress: _factoryAddress,
         metaFactoryAddress: _metaFactoryAddress,
-        kernelVersion
+        kernelVersion,
+        isWebAuthn
     });
+    if (!validatorAddress) {
+        throw new Error("Validator address is required");
+    }
     // Helper to generate the init code for the smart account
-    const generateInitCode = () => src_toEcdsaKernelSmartAccount_getAccountInitCode({
+    const generateInitCode = async () => src_toKernelSmartAccount_getAccountInitCode({
         entryPointVersion: entryPoint.version,
         kernelVersion,
-        owner: localOwner.address,
+        validatorData: await src_getValidatorData(owner),
         index,
         factoryAddress,
         accountLogicAddress,
-        ecdsaValidatorAddress
+        validatorAddress
     });
     let accountAddress = address;
     let chainId;
@@ -16526,7 +17114,7 @@ async function src_toEcdsaKernelSmartAccount(parameters) {
             return src_getAccountNonce(client, {
                 address: await this.getAddress(),
                 entryPointAddress: entryPoint.address,
-                key: src_getNonceKeyWithEncoding(kernelVersion, ecdsaValidatorAddress, 
+                key: src_getNonceKeyWithEncoding(kernelVersion, validatorAddress, 
                 /*args?.key ?? */ parameters.nonceKey ?? 0n)
             });
         },
@@ -16534,6 +17122,23 @@ async function src_toEcdsaKernelSmartAccount(parameters) {
             if (src_isKernelV2(kernelVersion)) {
                 return (0,src_external_viem_namespaceObject.concatHex)([src_ROOT_MODE_KERNEL_V2, src_DUMMY_ECDSA_SIGNATURE]);
             }
+            if (src_isWebAuthnAccount(owner)) {
+                return (0,src_external_viem_namespaceObject.encodeAbiParameters)([
+                    { name: "authenticatorData", type: "bytes" },
+                    { name: "clientDataJSON", type: "string" },
+                    { name: "responseTypeLocation", type: "uint256" },
+                    { name: "r", type: "uint256" },
+                    { name: "s", type: "uint256" },
+                    { name: "usePrecompiled", type: "bool" }
+                ], [
+                    "0x49960de5880e8c687434170f6476605b8fe4aeb9a28632c7995cf3ba831d97631d00000000",
+                    '{"type":"webauthn.get","challenge":"tbxXNFS9X_4Byr1cMwqKrIGB-_30a0QhZ6y7ucM0BOE","origin":"http://localhost:3000","crossOrigin":false, "other_keys_can_be_added_here":"do not compare clientDataJSON against a template. See https://goo.gl/yabPex"}',
+                    1n,
+                    44941127272049826721201904734628716258498742255959991581049806490182030242267n,
+                    9910254599581058084911561569808925251374718953855182016200087235935345969636n,
+                    false
+                ]);
+            }
             return src_DUMMY_ECDSA_SIGNATURE;
         },
         async sign({ hash }) {
@@ -16541,7 +17146,7 @@ async function src_toEcdsaKernelSmartAccount(parameters) {
         },
         async signMessage({ message }) {
             const signature = await src_signMessage_signMessage({
-                owner: localOwner,
+                owner,
                 message,
                 accountAddress: await this.getAddress(),
                 kernelVersion,
@@ -16551,13 +17156,13 @@ async function src_toEcdsaKernelSmartAccount(parameters) {
                 return signature;
             }
             return (0,src_external_viem_namespaceObject.concatHex)([
-                src_getEcdsaRootIdentifierForKernelV3(ecdsaValidatorAddress),
+                src_getEcdsaRootIdentifierForKernelV3(validatorAddress),
                 signature
             ]);
         },
         async signTypedData(typedData) {
             const signature = await src_signTypedData_signTypedData({
-                owner: localOwner,
+                owner: owner,
                 chainId: await getMemoizedChainId(),
                 ...typedData,
                 accountAddress: await this.getAddress(),
@@ -16567,7 +17172,7 @@ async function src_toEcdsaKernelSmartAccount(parameters) {
                 return signature;
             }
             return (0,src_external_viem_namespaceObject.concatHex)([
-                src_getEcdsaRootIdentifierForKernelV3(ecdsaValidatorAddress),
+                src_getEcdsaRootIdentifierForKernelV3(validatorAddress),
                 signature
             ]);
         },
@@ -16584,9 +17189,17 @@ async function src_toEcdsaKernelSmartAccount(parameters) {
                 entryPointVersion: entryPoint.version,
                 chainId: chainId
             });
-            const signature = await localOwner.signMessage({
-                message: { raw: hash }
-            });
+            const signature = src_isWebAuthnAccount(owner)
+                ? await src_signMessage_signMessage({
+                    owner,
+                    message: { raw: hash },
+                    chainId,
+                    accountAddress: await this.getAddress(),
+                    kernelVersion
+                })
+                : await owner.signMessage({
+                    message: { raw: hash }
+                });
             // Always use the sudo mode, since we will use external paymaster
             if (src_isKernelV2(kernelVersion)) {
                 return (0,src_external_viem_namespaceObject.concatHex)(["0x00000000", signature]);
@@ -16595,6 +17208,19 @@ async function src_toEcdsaKernelSmartAccount(parameters) {
         }
     });
 }
+//# sourceMappingURL=toKernelSmartAccount.js.map
+;// ../../node_modules/permissionless/_esm/accounts/kernel/toEcdsaKernelSmartAccount.js
+
+/**
+ * @deprecated ECDSA Kernel Smart Account is deprecated. Please use toKernelSmartAccount instead.
+ * @see toKernelSmartAccount
+ */
+async function src_toEcdsaKernelSmartAccount(parameters) {
+    return src_toKernelSmartAccount({
+        ...parameters,
+        validatorAddress: parameters.validatorAddress ?? parameters.ecdsaValidatorAddress
+    });
+}
 //# sourceMappingURL=toEcdsaKernelSmartAccount.js.map
 ;// ./src/AccountAbstraction/smartAccounts/KernelSmartAccount.ts