@atxp/base 0.9.0 → 0.9.2

package/dist/node_modules/@aa-sdk/core/dist/esm/client/schema.js

@@ -0,0 +1,69 @@
+import { BigNumberishRangeSchema, MultiplierSchema } from '../utils/schema.js';
+import { intersection as intersectionType, union as unionType, object as objectType, never as neverType, string as stringType, number as numberType } from '../../../../../zod/v3/types.js';
+
+// [!region ConnectionConfigSchema]
+// TODO: in v5 either remove this or simplify it (either way this should be moved out of aa-sdk/core)
+const ConnectionConfigSchema = intersectionType(unionType([
+    objectType({
+        rpcUrl: neverType().optional(),
+        apiKey: stringType(),
+        jwt: neverType().optional(),
+    }),
+    objectType({
+        rpcUrl: neverType().optional(),
+        apiKey: neverType().optional(),
+        jwt: stringType(),
+    }),
+    objectType({
+        rpcUrl: stringType(),
+        apiKey: neverType().optional(),
+        jwt: neverType().optional(),
+    }),
+    objectType({
+        rpcUrl: stringType(),
+        apiKey: neverType().optional(),
+        jwt: stringType(),
+    }),
+]), objectType({
+    chainAgnosticUrl: stringType().optional(),
+}));
+// [!endregion ConnectionConfigSchema]
+const UserOperationFeeOptionsFieldSchema = BigNumberishRangeSchema.merge(MultiplierSchema).partial();
+const UserOperationFeeOptionsSchema_v6 = objectType({
+    maxFeePerGas: UserOperationFeeOptionsFieldSchema,
+    maxPriorityFeePerGas: UserOperationFeeOptionsFieldSchema,
+    callGasLimit: UserOperationFeeOptionsFieldSchema,
+    verificationGasLimit: UserOperationFeeOptionsFieldSchema,
+    preVerificationGas: UserOperationFeeOptionsFieldSchema,
+})
+    .partial()
+    .strict();
+const UserOperationFeeOptionsSchema_v7 = UserOperationFeeOptionsSchema_v6.extend({
+    paymasterVerificationGasLimit: UserOperationFeeOptionsFieldSchema,
+    paymasterPostOpGasLimit: UserOperationFeeOptionsFieldSchema,
+})
+    .partial()
+    .strict();
+const UserOperationFeeOptionsSchema = UserOperationFeeOptionsSchema_v7;
+objectType({
+    /**
+     * The maximum number of times to try fetching a transaction receipt before giving up (default: 5)
+     */
+    txMaxRetries: numberType().min(0).optional().default(5),
+    /**
+     * The interval in milliseconds to wait between retries while waiting for tx receipts (default: 2_000)
+     */
+    txRetryIntervalMs: numberType().min(0).optional().default(2000),
+    /**
+     * The multiplier on interval length to wait between retries while waiting for tx receipts (default: 1.5)
+     */
+    txRetryMultiplier: numberType().min(0).optional().default(1.5),
+    /**
+     * Optional user operation fee options to be set globally at the provider level
+     */
+    feeOptions: UserOperationFeeOptionsSchema.optional(),
+})
+    .strict();
+
+export { ConnectionConfigSchema, UserOperationFeeOptionsFieldSchema, UserOperationFeeOptionsSchema, UserOperationFeeOptionsSchema_v6, UserOperationFeeOptionsSchema_v7 };
+//# sourceMappingURL=schema.js.map

package/dist/node_modules/@aa-sdk/core/dist/esm/client/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sources":["../../../../../../../../../node_modules/@aa-sdk/core/dist/esm/client/schema.js"],"sourcesContent":["import { z } from \"zod\";\nimport { BigNumberishRangeSchema, MultiplierSchema } from \"../utils/index.js\";\nexport const createPublicErc4337ClientSchema = () => z.custom((provider) => {\n    return (provider != null &&\n        typeof provider === \"object\" &&\n        \"request\" in provider &&\n        \"type\" in provider &&\n        \"key\" in provider &&\n        \"name\" in provider);\n});\n// [!region ConnectionConfigSchema]\n// TODO: in v5 either remove this or simplify it (either way this should be moved out of aa-sdk/core)\nexport const ConnectionConfigSchema = z.intersection(z.union([\n    z.object({\n        rpcUrl: z.never().optional(),\n        apiKey: z.string(),\n        jwt: z.never().optional(),\n    }),\n    z.object({\n        rpcUrl: z.never().optional(),\n        apiKey: z.never().optional(),\n        jwt: z.string(),\n    }),\n    z.object({\n        rpcUrl: z.string(),\n        apiKey: z.never().optional(),\n        jwt: z.never().optional(),\n    }),\n    z.object({\n        rpcUrl: z.string(),\n        apiKey: z.never().optional(),\n        jwt: z.string(),\n    }),\n]), z.object({\n    chainAgnosticUrl: z.string().optional(),\n}));\n// [!endregion ConnectionConfigSchema]\nexport const UserOperationFeeOptionsFieldSchema = BigNumberishRangeSchema.merge(MultiplierSchema).partial();\nexport const UserOperationFeeOptionsSchema_v6 = z\n    .object({\n    maxFeePerGas: UserOperationFeeOptionsFieldSchema,\n    maxPriorityFeePerGas: UserOperationFeeOptionsFieldSchema,\n    callGasLimit: UserOperationFeeOptionsFieldSchema,\n    verificationGasLimit: UserOperationFeeOptionsFieldSchema,\n    preVerificationGas: UserOperationFeeOptionsFieldSchema,\n})\n    .partial()\n    .strict();\nexport const UserOperationFeeOptionsSchema_v7 = UserOperationFeeOptionsSchema_v6.extend({\n    paymasterVerificationGasLimit: UserOperationFeeOptionsFieldSchema,\n    paymasterPostOpGasLimit: UserOperationFeeOptionsFieldSchema,\n})\n    .partial()\n    .strict();\nexport const UserOperationFeeOptionsSchema = UserOperationFeeOptionsSchema_v7;\nexport const SmartAccountClientOptsSchema = z\n    .object({\n    /**\n     * The maximum number of times to try fetching a transaction receipt before giving up (default: 5)\n     */\n    txMaxRetries: z.number().min(0).optional().default(5),\n    /**\n     * The interval in milliseconds to wait between retries while waiting for tx receipts (default: 2_000)\n     */\n    txRetryIntervalMs: z.number().min(0).optional().default(2000),\n    /**\n     * The multiplier on interval length to wait between retries while waiting for tx receipts (default: 1.5)\n     */\n    txRetryMultiplier: z.number().min(0).optional().default(1.5),\n    /**\n     * Optional user operation fee options to be set globally at the provider level\n     */\n    feeOptions: UserOperationFeeOptionsSchema.optional(),\n})\n    .strict();\n//# sourceMappingURL=schema.js.map"],"names":["z.intersection","z.union","z.object","z.never","z.string","z\n    .object","z.number"],"mappings":";;;AAUA;AACA;AACY,MAAC,sBAAsB,GAAGA,gBAAc,CAACC,SAAO,CAAC;AAC7D,IAAIC,UAAQ,CAAC;AACb,QAAQ,MAAM,EAAEC,SAAO,EAAE,CAAC,QAAQ,EAAE;AACpC,QAAQ,MAAM,EAAEC,UAAQ,EAAE;AAC1B,QAAQ,GAAG,EAAED,SAAO,EAAE,CAAC,QAAQ,EAAE;AACjC,KAAK,CAAC;AACN,IAAID,UAAQ,CAAC;AACb,QAAQ,MAAM,EAAEC,SAAO,EAAE,CAAC,QAAQ,EAAE;AACpC,QAAQ,MAAM,EAAEA,SAAO,EAAE,CAAC,QAAQ,EAAE;AACpC,QAAQ,GAAG,EAAEC,UAAQ,EAAE;AACvB,KAAK,CAAC;AACN,IAAIF,UAAQ,CAAC;AACb,QAAQ,MAAM,EAAEE,UAAQ,EAAE;AAC1B,QAAQ,MAAM,EAAED,SAAO,EAAE,CAAC,QAAQ,EAAE;AACpC,QAAQ,GAAG,EAAEA,SAAO,EAAE,CAAC,QAAQ,EAAE;AACjC,KAAK,CAAC;AACN,IAAID,UAAQ,CAAC;AACb,QAAQ,MAAM,EAAEE,UAAQ,EAAE;AAC1B,QAAQ,MAAM,EAAED,SAAO,EAAE,CAAC,QAAQ,EAAE;AACpC,QAAQ,GAAG,EAAEC,UAAQ,EAAE;AACvB,KAAK,CAAC;AACN,CAAC,CAAC,EAAEF,UAAQ,CAAC;AACb,IAAI,gBAAgB,EAAEE,UAAQ,EAAE,CAAC,QAAQ,EAAE;AAC3C,CAAC,CAAC;AACF;AACY,MAAC,kCAAkC,GAAG,uBAAuB,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,OAAO;AAC7F,MAAC,gCAAgC,GAAGC,UACrC,CAAC;AACZ,IAAI,YAAY,EAAE,kCAAkC;AACpD,IAAI,oBAAoB,EAAE,kCAAkC;AAC5D,IAAI,YAAY,EAAE,kCAAkC;AACpD,IAAI,oBAAoB,EAAE,kCAAkC;AAC5D,IAAI,kBAAkB,EAAE,kCAAkC;AAC1D,CAAC;AACD,KAAK,OAAO;AACZ,KAAK,MAAM;AACC,MAAC,gCAAgC,GAAG,gCAAgC,CAAC,MAAM,CAAC;AACxF,IAAI,6BAA6B,EAAE,kCAAkC;AACrE,IAAI,uBAAuB,EAAE,kCAAkC;AAC/D,CAAC;AACD,KAAK,OAAO;AACZ,KAAK,MAAM;AACC,MAAC,6BAA6B,GAAG;AACDA,UACjC,CAAC;AACZ;AACA;AACA;AACA,IAAI,YAAY,EAAEC,UAAQ,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;AACzD;AACA;AACA;AACA,IAAI,iBAAiB,EAAEA,UAAQ,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;AACjE;AACA;AACA;AACA,IAAI,iBAAiB,EAAEA,UAAQ,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC;AAChE;AACA;AACA;AACA,IAAI,UAAU,EAAE,6BAA6B,CAAC,QAAQ,EAAE;AACxD,CAAC;AACD,KAAK,MAAM;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@aa-sdk/core/dist/esm/errors/base.js

@@ -0,0 +1,43 @@
+import { BaseError as BaseError$1 } from 'viem';
+import { VERSION } from '../version.js';
+
+/**
+ * A custom error class that extends from `ViemBaseError`. This class allows for error messages to include links to relevant documentation based on provided `docsPath` and `docsSlug` parameters.
+ * This is based on on viem's BaseError type (obviously from the import and extend)
+ * we want the errors here to point to our docs if we supply a docsPath though
+ */
+class BaseError extends BaseError$1 {
+    constructor(shortMessage, args = {}) {
+        super(shortMessage, args);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "AASDKError"
+        });
+        Object.defineProperty(this, "version", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: VERSION
+        });
+        const docsPath = args.cause instanceof BaseError
+            ? args.cause.docsPath || args.docsPath
+            : args.docsPath;
+        this.message = [
+            shortMessage || "An error occurred.",
+            "",
+            ...(args.metaMessages ? [...args.metaMessages, ""] : []),
+            ...(docsPath
+                ? [
+                    `Docs: https://www.alchemy.com/docs/wallets${docsPath}${args.docsSlug ? `#${args.docsSlug}` : ""}`,
+                ]
+                : []),
+            ...(this.details ? [`Details: ${this.details}`] : []),
+            `Version: ${this.version}`,
+        ].join("\n");
+    }
+}
+
+export { BaseError };
+//# sourceMappingURL=base.js.map

package/dist/node_modules/@aa-sdk/core/dist/esm/errors/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sources":["../../../../../../../../../node_modules/@aa-sdk/core/dist/esm/errors/base.js"],"sourcesContent":["import { BaseError as ViemBaseError } from \"viem\";\nimport { VERSION } from \"../version.js\";\n/**\n * A custom error class that extends from `ViemBaseError`. This class allows for error messages to include links to relevant documentation based on provided `docsPath` and `docsSlug` parameters.\n * This is based on on viem's BaseError type (obviously from the import and extend)\n * we want the errors here to point to our docs if we supply a docsPath though\n */\nexport class BaseError extends ViemBaseError {\n    constructor(shortMessage, args = {}) {\n        super(shortMessage, args);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: \"AASDKError\"\n        });\n        Object.defineProperty(this, \"version\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: VERSION\n        });\n        const docsPath = args.cause instanceof BaseError\n            ? args.cause.docsPath || args.docsPath\n            : args.docsPath;\n        this.message = [\n            shortMessage || \"An error occurred.\",\n            \"\",\n            ...(args.metaMessages ? [...args.metaMessages, \"\"] : []),\n            ...(docsPath\n                ? [\n                    `Docs: https://www.alchemy.com/docs/wallets${docsPath}${args.docsSlug ? `#${args.docsSlug}` : \"\"}`,\n                ]\n                : []),\n            ...(this.details ? [`Details: ${this.details}`] : []),\n            `Version: ${this.version}`,\n        ].join(\"\\n\");\n    }\n}\n//# sourceMappingURL=base.js.map"],"names":["ViemBaseError"],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACO,MAAM,SAAS,SAASA,WAAa,CAAC;AAC7C,IAAI,WAAW,CAAC,YAAY,EAAE,IAAI,GAAG,EAAE,EAAE;AACzC,QAAQ,KAAK,CAAC,YAAY,EAAE,IAAI,CAAC;AACjC,QAAQ,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE;AAC5C,YAAY,UAAU,EAAE,IAAI;AAC5B,YAAY,YAAY,EAAE,IAAI;AAC9B,YAAY,QAAQ,EAAE,IAAI;AAC1B,YAAY,KAAK,EAAE;AACnB,SAAS,CAAC;AACV,QAAQ,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,SAAS,EAAE;AAC/C,YAAY,UAAU,EAAE,IAAI;AAC5B,YAAY,YAAY,EAAE,IAAI;AAC9B,YAAY,QAAQ,EAAE,IAAI;AAC1B,YAAY,KAAK,EAAE;AACnB,SAAS,CAAC;AACV,QAAQ,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,YAAY;AAC/C,cAAc,IAAI,CAAC,KAAK,CAAC,QAAQ,IAAI,IAAI,CAAC;AAC1C,cAAc,IAAI,CAAC,QAAQ;AAC3B,QAAQ,IAAI,CAAC,OAAO,GAAG;AACvB,YAAY,YAAY,IAAI,oBAAoB;AAChD,YAAY,EAAE;AACd,YAAY,IAAI,IAAI,CAAC,YAAY,GAAG,CAAC,GAAG,IAAI,CAAC,YAAY,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC;AACpE,YAAY,IAAI;AAChB,kBAAkB;AAClB,oBAAoB,CAAC,0CAA0C,EAAE,QAAQ,CAAC,EAAE,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;AACtH;AACA,kBAAkB,EAAE,CAAC;AACrB,YAAY,IAAI,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;AACjE,YAAY,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;AACtC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC;AACpB,IAAI;AACJ;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@aa-sdk/core/dist/esm/errors/client.js

@@ -0,0 +1,22 @@
+import { BaseError } from './base.js';
+
+/**
+ * Error class representing a "Chain Not Found" error, typically thrown when no chain is supplied to the client.
+ */
+class ChainNotFoundError extends BaseError {
+    /**
+     * Initializes a new instance of the error message with a default message indicating that no chain was supplied to the client.
+     */
+    constructor() {
+        super("No chain supplied to the client");
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "ChainNotFoundError"
+        });
+    }
+}
+
+export { ChainNotFoundError };
+//# sourceMappingURL=client.js.map

package/dist/node_modules/@aa-sdk/core/dist/esm/errors/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sources":["../../../../../../../../../node_modules/@aa-sdk/core/dist/esm/errors/client.js"],"sourcesContent":["import { BaseError } from \"./base.js\";\n/**\n * Represents an error thrown when a client is not compatible with the expected client type for a specific method. The error message provides guidance on how to create a compatible client.\n */\nexport class IncompatibleClientError extends BaseError {\n    /**\n     * Throws an error when the client type does not match the expected client type.\n     *\n     * @param {string} expectedClient The expected type of the client.\n     * @param {string} method The method that was called.\n     * @param {Client} client The client instance.\n     */\n    constructor(expectedClient, method, client) {\n        super([\n            `Client of type (${client.type}) is not a ${expectedClient}.`,\n            `Create one with \\`createSmartAccountClient\\` first before using \\`${method}\\``,\n        ].join(\"\\n\"));\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: \"IncompatibleClientError\"\n        });\n    }\n}\n/**\n * Represents an error that occurs when an invalid RPC URL is provided. This class extends the `BaseError` class and includes the invalid URL in the error message.\n */\nexport class InvalidRpcUrlError extends BaseError {\n    /**\n     * Creates an instance of an error with a message indicating an invalid RPC URL.\n     *\n     * @param {string} [rpcUrl] The invalid RPC URL that caused the error\n     */\n    constructor(rpcUrl) {\n        super(`Invalid RPC URL ${rpcUrl}`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: \"InvalidRpcUrlError\"\n        });\n    }\n}\n/**\n * Error class representing a \"Chain Not Found\" error, typically thrown when no chain is supplied to the client.\n */\nexport class ChainNotFoundError extends BaseError {\n    /**\n     * Initializes a new instance of the error message with a default message indicating that no chain was supplied to the client.\n     */\n    constructor() {\n        super(\"No chain supplied to the client\");\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: \"ChainNotFoundError\"\n        });\n    }\n}\n/**\n * Error class denoting that the provided entity id is invalid because it's too large.\n */\nexport class InvalidEntityIdError extends BaseError {\n    /**\n     * Initializes a new instance of the error message with a default message indicating that the entity id is invalid because it's too large.\n     *\n     * @param {number} entityId the invalid entityId used\n     */\n    constructor(entityId) {\n        super(`Entity ID used is ${entityId}, but must be less than or equal to uint32.max`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: \"InvalidEntityIdError\"\n        });\n    }\n}\n/**\n * Error class denoting that the nonce key is invalid because its too large.\n */\nexport class InvalidNonceKeyError extends BaseError {\n    /**\n     * Initializes a new instance of the error message with a default message indicating that the nonce key is invalid.\n     *\n     * @param {bigint} nonceKey the invalid nonceKey used\n     */\n    constructor(nonceKey) {\n        super(`Nonce key is ${nonceKey} but has to be less than or equal to 2**152`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: \"InvalidNonceKeyError\"\n        });\n    }\n}\n/**\n * Error class denoting that the provided entity id is invalid because it's overriding the native entity id.\n */\nexport class EntityIdOverrideError extends BaseError {\n    /**\n     * Initializes a new instance of the error message with a default message indicating that the nonce key is invalid.\n     */\n    constructor() {\n        super(`EntityId of 0 is reserved for the owner and cannot be used`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: \"EntityIdOverrideError\"\n        });\n    }\n}\n/**\n * Error class denoting that the provided ma v2 account mode is invalid.\n */\nexport class InvalidModularAccountV2Mode extends BaseError {\n    /**\n     * Initializes a new instance of the error message with a default message indicating that the provided ma v2 account mode is invalid.\n     */\n    constructor() {\n        super(`The provided account mode is invalid for ModularAccount V2`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: \"InvalidModularAccountV2Mode\"\n        });\n    }\n}\n/**\n * Error class denoting that the deferred action nonce used is invalid.\n */\nexport class InvalidDeferredActionNonce extends BaseError {\n    /**\n     * Initializes a new instance of the error message with a default message indicating that the provided deferred action nonce is invalid.\n     */\n    constructor() {\n        super(`The provided deferred action nonce is invalid`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: \"InvalidDeferredActionNonce\"\n        });\n    }\n}\n//# sourceMappingURL=client.js.map"],"names":[],"mappings":";;AA4CA;AACA;AACA;AACO,MAAM,kBAAkB,SAAS,SAAS,CAAC;AAClD;AACA;AACA;AACA,IAAI,WAAW,GAAG;AAClB,QAAQ,KAAK,CAAC,iCAAiC,CAAC;AAChD,QAAQ,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE;AAC5C,YAAY,UAAU,EAAE,IAAI;AAC5B,YAAY,YAAY,EAAE,IAAI;AAC9B,YAAY,QAAQ,EAAE,IAAI;AAC1B,YAAY,KAAK,EAAE;AACnB,SAAS,CAAC;AACV,IAAI;AACJ;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@aa-sdk/core/dist/esm/transport/split.js

@@ -0,0 +1,57 @@
+import { custom } from 'viem';
+
+/**
+ * The Split Transport allows you to split RPC traffic for specific methods across
+ * different RPC providers. This is done by specifying the methods you want handled
+ * specially as overrides and providing a fallback transport for all other methods.
+ *
+ * @example
+ * ```ts
+ * import { createPublicClient, http } from "viem";
+ * import { split } from "@aa-sdk/core";
+ *
+ * const bundlerMethods = [
+ *  "eth_sendUserOperation",
+ *  "eth_estimateUserOperationGas",
+ *  "eth_getUserOperationReceipt",
+ *  "eth_getUserOperationByHash",
+ *  "eth_supportedEntryPoints"
+ * ];
+ *
+ * const clientWithSplit = createPublicClient({
+ *  transport: split({
+ *      overrides: [{
+ *          methods: bundlerMethods,
+ *          transport: http(BUNDLER_RPC_URL)
+ *      }],
+ *      fallback: http(OTHER_RPC_URL)
+ *  }),
+ * });
+ * ```
+ *
+ * @param {SplitTransportParams} params split transport configuration containing the methods overrides and fallback transport
+ * @returns {CustomTransport} a viem Transport that splits traffic
+ */
+const split = (params) => {
+    const overrideMap = params.overrides.reduce((accum, curr) => {
+        curr.methods.forEach((method) => {
+            if (accum.has(method) && accum.get(method) !== curr.transport) {
+                throw new Error("A method cannot be handled by more than one transport");
+            }
+            accum.set(method, curr.transport);
+        });
+        return accum;
+    }, new Map());
+    return (opts) => custom({
+        request: async (args) => {
+            const transportOverride = overrideMap.get(args.method);
+            if (transportOverride != null) {
+                return transportOverride(opts).request(args);
+            }
+            return params.fallback(opts).request(args);
+        },
+    })(opts);
+};
+
+export { split };
+//# sourceMappingURL=split.js.map

package/dist/node_modules/@aa-sdk/core/dist/esm/transport/split.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"split.js","sources":["../../../../../../../../../node_modules/@aa-sdk/core/dist/esm/transport/split.js"],"sourcesContent":["import { custom } from \"viem\";\n/**\n * The Split Transport allows you to split RPC traffic for specific methods across\n * different RPC providers. This is done by specifying the methods you want handled\n * specially as overrides and providing a fallback transport for all other methods.\n *\n * @example\n * ```ts\n * import { createPublicClient, http } from \"viem\";\n * import { split } from \"@aa-sdk/core\";\n *\n * const bundlerMethods = [\n *  \"eth_sendUserOperation\",\n *  \"eth_estimateUserOperationGas\",\n *  \"eth_getUserOperationReceipt\",\n *  \"eth_getUserOperationByHash\",\n *  \"eth_supportedEntryPoints\"\n * ];\n *\n * const clientWithSplit = createPublicClient({\n *  transport: split({\n *      overrides: [{\n *          methods: bundlerMethods,\n *          transport: http(BUNDLER_RPC_URL)\n *      }],\n *      fallback: http(OTHER_RPC_URL)\n *  }),\n * });\n * ```\n *\n * @param {SplitTransportParams} params split transport configuration containing the methods overrides and fallback transport\n * @returns {CustomTransport} a viem Transport that splits traffic\n */\nexport const split = (params) => {\n    const overrideMap = params.overrides.reduce((accum, curr) => {\n        curr.methods.forEach((method) => {\n            if (accum.has(method) && accum.get(method) !== curr.transport) {\n                throw new Error(\"A method cannot be handled by more than one transport\");\n            }\n            accum.set(method, curr.transport);\n        });\n        return accum;\n    }, new Map());\n    return (opts) => custom({\n        request: async (args) => {\n            const transportOverride = overrideMap.get(args.method);\n            if (transportOverride != null) {\n                return transportOverride(opts).request(args);\n            }\n            return params.fallback(opts).request(args);\n        },\n    })(opts);\n};\n//# sourceMappingURL=split.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,KAAK,GAAG,CAAC,MAAM,KAAK;AACjC,IAAI,MAAM,WAAW,GAAG,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,IAAI,KAAK;AACjE,QAAQ,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,KAAK;AACzC,YAAY,IAAI,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC,SAAS,EAAE;AAC3E,gBAAgB,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC;AACxF,YAAY;AACZ,YAAY,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC;AAC7C,QAAQ,CAAC,CAAC;AACV,QAAQ,OAAO,KAAK;AACpB,IAAI,CAAC,EAAE,IAAI,GAAG,EAAE,CAAC;AACjB,IAAI,OAAO,CAAC,IAAI,KAAK,MAAM,CAAC;AAC5B,QAAQ,OAAO,EAAE,OAAO,IAAI,KAAK;AACjC,YAAY,MAAM,iBAAiB,GAAG,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC;AAClE,YAAY,IAAI,iBAAiB,IAAI,IAAI,EAAE;AAC3C,gBAAgB,OAAO,iBAAiB,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC;AAC5D,YAAY;AACZ,YAAY,OAAO,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC;AACtD,QAAQ,CAAC;AACT,KAAK,CAAC,CAAC,IAAI,CAAC;AACZ;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@aa-sdk/core/dist/esm/utils/schema.js

@@ -0,0 +1,33 @@
+import { isHex } from 'viem';
+import { custom, union as unionType, number as numberType, bigint as bigIntType, object as objectType } from '../../../../../zod/v3/types.js';
+
+const ChainSchema = custom((chain) => chain != null &&
+    typeof chain === "object" &&
+    "id" in chain &&
+    typeof chain.id === "number");
+const HexSchema = custom((val) => {
+    return isHex(val, { strict: true });
+});
+// [!region BigNumberish]
+const BigNumberishSchema = unionType([HexSchema, numberType(), bigIntType()]);
+// [!endregion BigNumberish]
+// [!region BigNumberishRange]
+const BigNumberishRangeSchema = objectType({
+    min: BigNumberishSchema.optional(),
+    max: BigNumberishSchema.optional(),
+})
+    .strict();
+// [!endregion BigNumberishRange]
+// [!region Multiplier]
+const MultiplierSchema = objectType({
+    /**
+     * Multiplier value with max precision of 4 decimal places
+     */
+    multiplier: numberType().refine((n) => {
+        return (n.toString().split(".")[1]?.length ?? 0) <= 4;
+    }, { message: "Max precision is 4 decimal places" }),
+})
+    .strict();
+
+export { BigNumberishRangeSchema, BigNumberishSchema, ChainSchema, HexSchema, MultiplierSchema };
+//# sourceMappingURL=schema.js.map

package/dist/node_modules/@aa-sdk/core/dist/esm/utils/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sources":["../../../../../../../../../node_modules/@aa-sdk/core/dist/esm/utils/schema.js"],"sourcesContent":["import { isHex } from \"viem\";\nimport { z } from \"zod\";\nexport const ChainSchema = z.custom((chain) => chain != null &&\n    typeof chain === \"object\" &&\n    \"id\" in chain &&\n    typeof chain.id === \"number\");\nexport const HexSchema = z.custom((val) => {\n    return isHex(val, { strict: true });\n});\n// [!region BigNumberish]\nexport const BigNumberishSchema = z.union([HexSchema, z.number(), z.bigint()]);\n// [!endregion BigNumberish]\n// [!region BigNumberishRange]\nexport const BigNumberishRangeSchema = z\n    .object({\n    min: BigNumberishSchema.optional(),\n    max: BigNumberishSchema.optional(),\n})\n    .strict();\n// [!endregion BigNumberishRange]\n// [!region Multiplier]\nexport const MultiplierSchema = z\n    .object({\n    /**\n     * Multiplier value with max precision of 4 decimal places\n     */\n    multiplier: z.number().refine((n) => {\n        return (n.toString().split(\".\")[1]?.length ?? 0) <= 4;\n    }, { message: \"Max precision is 4 decimal places\" }),\n})\n    .strict();\n// [!endregion Multiplier]\nexport function isBigNumberish(x) {\n    return x != null && BigNumberishSchema.safeParse(x).success;\n}\nexport function isMultiplier(x) {\n    return x != null && MultiplierSchema.safeParse(x).success;\n}\n//# sourceMappingURL=schema.js.map"],"names":["z.custom","z.union","z.number","z.bigint","z\n    .object"],"mappings":";;;AAEY,MAAC,WAAW,GAAGA,MAAQ,CAAC,CAAC,KAAK,KAAK,KAAK,IAAI,IAAI;AAC5D,IAAI,OAAO,KAAK,KAAK,QAAQ;AAC7B,IAAI,IAAI,IAAI,KAAK;AACjB,IAAI,OAAO,KAAK,CAAC,EAAE,KAAK,QAAQ;AACpB,MAAC,SAAS,GAAGA,MAAQ,CAAC,CAAC,GAAG,KAAK;AAC3C,IAAI,OAAO,KAAK,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;AACvC,CAAC;AACD;AACY,MAAC,kBAAkB,GAAGC,SAAO,CAAC,CAAC,SAAS,EAAEC,UAAQ,EAAE,EAAEC,UAAQ,EAAE,CAAC;AAC7E;AACA;AACY,MAAC,uBAAuB,GAAGC,UAC5B,CAAC;AACZ,IAAI,GAAG,EAAE,kBAAkB,CAAC,QAAQ,EAAE;AACtC,IAAI,GAAG,EAAE,kBAAkB,CAAC,QAAQ,EAAE;AACtC,CAAC;AACD,KAAK,MAAM;AACX;AACA;AACY,MAAC,gBAAgB,GAAGA,UACrB,CAAC;AACZ;AACA;AACA;AACA,IAAI,UAAU,EAAEF,UAAQ,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK;AACzC,QAAQ,OAAO,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,IAAI,CAAC,KAAK,CAAC;AAC7D,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,mCAAmC,EAAE,CAAC;AACxD,CAAC;AACD,KAAK,MAAM;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@aa-sdk/core/dist/esm/utils/traceHeader.js

@@ -0,0 +1,22 @@
+function generateRandomHexString(numBytes) {
+    const hexPairs = new Array(numBytes).fill(0).map(() => Math.floor(Math.random() * 16)
+        .toString(16)
+        .padStart(2, "0"));
+    return hexPairs.join("");
+}
+/**
+ * These are the headers that are used in the trace headers, could be found in the spec
+ *
+ * @see https://www.w3.org/TR/trace-context/#design-overview
+ */
+const TRACE_HEADER_NAME = "traceparent";
+/**
+ * These are the headers that are used in the trace headers, could be found in the spec
+ *
+ * @see https://www.w3.org/TR/trace-context/#design-overview
+ */
+const TRACE_HEADER_STATE = "tracestate";
+generateRandomHexString(16);
+
+export { TRACE_HEADER_NAME, TRACE_HEADER_STATE };
+//# sourceMappingURL=traceHeader.js.map

package/dist/node_modules/@aa-sdk/core/dist/esm/utils/traceHeader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceHeader.js","sources":["../../../../../../../../../node_modules/@aa-sdk/core/dist/esm/utils/traceHeader.js"],"sourcesContent":["function generateRandomHexString(numBytes) {\n    const hexPairs = new Array(numBytes).fill(0).map(() => Math.floor(Math.random() * 16)\n        .toString(16)\n        .padStart(2, \"0\"));\n    return hexPairs.join(\"\");\n}\n/**\n * These are the headers that are used in the trace headers, could be found in the spec\n *\n * @see https://www.w3.org/TR/trace-context/#design-overview\n */\nexport const TRACE_HEADER_NAME = \"traceparent\";\n/**\n * These are the headers that are used in the trace headers, could be found in the spec\n *\n * @see https://www.w3.org/TR/trace-context/#design-overview\n */\nexport const TRACE_HEADER_STATE = \"tracestate\";\nconst clientTraceId = generateRandomHexString(16);\n/**\n * Some tools that are useful when dealing with the values\n * of the trace header. Follows the W3C trace context standard.\n *\n * @see https://www.w3.org/TR/trace-context/\n */\nexport class TraceHeader {\n    /**\n     * Initializes a new instance with the provided trace identifiers and state information.\n     *\n     * @param {string} traceId The unique identifier for the trace\n     * @param {string} parentId The identifier of the parent trace\n     * @param {string} traceFlags Flags containing trace-related options\n     * @param {TraceHeader[\"traceState\"]} traceState The trace state information for additional trace context\n     */\n    constructor(traceId, parentId, traceFlags, traceState) {\n        Object.defineProperty(this, \"traceId\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: void 0\n        });\n        Object.defineProperty(this, \"parentId\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: void 0\n        });\n        Object.defineProperty(this, \"traceFlags\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: void 0\n        });\n        Object.defineProperty(this, \"traceState\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: void 0\n        });\n        this.traceId = traceId;\n        this.parentId = parentId;\n        this.traceFlags = traceFlags;\n        this.traceState = traceState;\n    }\n    /**\n     * Creating a default trace id that is a random setup for both trace id and parent id\n     *\n     * @example ```ts\n     * const traceHeader = TraceHeader.fromTraceHeader(headers) || TraceHeader.default();\n     * ```\n     *\n     * @returns {TraceHeader} A default trace header\n     */\n    static default() {\n        return new TraceHeader(clientTraceId, generateRandomHexString(8), \"00\", //Means no flag have been set, and no sampled state https://www.w3.org/TR/trace-context/#trace-flags\n        {});\n    }\n    /**\n     * Should be able to consume a trace header from the headers of an http request\n     *\n     * @example ```ts\n     * const traceHeader = TraceHeader.fromTraceHeader(headers);\n     * ```\n     *\n     * @param {Record<string,string>} headers The headers from the http request\n     * @returns {TraceHeader | undefined} The trace header object, or nothing if not found\n     */\n    static fromTraceHeader(headers) {\n        if (!headers[TRACE_HEADER_NAME]) {\n            return undefined;\n        }\n        const [version, traceId, parentId, traceFlags] = headers[TRACE_HEADER_NAME]?.split(\"-\");\n        const traceState = headers[TRACE_HEADER_STATE]?.split(\",\").reduce((acc, curr) => {\n            const [key, value] = curr.split(\"=\");\n            acc[key] = value;\n            return acc;\n        }, {}) || {};\n        if (version !== \"00\") {\n            console.debug(new Error(`Invalid version for traceheader: ${headers[TRACE_HEADER_NAME]}`));\n            return undefined;\n        }\n        return new TraceHeader(traceId, parentId, traceFlags, traceState);\n    }\n    /**\n     * Should be able to convert the trace header to the format that is used in the headers of an http request\n     *\n     * @example ```ts\n     * const traceHeader = TraceHeader.fromTraceHeader(headers) || TraceHeader.default();\n     * const headers = traceHeader.toTraceHeader();\n     * ```\n     *\n     * @returns {{traceparent: string, tracestate: string}} The trace header in the format of a record, used in our http client\n     */\n    toTraceHeader() {\n        return {\n            [TRACE_HEADER_NAME]: `00-${this.traceId}-${this.parentId}-${this.traceFlags}`,\n            [TRACE_HEADER_STATE]: Object.entries(this.traceState)\n                .map(([key, value]) => `${key}=${value}`)\n                .join(\",\"),\n        };\n    }\n    /**\n     * Should be able to create a new trace header with a new event in the trace state,\n     *  as the key of the eventName as breadcrumbs appending onto previous breadcrumbs with the - infix if exists. And the\n     * trace parent gets updated as according to the docs\n     *\n     * @example ```ts\n     * const traceHeader = TraceHeader.fromTraceHeader(headers) || TraceHeader.default();\n     * const newTraceHeader = traceHeader.withEvent(\"newEvent\");\n     * ```\n     *\n     * @param {string} eventName The key of the new event\n     * @returns {TraceHeader} The new trace header\n     */\n    withEvent(eventName) {\n        const breadcrumbs = this.traceState.breadcrumbs\n            ? `${this.traceState.breadcrumbs}-${eventName}`\n            : eventName;\n        return new TraceHeader(this.traceId, this.parentId, this.traceFlags, {\n            ...this.traceState,\n            breadcrumbs,\n        });\n    }\n}\n//# sourceMappingURL=traceHeader.js.map"],"names":[],"mappings":"AAAA,SAAS,uBAAuB,CAAC,QAAQ,EAAE;AAC3C,IAAI,MAAM,QAAQ,GAAG,IAAI,KAAK,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE;AACxF,SAAS,QAAQ,CAAC,EAAE;AACpB,SAAS,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AAC1B,IAAI,OAAO,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;AAC5B;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,iBAAiB,GAAG;AACjC;AACA;AACA;AACA;AACA;AACY,MAAC,kBAAkB,GAAG;AACZ,uBAAuB,CAAC,EAAE;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@aa-sdk/core/dist/esm/version.js

@@ -0,0 +1,6 @@
+// This file is autogenerated by inject-version.ts. Any changes will be
+// overwritten on commit!
+const VERSION = "4.81.3";
+
+export { VERSION };
+//# sourceMappingURL=version.js.map

package/dist/node_modules/@aa-sdk/core/dist/esm/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sources":["../../../../../../../../node_modules/@aa-sdk/core/dist/esm/version.js"],"sourcesContent":["// This file is autogenerated by inject-version.ts. Any changes will be\n// overwritten on commit!\nexport const VERSION = \"4.81.3\";\n//# sourceMappingURL=version.js.map"],"names":[],"mappings":"AAAA;AACA;AACY,MAAC,OAAO,GAAG;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@account-kit/infra/dist/esm/alchemyTrackerHeaders.js

@@ -0,0 +1,36 @@
+import { TRACE_HEADER_NAME, TRACE_HEADER_STATE } from '../../../../@aa-sdk/core/dist/esm/utils/traceHeader.js';
+
+/**
+ * The header that is used to track the trace id.
+ * We use a client specific one to not mess with the span tracing of the servers.
+ *
+ * @see headersUpdate
+ */
+const TRACKER_HEADER = "X-Alchemy-Client-Trace-Id";
+/**
+ * The header that is used to track the breadcrumb.
+ *
+ * @see headersUpdate
+ */
+const TRACKER_BREADCRUMB = "X-Alchemy-Client-Breadcrumb";
+/**
+ * Remove the tracking headers. This is used in our split transport to ensure that we remove the headers that
+ * are not used by the other systems.
+ *
+ * @param {unknown} x The headers to remove the tracking headers from
+ */
+function mutateRemoveTrackingHeaders(x) {
+    if (!x)
+        return;
+    if (Array.isArray(x))
+        return;
+    if (typeof x !== "object")
+        return;
+    TRACKER_HEADER in x && delete x[TRACKER_HEADER];
+    TRACKER_BREADCRUMB in x && delete x[TRACKER_BREADCRUMB];
+    TRACE_HEADER_NAME in x && delete x[TRACE_HEADER_NAME];
+    TRACE_HEADER_STATE in x && delete x[TRACE_HEADER_STATE];
+}
+
+export { mutateRemoveTrackingHeaders };
+//# sourceMappingURL=alchemyTrackerHeaders.js.map

package/dist/node_modules/@account-kit/infra/dist/esm/alchemyTrackerHeaders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alchemyTrackerHeaders.js","sources":["../../../../../../../../node_modules/@account-kit/infra/dist/esm/alchemyTrackerHeaders.js"],"sourcesContent":["import { TRACE_HEADER_NAME } from \"@aa-sdk/core\";\nimport { TRACE_HEADER_STATE } from \"@aa-sdk/core\";\nimport { TraceHeader } from \"@aa-sdk/core\";\n/**\n * The header that is used to track the trace id.\n * We use a client specific one to not mess with the span tracing of the servers.\n *\n * @see headersUpdate\n */\nconst TRACKER_HEADER = \"X-Alchemy-Client-Trace-Id\";\n/**\n * The header that is used to track the breadcrumb.\n *\n * @see headersUpdate\n */\nconst TRACKER_BREADCRUMB = \"X-Alchemy-Client-Breadcrumb\";\n/**\n * Remove the tracking headers. This is used in our split transport to ensure that we remove the headers that\n * are not used by the other systems.\n *\n * @param {unknown} x The headers to remove the tracking headers from\n */\nexport function mutateRemoveTrackingHeaders(x) {\n    if (!x)\n        return;\n    if (Array.isArray(x))\n        return;\n    if (typeof x !== \"object\")\n        return;\n    TRACKER_HEADER in x && delete x[TRACKER_HEADER];\n    TRACKER_BREADCRUMB in x && delete x[TRACKER_BREADCRUMB];\n    TRACE_HEADER_NAME in x && delete x[TRACE_HEADER_NAME];\n    TRACE_HEADER_STATE in x && delete x[TRACE_HEADER_STATE];\n}\nfunction addCrumb(previous, crumb) {\n    if (!previous)\n        return crumb;\n    return `${previous} > ${crumb}`;\n}\n/**\n * Update the headers with the trace header and breadcrumb.\n *\n * These trace headers are used in the imply ingestion pipeline to trace the request.\n * And the breadcrumb is used to get finer grain details in the trace.\n *\n * Then there are the trace headers that are part of the W3C trace context standard.\n *\n * @param {string} crumb The crumb to add to the breadcrumb\n * @returns {Function} A function that updates the headers\n */\nexport function headersUpdate(crumb) {\n    const headerUpdate_ = (x) => {\n        const traceHeader = (TraceHeader.fromTraceHeader(x) || TraceHeader.default()).withEvent(crumb);\n        return {\n            [TRACKER_HEADER]: traceHeader.parentId,\n            ...x,\n            [TRACKER_BREADCRUMB]: addCrumb(x[TRACKER_BREADCRUMB], crumb),\n            ...traceHeader.toTraceHeader(),\n        };\n    };\n    return headerUpdate_;\n}\n//# sourceMappingURL=alchemyTrackerHeaders.js.map"],"names":[],"mappings":";;AAGA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,cAAc,GAAG,2BAA2B;AAClD;AACA;AACA;AACA;AACA;AACA,MAAM,kBAAkB,GAAG,6BAA6B;AACxD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,2BAA2B,CAAC,CAAC,EAAE;AAC/C,IAAI,IAAI,CAAC,CAAC;AACV,QAAQ;AACR,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;AACxB,QAAQ;AACR,IAAI,IAAI,OAAO,CAAC,KAAK,QAAQ;AAC7B,QAAQ;AACR,IAAI,cAAc,IAAI,CAAC,IAAI,OAAO,CAAC,CAAC,cAAc,CAAC;AACnD,IAAI,kBAAkB,IAAI,CAAC,IAAI,OAAO,CAAC,CAAC,kBAAkB,CAAC;AAC3D,IAAI,iBAAiB,IAAI,CAAC,IAAI,OAAO,CAAC,CAAC,iBAAiB,CAAC;AACzD,IAAI,kBAAkB,IAAI,CAAC,IAAI,OAAO,CAAC,CAAC,kBAAkB,CAAC;AAC3D;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@account-kit/infra/dist/esm/alchemyTransport.js

@@ -0,0 +1,190 @@
+import { http, createTransport } from 'viem';
+import { mutateRemoveTrackingHeaders } from './alchemyTrackerHeaders.js';
+import { AlchemyChainSchema } from './schema.js';
+import { VERSION } from './version.js';
+import { ConnectionConfigSchema } from '../../../../@aa-sdk/core/dist/esm/client/schema.js';
+import { ChainNotFoundError } from '../../../../@aa-sdk/core/dist/esm/errors/client.js';
+import { split } from '../../../../@aa-sdk/core/dist/esm/transport/split.js';
+
+const alchemyMethods = [
+    "eth_sendUserOperation",
+    "eth_estimateUserOperationGas",
+    "eth_getUserOperationReceipt",
+    "eth_getUserOperationByHash",
+    "eth_supportedEntryPoints",
+    "rundler_maxPriorityFeePerGas",
+    "pm_getPaymasterData",
+    "pm_getPaymasterStubData",
+    "alchemy_requestGasAndPaymasterAndData",
+];
+const chainAgnosticMethods = [
+    "wallet_prepareCalls",
+    "wallet_sendPreparedCalls",
+    "wallet_requestAccount",
+    "wallet_createAccount",
+    "wallet_listAccounts",
+    "wallet_createSession",
+    "wallet_getCallsStatus",
+    "wallet_requestQuote_v0",
+];
+/**
+ * Creates an Alchemy transport with the specified configuration options.
+ * When sending all traffic to Alchemy, you must pass in one of rpcUrl, apiKey, or jwt.
+ * If you want to send Bundler and Paymaster traffic to Alchemy and Node traffic to a different RPC, you must pass in alchemyConnection and nodeRpcUrl.
+ *
+ * @example
+ * ### Basic Example
+ * If the chain you're using is supported for both Bundler and Node RPCs, then you can do the following:
+ * ```ts
+ * import { alchemy } from "@account-kit/infra";
+ *
+ * const transport = alchemy({
+ *  // NOTE: you can also pass in an rpcUrl or jwt here or rpcUrl and jwt
+ *  apiKey: "your-api-key",
+ * });
+ * ```
+ *
+ * ### AA Only Chains
+ * For AA-only chains, you need to specify the alchemyConnection and nodeRpcUrl since Alchemy only
+ * handles the Bundler and Paymaster RPCs for these chains.
+ * ```ts
+ * import { alchemy } from "@account-kit/infra";
+ *
+ * const transport = alchemy({
+ *  alchemyConnection: {
+ *    apiKey: "your-api-key",
+ *  },
+ *  nodeRpcUrl: "https://zora.rpc.url",
+ * });
+ * ```
+ *
+ * @param {AlchemyTransportConfig} config The configuration object for the Alchemy transport.
+ * @param {number} config.retryDelay Optional The delay between retries, in milliseconds.
+ * @param {number} config.retryCount Optional The number of retry attempts.
+ * @param {string} [config.alchemyConnection] Optional Alchemy connection configuration (if this is passed in, nodeRpcUrl is required).
+ * @param {string} [config.fetchOptions] Optional fetch options for HTTP requests.
+ * @param {string} [config.nodeRpcUrl] Optional RPC URL for node (if this is passed in, alchemyConnection is required).
+ * @param {string} [config.rpcUrl] Optional RPC URL.
+ * @param {string} [config.apiKey] Optional API key for Alchemy.
+ * @param {string} [config.jwt] Optional JSON Web Token for authorization.
+ * @returns {AlchemyTransport} The configured Alchemy transport object.
+ */
+function alchemy(config) {
+    const { retryDelay, retryCount = 0 } = config;
+    // we create a copy here in case we create a split transport down below
+    // we don't want to add alchemy headers to 3rd party nodes
+    const fetchOptions = { ...config.fetchOptions };
+    const connectionConfig = ConnectionConfigSchema.parse(config.alchemyConnection ?? config);
+    const headersAsObject = convertHeadersToObject(fetchOptions.headers);
+    // TODO: we probably should just log these headers during telemetry logging instead of doing this mutable header stuff
+    fetchOptions.headers = {
+        ...headersAsObject,
+        "Alchemy-AA-Sdk-Version": VERSION,
+    };
+    if (connectionConfig.jwt != null || connectionConfig.apiKey != null) {
+        fetchOptions.headers = {
+            ...fetchOptions.headers,
+            Authorization: `Bearer ${connectionConfig.jwt ?? connectionConfig.apiKey}`,
+        };
+    }
+    const transport = (opts) => {
+        const { chain: chain_ } = opts;
+        if (!chain_) {
+            throw new ChainNotFoundError();
+        }
+        const chain = AlchemyChainSchema.parse(chain_);
+        const rpcUrl = connectionConfig.rpcUrl == null
+            ? chain.rpcUrls.alchemy.http[0]
+            : connectionConfig.rpcUrl;
+        const chainAgnosticRpcUrl = connectionConfig.rpcUrl == null
+            ? "https://api.g.alchemy.com/v2"
+            : (connectionConfig.chainAgnosticUrl ?? connectionConfig.rpcUrl);
+        const innerTransport = (() => {
+            mutateRemoveTrackingHeaders(config?.fetchOptions?.headers);
+            if (config.alchemyConnection && config.nodeRpcUrl) {
+                return split({
+                    overrides: [
+                        {
+                            methods: alchemyMethods,
+                            transport: http(rpcUrl, { fetchOptions, retryCount }),
+                        },
+                        {
+                            methods: chainAgnosticMethods,
+                            transport: http(chainAgnosticRpcUrl, {
+                                fetchOptions,
+                                retryCount,
+                                retryDelay,
+                            }),
+                        },
+                    ],
+                    fallback: http(config.nodeRpcUrl, {
+                        fetchOptions: config.fetchOptions,
+                        retryCount,
+                        retryDelay,
+                    }),
+                });
+            }
+            return split({
+                overrides: [
+                    {
+                        methods: chainAgnosticMethods,
+                        transport: http(chainAgnosticRpcUrl, {
+                            fetchOptions,
+                            retryCount,
+                            retryDelay,
+                        }),
+                    },
+                ],
+                fallback: http(rpcUrl, { fetchOptions, retryCount, retryDelay }),
+            });
+        })();
+        return createTransport({
+            key: "alchemy",
+            name: "Alchemy Transport",
+            request: innerTransport({
+                ...opts,
+                // Retries are already handled above within the split transport,
+                // so `retryCount` must be 0 here for the expected behavior.
+                retryCount: 0,
+            }).request,
+            // Retries are already handled above within the split transport,
+            // so `retryCount` must be 0 here too for the expected behavior.
+            retryCount: 0,
+            retryDelay,
+            type: "alchemy",
+        }, { alchemyRpcUrl: rpcUrl, fetchOptions });
+    };
+    return Object.assign(transport, {
+        dynamicFetchOptions: fetchOptions,
+        updateHeaders(newHeaders_) {
+            const newHeaders = convertHeadersToObject(newHeaders_);
+            fetchOptions.headers = {
+                ...fetchOptions.headers,
+                ...newHeaders,
+            };
+        },
+        config,
+    });
+}
+const convertHeadersToObject = (headers) => {
+    if (!headers) {
+        return {};
+    }
+    if (headers instanceof Headers) {
+        const headersObject = {};
+        headers.forEach((value, key) => {
+            headersObject[key] = value;
+        });
+        return headersObject;
+    }
+    if (Array.isArray(headers)) {
+        return headers.reduce((acc, header) => {
+            acc[header[0]] = header[1];
+            return acc;
+        }, {});
+    }
+    return headers;
+};
+
+export { alchemy, convertHeadersToObject };
+//# sourceMappingURL=alchemyTransport.js.map

package/dist/node_modules/@account-kit/infra/dist/esm/alchemyTransport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alchemyTransport.js","sources":["../../../../../../../../node_modules/@account-kit/infra/dist/esm/alchemyTransport.js"],"sourcesContent":["import { ChainNotFoundError, ConnectionConfigSchema, split, } from \"@aa-sdk/core\";\nimport { createTransport, http, } from \"viem\";\nimport { mutateRemoveTrackingHeaders } from \"./alchemyTrackerHeaders.js\";\nimport { AlchemyChainSchema } from \"./schema.js\";\nimport { VERSION } from \"./version.js\";\nconst alchemyMethods = [\n    \"eth_sendUserOperation\",\n    \"eth_estimateUserOperationGas\",\n    \"eth_getUserOperationReceipt\",\n    \"eth_getUserOperationByHash\",\n    \"eth_supportedEntryPoints\",\n    \"rundler_maxPriorityFeePerGas\",\n    \"pm_getPaymasterData\",\n    \"pm_getPaymasterStubData\",\n    \"alchemy_requestGasAndPaymasterAndData\",\n];\nconst chainAgnosticMethods = [\n    \"wallet_prepareCalls\",\n    \"wallet_sendPreparedCalls\",\n    \"wallet_requestAccount\",\n    \"wallet_createAccount\",\n    \"wallet_listAccounts\",\n    \"wallet_createSession\",\n    \"wallet_getCallsStatus\",\n    \"wallet_requestQuote_v0\",\n];\n/**\n * A type guard for the transport to determine if it is an Alchemy transport.\n * Used in cases where we would like to do switching depending on the transport, where there used\n * to be two clients for an alchemy and a non-alchemy, and with this switch we don't need the two seperate clients. *\n *\n * @param {Transport} transport The transport to check\n * @param {Chain} chain Chain for the transport to run its function to return the transport config\n * @returns {boolean} `true` if the transport is an Alchemy transport, otherwise `false`\n */\nexport function isAlchemyTransport(transport, chain) {\n    return transport({ chain }).config.type === \"alchemy\";\n}\n/**\n * Creates an Alchemy transport with the specified configuration options.\n * When sending all traffic to Alchemy, you must pass in one of rpcUrl, apiKey, or jwt.\n * If you want to send Bundler and Paymaster traffic to Alchemy and Node traffic to a different RPC, you must pass in alchemyConnection and nodeRpcUrl.\n *\n * @example\n * ### Basic Example\n * If the chain you're using is supported for both Bundler and Node RPCs, then you can do the following:\n * ```ts\n * import { alchemy } from \"@account-kit/infra\";\n *\n * const transport = alchemy({\n *  // NOTE: you can also pass in an rpcUrl or jwt here or rpcUrl and jwt\n *  apiKey: \"your-api-key\",\n * });\n * ```\n *\n * ### AA Only Chains\n * For AA-only chains, you need to specify the alchemyConnection and nodeRpcUrl since Alchemy only\n * handles the Bundler and Paymaster RPCs for these chains.\n * ```ts\n * import { alchemy } from \"@account-kit/infra\";\n *\n * const transport = alchemy({\n *  alchemyConnection: {\n *    apiKey: \"your-api-key\",\n *  },\n *  nodeRpcUrl: \"https://zora.rpc.url\",\n * });\n * ```\n *\n * @param {AlchemyTransportConfig} config The configuration object for the Alchemy transport.\n * @param {number} config.retryDelay Optional The delay between retries, in milliseconds.\n * @param {number} config.retryCount Optional The number of retry attempts.\n * @param {string} [config.alchemyConnection] Optional Alchemy connection configuration (if this is passed in, nodeRpcUrl is required).\n * @param {string} [config.fetchOptions] Optional fetch options for HTTP requests.\n * @param {string} [config.nodeRpcUrl] Optional RPC URL for node (if this is passed in, alchemyConnection is required).\n * @param {string} [config.rpcUrl] Optional RPC URL.\n * @param {string} [config.apiKey] Optional API key for Alchemy.\n * @param {string} [config.jwt] Optional JSON Web Token for authorization.\n * @returns {AlchemyTransport} The configured Alchemy transport object.\n */\nexport function alchemy(config) {\n    const { retryDelay, retryCount = 0 } = config;\n    // we create a copy here in case we create a split transport down below\n    // we don't want to add alchemy headers to 3rd party nodes\n    const fetchOptions = { ...config.fetchOptions };\n    const connectionConfig = ConnectionConfigSchema.parse(config.alchemyConnection ?? config);\n    const headersAsObject = convertHeadersToObject(fetchOptions.headers);\n    // TODO: we probably should just log these headers during telemetry logging instead of doing this mutable header stuff\n    fetchOptions.headers = {\n        ...headersAsObject,\n        \"Alchemy-AA-Sdk-Version\": VERSION,\n    };\n    if (connectionConfig.jwt != null || connectionConfig.apiKey != null) {\n        fetchOptions.headers = {\n            ...fetchOptions.headers,\n            Authorization: `Bearer ${connectionConfig.jwt ?? connectionConfig.apiKey}`,\n        };\n    }\n    const transport = (opts) => {\n        const { chain: chain_ } = opts;\n        if (!chain_) {\n            throw new ChainNotFoundError();\n        }\n        const chain = AlchemyChainSchema.parse(chain_);\n        const rpcUrl = connectionConfig.rpcUrl == null\n            ? chain.rpcUrls.alchemy.http[0]\n            : connectionConfig.rpcUrl;\n        const chainAgnosticRpcUrl = connectionConfig.rpcUrl == null\n            ? \"https://api.g.alchemy.com/v2\"\n            : (connectionConfig.chainAgnosticUrl ?? connectionConfig.rpcUrl);\n        const innerTransport = (() => {\n            mutateRemoveTrackingHeaders(config?.fetchOptions?.headers);\n            if (config.alchemyConnection && config.nodeRpcUrl) {\n                return split({\n                    overrides: [\n                        {\n                            methods: alchemyMethods,\n                            transport: http(rpcUrl, { fetchOptions, retryCount }),\n                        },\n                        {\n                            methods: chainAgnosticMethods,\n                            transport: http(chainAgnosticRpcUrl, {\n                                fetchOptions,\n                                retryCount,\n                                retryDelay,\n                            }),\n                        },\n                    ],\n                    fallback: http(config.nodeRpcUrl, {\n                        fetchOptions: config.fetchOptions,\n                        retryCount,\n                        retryDelay,\n                    }),\n                });\n            }\n            return split({\n                overrides: [\n                    {\n                        methods: chainAgnosticMethods,\n                        transport: http(chainAgnosticRpcUrl, {\n                            fetchOptions,\n                            retryCount,\n                            retryDelay,\n                        }),\n                    },\n                ],\n                fallback: http(rpcUrl, { fetchOptions, retryCount, retryDelay }),\n            });\n        })();\n        return createTransport({\n            key: \"alchemy\",\n            name: \"Alchemy Transport\",\n            request: innerTransport({\n                ...opts,\n                // Retries are already handled above within the split transport,\n                // so `retryCount` must be 0 here for the expected behavior.\n                retryCount: 0,\n            }).request,\n            // Retries are already handled above within the split transport,\n            // so `retryCount` must be 0 here too for the expected behavior.\n            retryCount: 0,\n            retryDelay,\n            type: \"alchemy\",\n        }, { alchemyRpcUrl: rpcUrl, fetchOptions });\n    };\n    return Object.assign(transport, {\n        dynamicFetchOptions: fetchOptions,\n        updateHeaders(newHeaders_) {\n            const newHeaders = convertHeadersToObject(newHeaders_);\n            fetchOptions.headers = {\n                ...fetchOptions.headers,\n                ...newHeaders,\n            };\n        },\n        config,\n    });\n}\nexport const convertHeadersToObject = (headers) => {\n    if (!headers) {\n        return {};\n    }\n    if (headers instanceof Headers) {\n        const headersObject = {};\n        headers.forEach((value, key) => {\n            headersObject[key] = value;\n        });\n        return headersObject;\n    }\n    if (Array.isArray(headers)) {\n        return headers.reduce((acc, header) => {\n            acc[header[0]] = header[1];\n            return acc;\n        }, {});\n    }\n    return headers;\n};\n//# sourceMappingURL=alchemyTransport.js.map"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@account-kit/infra/dist/esm/schema.js

@@ -0,0 +1,10 @@
+import * as external from '../../../../zod/v3/external.js';
+import { ChainSchema } from '../../../../@aa-sdk/core/dist/esm/utils/schema.js';
+
+const AlchemyChainSchema = external.custom((chain) => {
+    const chain_ = ChainSchema.parse(chain);
+    return chain_.rpcUrls.alchemy != null;
+}, "chain must include an alchemy rpc url. See `defineAlchemyChain` or import a chain from `@account-kit/infra`.");
+
+export { AlchemyChainSchema };
+//# sourceMappingURL=schema.js.map

package/dist/node_modules/@account-kit/infra/dist/esm/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sources":["../../../../../../../../node_modules/@account-kit/infra/dist/esm/schema.js"],"sourcesContent":["import { ChainSchema } from \"@aa-sdk/core\";\nimport z from \"zod\";\nexport const AlchemyChainSchema = z.custom((chain) => {\n    const chain_ = ChainSchema.parse(chain);\n    return chain_.rpcUrls.alchemy != null;\n}, \"chain must include an alchemy rpc url. See `defineAlchemyChain` or import a chain from `@account-kit/infra`.\");\n//# sourceMappingURL=schema.js.map"],"names":["z"],"mappings":";;;AAEY,MAAC,kBAAkB,GAAGA,QAAC,CAAC,MAAM,CAAC,CAAC,KAAK,KAAK;AACtD,IAAI,MAAM,MAAM,GAAG,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC;AAC3C,IAAI,OAAO,MAAM,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI;AACzC,CAAC,EAAE,8GAA8G;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@account-kit/infra/dist/esm/version.js

@@ -0,0 +1,6 @@
+// This file is autogenerated by inject-version.ts. Any changes will be
+// overwritten on commit!
+const VERSION = "4.81.3";
+
+export { VERSION };
+//# sourceMappingURL=version.js.map

package/dist/node_modules/@account-kit/infra/dist/esm/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sources":["../../../../../../../../node_modules/@account-kit/infra/dist/esm/version.js"],"sourcesContent":["// This file is autogenerated by inject-version.ts. Any changes will be\n// overwritten on commit!\nexport const VERSION = \"4.81.3\";\n//# sourceMappingURL=version.js.map"],"names":[],"mappings":"AAAA;AACA;AACY,MAAC,OAAO,GAAG;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/zod/index.js

@@ -0,0 +1,6 @@
+import * as external from './v3/external.js';
+
+
+
+export { external as default, external as z };
+//# sourceMappingURL=index.js.map