@permissionless/wagmi 0.0.2 → 0.0.3

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @permissionless/wagmi
 
+## 0.0.3
+
+### Patch Changes
+
+- 17ba362046c66642e908b7f8af0d0b4b4ef16de1: Added account-specific connectors
+- Updated dependencies [17ba362046c66642e908b7f8af0d0b4b4ef16de1]
+  - permissionless@0.0.35
+
 ## 0.0.1
 
 ### Patch Changes

package/_cjs/connectors/biconomySmartAccount.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.biconomySmartAccount = void 0;
+const accounts_1 = require("permissionless/accounts");
+const simpleSmartAccount_1 = require("./simpleSmartAccount.js");
+async function biconomySmartAccount({ publicClient, signer, bundlerTransport, sponsorUserOperation, ...rest }) {
+    return (0, simpleSmartAccount_1.smartAccountConnectorHelper)({
+        account: await (0, accounts_1.signerToBiconomySmartAccount)(publicClient, {
+            ...rest,
+            signer
+        }),
+        publicClient,
+        bundlerTransport,
+        sponsorUserOperation
+    });
+}
+exports.biconomySmartAccount = biconomySmartAccount;
+//# sourceMappingURL=biconomySmartAccount.js.map

package/_cjs/connectors/biconomySmartAccount.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"biconomySmartAccount.js","sourceRoot":"","sources":["../../connectors/biconomySmartAccount.ts"],"names":[],"mappings":";;;AAAA,sDAGgC;AAGhC,6DAG6B;AAoBtB,KAAK,UAAU,oBAAoB,CAKxC,EACE,YAAY,EACZ,MAAM,EACN,gBAAgB,EAChB,oBAAoB,EACpB,GAAG,IAAI,EAGV;IACG,OAAO,IAAA,gDAA2B,EAAC;QAC/B,OAAO,EAAE,MAAM,IAAA,uCAA4B,EAAC,YAAY,EAAE;YACtD,GAAG,IAAI;YACP,MAAM;SACT,CAAC;QACF,YAAY;QACZ,gBAAgB;QAChB,oBAAoB;KACvB,CAAC,CAAA;AACN,CAAC;AAvBD,oDAuBC"}

package/_cjs/connectors/kernelSmartAccount.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kernelSmartAccount = void 0;
+const accounts_1 = require("permissionless/accounts");
+const simpleSmartAccount_1 = require("./simpleSmartAccount.js");
+async function kernelSmartAccount({ publicClient, signer, bundlerTransport, sponsorUserOperation, ...rest }) {
+    return (0, simpleSmartAccount_1.smartAccountConnectorHelper)({
+        account: await (0, accounts_1.signerToEcdsaKernelSmartAccount)(publicClient, {
+            ...rest,
+            signer
+        }),
+        publicClient,
+        bundlerTransport,
+        sponsorUserOperation
+    });
+}
+exports.kernelSmartAccount = kernelSmartAccount;
+//# sourceMappingURL=kernelSmartAccount.js.map

package/_cjs/connectors/kernelSmartAccount.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernelSmartAccount.js","sourceRoot":"","sources":["../../connectors/kernelSmartAccount.ts"],"names":[],"mappings":";;;AAAA,sDAGgC;AAGhC,6DAG6B;AAoBtB,KAAK,UAAU,kBAAkB,CAKtC,EACE,YAAY,EACZ,MAAM,EACN,gBAAgB,EAChB,oBAAoB,EACpB,GAAG,IAAI,EAGV;IACG,OAAO,IAAA,gDAA2B,EAAC;QAC/B,OAAO,EAAE,MAAM,IAAA,0CAA+B,EAAC,YAAY,EAAE;YACzD,GAAG,IAAI;YACP,MAAM;SACT,CAAC;QACF,YAAY;QACZ,gBAAgB;QAChB,oBAAoB;KACvB,CAAC,CAAA;AACN,CAAC;AAvBD,gDAuBC"}

package/_cjs/connectors/safeSmartAccount.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeSmartAccount = void 0;
+const accounts_1 = require("permissionless/accounts");
+const simpleSmartAccount_1 = require("./simpleSmartAccount.js");
+async function safeSmartAccount({ publicClient, signer, bundlerTransport, sponsorUserOperation, ...rest }) {
+    return (0, simpleSmartAccount_1.smartAccountConnectorHelper)({
+        account: await (0, accounts_1.signerToSafeSmartAccount)(publicClient, {
+            ...rest,
+            signer
+        }),
+        publicClient,
+        bundlerTransport,
+        sponsorUserOperation
+    });
+}
+exports.safeSmartAccount = safeSmartAccount;
+//# sourceMappingURL=safeSmartAccount.js.map

package/_cjs/connectors/safeSmartAccount.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeSmartAccount.js","sourceRoot":"","sources":["../../connectors/safeSmartAccount.ts"],"names":[],"mappings":";;;AAAA,sDAGgC;AAGhC,6DAG6B;AAiBtB,KAAK,UAAU,gBAAgB,CAKpC,EACE,YAAY,EACZ,MAAM,EACN,gBAAgB,EAChB,oBAAoB,EACpB,GAAG,IAAI,EAGV;IACG,OAAO,IAAA,gDAA2B,EAAC;QAC/B,OAAO,EAAE,MAAM,IAAA,mCAAwB,EAAC,YAAY,EAAE;YAClD,GAAG,IAAI;YACP,MAAM;SACT,CAAC;QACF,YAAY;QACZ,gBAAgB;QAChB,oBAAoB;KACvB,CAAC,CAAA;AACN,CAAC;AAvBD,4CAuBC"}

package/_cjs/connectors/simpleSmartAccount.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simpleSmartAccount = exports.smartAccountConnectorHelper = void 0;
+const permissionless_1 = require("permissionless");
+const accounts_1 = require("permissionless/accounts");
+const smartAccount_1 = require("./smartAccount.js");
+async function smartAccountConnectorHelper({ bundlerTransport, sponsorUserOperation, account }) {
+    const smartAccountClient = (0, permissionless_1.createSmartAccountClient)({
+        account,
+        transport: bundlerTransport,
+        sponsorUserOperation: sponsorUserOperation
+    });
+    return (0, smartAccount_1.smartAccount)({
+        smartAccountClient: smartAccountClient
+    });
+}
+exports.smartAccountConnectorHelper = smartAccountConnectorHelper;
+async function simpleSmartAccount({ publicClient, signer, bundlerTransport, sponsorUserOperation, ...rest }) {
+    return smartAccountConnectorHelper({
+        account: await (0, accounts_1.signerToSimpleSmartAccount)(publicClient, {
+            ...rest,
+            signer
+        }),
+        publicClient,
+        bundlerTransport,
+        sponsorUserOperation
+    });
+}
+exports.simpleSmartAccount = simpleSmartAccount;
+//# sourceMappingURL=simpleSmartAccount.js.map

package/_cjs/connectors/simpleSmartAccount.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simpleSmartAccount.js","sourceRoot":"","sources":["../../connectors/simpleSmartAccount.ts"],"names":[],"mappings":";;;AAAA,mDAAyD;AACzD,sDAKgC;AAIhC,iDAA6C;AA8BtC,KAAK,UAAU,2BAA2B,CAO/C,EACE,gBAAgB,EAChB,oBAAoB,EACpB,OAAO,EAMV;IACG,MAAM,kBAAkB,GAAG,IAAA,yCAAwB,EAAC;QAChD,OAAO;QACP,SAAS,EAAE,gBAAgB;QAC3B,oBAAoB,EAAE,oBAAoB;KAC7C,CAAC,CAAA;IAEF,OAAO,IAAA,2BAAY,EAAC;QAChB,kBAAkB,EAAE,kBAAkB;KACzC,CAAC,CAAA;AACN,CAAC;AA1BD,kEA0BC;AAEM,KAAK,UAAU,kBAAkB,CAKtC,EACE,YAAY,EACZ,MAAM,EACN,gBAAgB,EAChB,oBAAoB,EACpB,GAAG,IAAI,EAC2D;IAClE,OAAO,2BAA2B,CAAC;QAC/B,OAAO,EAAE,MAAM,IAAA,qCAA0B,EAAC,YAAY,EAAE;YACpD,GAAG,IAAI;YACP,MAAM;SACT,CAAC;QACF,YAAY;QACZ,gBAAgB;QAChB,oBAAoB;KACvB,CAAC,CAAA;AACN,CAAC;AArBD,gDAqBC"}

package/_cjs/index.js

@@ -1,6 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.smartAccount = void 0;
+exports.kernelSmartAccount = exports.biconomySmartAccount = exports.safeSmartAccount = exports.simpleSmartAccount = exports.smartAccount = void 0;
+const simpleSmartAccount_1 = require("./connectors/simpleSmartAccount.js");
+Object.defineProperty(exports, "simpleSmartAccount", { enumerable: true, get: function () { return simpleSmartAccount_1.simpleSmartAccount; } });
 const smartAccount_1 = require("./connectors/smartAccount.js");
 Object.defineProperty(exports, "smartAccount", { enumerable: true, get: function () { return smartAccount_1.smartAccount; } });
+const safeSmartAccount_1 = require("./connectors/safeSmartAccount.js");
+Object.defineProperty(exports, "safeSmartAccount", { enumerable: true, get: function () { return safeSmartAccount_1.safeSmartAccount; } });
+const biconomySmartAccount_1 = require("./connectors/biconomySmartAccount.js");
+Object.defineProperty(exports, "biconomySmartAccount", { enumerable: true, get: function () { return biconomySmartAccount_1.biconomySmartAccount; } });
+const kernelSmartAccount_1 = require("./connectors/kernelSmartAccount.js");
+Object.defineProperty(exports, "kernelSmartAccount", { enumerable: true, get: function () { return kernelSmartAccount_1.kernelSmartAccount; } });
 //# sourceMappingURL=index.js.map

package/_cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":";;;AAAA,4DAAwD;AAE/C,6FAFA,2BAAY,OAEA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":";;;AAAA,wEAGwC;AAoBpC,mGArBA,uCAAkB,OAqBA;AAnBtB,4DAAwD;AAkBpD,6FAlBK,2BAAY,OAkBL;AAhBhB,oEAGsC;AAgBlC,iGAjBA,mCAAgB,OAiBA;AAdpB,4EAG0C;AAatC,qGAdA,2CAAoB,OAcA;AAXxB,wEAGwC;AAUpC,mGAXA,uCAAkB,OAWA"}

package/_esm/connectors/biconomySmartAccount.js

@@ -0,0 +1,14 @@
+import { signerToBiconomySmartAccount } from "permissionless/accounts";
+import { smartAccountConnectorHelper } from "./simpleSmartAccount.js";
+export async function biconomySmartAccount({ publicClient, signer, bundlerTransport, sponsorUserOperation, ...rest }) {
+    return smartAccountConnectorHelper({
+        account: await signerToBiconomySmartAccount(publicClient, {
+            ...rest,
+            signer
+        }),
+        publicClient,
+        bundlerTransport,
+        sponsorUserOperation
+    });
+}
+//# sourceMappingURL=biconomySmartAccount.js.map

package/_esm/connectors/biconomySmartAccount.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"biconomySmartAccount.js","sourceRoot":"","sources":["../../connectors/biconomySmartAccount.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,4BAA4B,EAC/B,MAAM,yBAAyB,CAAA;AAGhC,OAAO,EAEH,2BAA2B,EAC9B,MAAM,sBAAsB,CAAA;AAoB7B,MAAM,CAAC,KAAK,UAAU,oBAAoB,CAKxC,EACE,YAAY,EACZ,MAAM,EACN,gBAAgB,EAChB,oBAAoB,EACpB,GAAG,IAAI,EAGV;IACG,OAAO,2BAA2B,CAAC;QAC/B,OAAO,EAAE,MAAM,4BAA4B,CAAC,YAAY,EAAE;YACtD,GAAG,IAAI;YACP,MAAM;SACT,CAAC;QACF,YAAY;QACZ,gBAAgB;QAChB,oBAAoB;KACvB,CAAC,CAAA;AACN,CAAC"}

package/_esm/connectors/kernelSmartAccount.js

@@ -0,0 +1,14 @@
+import { signerToEcdsaKernelSmartAccount } from "permissionless/accounts";
+import { smartAccountConnectorHelper } from "./simpleSmartAccount.js";
+export async function kernelSmartAccount({ publicClient, signer, bundlerTransport, sponsorUserOperation, ...rest }) {
+    return smartAccountConnectorHelper({
+        account: await signerToEcdsaKernelSmartAccount(publicClient, {
+            ...rest,
+            signer
+        }),
+        publicClient,
+        bundlerTransport,
+        sponsorUserOperation
+    });
+}
+//# sourceMappingURL=kernelSmartAccount.js.map

package/_esm/connectors/kernelSmartAccount.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernelSmartAccount.js","sourceRoot":"","sources":["../../connectors/kernelSmartAccount.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,+BAA+B,EAClC,MAAM,yBAAyB,CAAA;AAGhC,OAAO,EAEH,2BAA2B,EAC9B,MAAM,sBAAsB,CAAA;AAoB7B,MAAM,CAAC,KAAK,UAAU,kBAAkB,CAKtC,EACE,YAAY,EACZ,MAAM,EACN,gBAAgB,EAChB,oBAAoB,EACpB,GAAG,IAAI,EAGV;IACG,OAAO,2BAA2B,CAAC;QAC/B,OAAO,EAAE,MAAM,+BAA+B,CAAC,YAAY,EAAE;YACzD,GAAG,IAAI;YACP,MAAM;SACT,CAAC;QACF,YAAY;QACZ,gBAAgB;QAChB,oBAAoB;KACvB,CAAC,CAAA;AACN,CAAC"}

package/_esm/connectors/safeSmartAccount.js

@@ -0,0 +1,14 @@
+import { signerToSafeSmartAccount } from "permissionless/accounts";
+import { smartAccountConnectorHelper } from "./simpleSmartAccount.js";
+export async function safeSmartAccount({ publicClient, signer, bundlerTransport, sponsorUserOperation, ...rest }) {
+    return smartAccountConnectorHelper({
+        account: await signerToSafeSmartAccount(publicClient, {
+            ...rest,
+            signer
+        }),
+        publicClient,
+        bundlerTransport,
+        sponsorUserOperation
+    });
+}
+//# sourceMappingURL=safeSmartAccount.js.map

package/_esm/connectors/safeSmartAccount.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeSmartAccount.js","sourceRoot":"","sources":["../../connectors/safeSmartAccount.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,wBAAwB,EAC3B,MAAM,yBAAyB,CAAA;AAGhC,OAAO,EAEH,2BAA2B,EAC9B,MAAM,sBAAsB,CAAA;AAiB7B,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAKpC,EACE,YAAY,EACZ,MAAM,EACN,gBAAgB,EAChB,oBAAoB,EACpB,GAAG,IAAI,EAGV;IACG,OAAO,2BAA2B,CAAC;QAC/B,OAAO,EAAE,MAAM,wBAAwB,CAAC,YAAY,EAAE;YAClD,GAAG,IAAI;YACP,MAAM;SACT,CAAC;QACF,YAAY;QACZ,gBAAgB;QAChB,oBAAoB;KACvB,CAAC,CAAA;AACN,CAAC"}

package/_esm/connectors/simpleSmartAccount.js

@@ -0,0 +1,26 @@
+import { createSmartAccountClient } from "permissionless";
+import { signerToSimpleSmartAccount } from "permissionless/accounts";
+import {} from "permissionless/actions/smartAccount";
+import { smartAccount } from "./smartAccount.js";
+export async function smartAccountConnectorHelper({ bundlerTransport, sponsorUserOperation, account }) {
+    const smartAccountClient = createSmartAccountClient({
+        account,
+        transport: bundlerTransport,
+        sponsorUserOperation: sponsorUserOperation
+    });
+    return smartAccount({
+        smartAccountClient: smartAccountClient
+    });
+}
+export async function simpleSmartAccount({ publicClient, signer, bundlerTransport, sponsorUserOperation, ...rest }) {
+    return smartAccountConnectorHelper({
+        account: await signerToSimpleSmartAccount(publicClient, {
+            ...rest,
+            signer
+        }),
+        publicClient,
+        bundlerTransport,
+        sponsorUserOperation
+    });
+}
+//# sourceMappingURL=simpleSmartAccount.js.map

package/_esm/connectors/simpleSmartAccount.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simpleSmartAccount.js","sourceRoot":"","sources":["../../connectors/simpleSmartAccount.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAA;AACzD,OAAO,EAIH,0BAA0B,EAC7B,MAAM,yBAAyB,CAAA;AAChC,OAAO,EAAuC,MAAM,qCAAqC,CAAA;AAGzF,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AA8B7C,MAAM,CAAC,KAAK,UAAU,2BAA2B,CAO/C,EACE,gBAAgB,EAChB,oBAAoB,EACpB,OAAO,EAMV;IACG,MAAM,kBAAkB,GAAG,wBAAwB,CAAC;QAChD,OAAO;QACP,SAAS,EAAE,gBAAgB;QAC3B,oBAAoB,EAAE,oBAAoB;KAC7C,CAAC,CAAA;IAEF,OAAO,YAAY,CAAC;QAChB,kBAAkB,EAAE,kBAAkB;KACzC,CAAC,CAAA;AACN,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,kBAAkB,CAKtC,EACE,YAAY,EACZ,MAAM,EACN,gBAAgB,EAChB,oBAAoB,EACpB,GAAG,IAAI,EAC2D;IAClE,OAAO,2BAA2B,CAAC;QAC/B,OAAO,EAAE,MAAM,0BAA0B,CAAC,YAAY,EAAE;YACpD,GAAG,IAAI;YACP,MAAM;SACT,CAAC;QACF,YAAY;QACZ,gBAAgB;QAChB,oBAAoB;KACvB,CAAC,CAAA;AACN,CAAC"}

package/_esm/index.js

@@ -1,3 +1,7 @@
+import { simpleSmartAccount } from "./connectors/simpleSmartAccount.js";
 import { smartAccount } from "./connectors/smartAccount.js";
-export { smartAccount };
+import { safeSmartAccount } from "./connectors/safeSmartAccount.js";
+import { biconomySmartAccount } from "./connectors/biconomySmartAccount.js";
+import { kernelSmartAccount } from "./connectors/kernelSmartAccount.js";
+export { smartAccount, simpleSmartAccount, safeSmartAccount, biconomySmartAccount, kernelSmartAccount };
 //# sourceMappingURL=index.js.map

package/_esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAExD,OAAO,EAAE,YAAY,EAAE,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,kBAAkB,EACrB,MAAM,iCAAiC,CAAA;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAExD,OAAO,EAEH,gBAAgB,EACnB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAEH,oBAAoB,EACvB,MAAM,mCAAmC,CAAA;AAE1C,OAAO,EAEH,kBAAkB,EACrB,MAAM,iCAAiC,CAAA;AAExC,OAAO,EACH,YAAY,EACZ,kBAAkB,EAElB,gBAAgB,EAEhB,oBAAoB,EAEpB,kBAAkB,EAErB,CAAA"}

package/_types/connectors/biconomySmartAccount.d.ts

@@ -0,0 +1,317 @@
+import { type SignerToBiconomySmartAccountParameters } from "permissionless/accounts";
+import type { Prettify } from "permissionless/types";
+import type { Address, Chain, Transport } from "viem";
+import { type SmartAccountParameters } from "./simpleSmartAccount";
+export type BiconomySmartAccountParameters<TTransport extends Transport = Transport, TChain extends Chain | undefined = Chain | undefined, TSource extends string = "custom", TAddress extends Address = Address> = Prettify<SmartAccountParameters<Omit<SignerToBiconomySmartAccountParameters<TSource, TAddress>, "signer">, TTransport, TChain, TSource, TAddress>>;
+export declare function biconomySmartAccount<TTransport extends Transport = Transport, TChain extends Chain | undefined = Chain | undefined, TSource extends string = "custom", TAddress extends Address = Address>({ publicClient, signer, bundlerTransport, sponsorUserOperation, ...rest }: Prettify<BiconomySmartAccountParameters<TTransport, TChain, TSource, TAddress>>): Promise<import("wagmi").CreateConnectorFn<unknown, {
+    id: string;
+    name: string;
+    type: string;
+    connect: ({ chainId }?: {
+        chainId?: number | undefined;
+        isReconnecting?: boolean | undefined;
+    } | undefined) => Promise<{
+        accounts: `0x${string}`[];
+        chainId: number;
+    }>;
+    disconnect: () => Promise<void>;
+    getAccounts: () => Promise<`0x${string}`[]>;
+    getChainId: () => Promise<number>;
+    getProvider: () => Promise<void>;
+    isAuthorized: () => Promise<true>;
+    onAccountsChanged: () => void;
+    onChainChanged: () => void;
+    onDisconnect: () => void;
+    getClient: ({ chainId: requestedChainId }: {
+        chainId: number;
+    }) => Promise<{
+        account: import("permissionless/accounts").SmartAccount<"biconomySmartAccount", TTransport, TChain>;
+        batch?: {
+            multicall?: boolean | {
+                batchSize?: number | undefined;
+                wait?: number | undefined;
+            } | undefined;
+        } | undefined;
+        cacheTime: number;
+        chain: undefined;
+        key: string;
+        name: string;
+        pollingInterval: number;
+        request: import("viem").EIP1193RequestFn<import("permissionless/_types/types/bundler").BundlerRpcSchema>;
+        transport: ReturnType<TTransport>["config"] & ReturnType<TTransport>["value"];
+        type: string;
+        uid: string;
+        sendTransaction: <TChainOverride extends Chain | undefined>(args: import("viem").SendTransactionParameters<undefined, import("permissionless/accounts").SmartAccount<"biconomySmartAccount", TTransport, TChain>, TChainOverride>) => Promise<`0x${string}`>;
+        signMessage: (args: import("viem").SignMessageParameters<import("permissionless/accounts").SmartAccount<"biconomySmartAccount", TTransport, TChain>>) => Promise<`0x${string}`>;
+        signTypedData: <const TTypedData extends {
+            [x: string]: readonly import("viem").TypedDataParameter[];
+            [x: `string[${string}]`]: undefined;
+            [x: `function[${string}]`]: undefined;
+            [x: `address[${string}]`]: undefined;
+            [x: `bool[${string}]`]: undefined;
+            [x: `bytes[${string}]`]: undefined;
+            [x: `bytes1[${string}]`]: undefined;
+            [x: `bytes16[${string}]`]: undefined;
+            [x: `bytes2[${string}]`]: undefined;
+            [x: `bytes3[${string}]`]: undefined;
+            [x: `bytes4[${string}]`]: undefined;
+            [x: `bytes5[${string}]`]: undefined;
+            [x: `bytes6[${string}]`]: undefined;
+            [x: `bytes7[${string}]`]: undefined;
+            [x: `bytes8[${string}]`]: undefined;
+            [x: `bytes9[${string}]`]: undefined;
+            [x: `bytes10[${string}]`]: undefined;
+            [x: `bytes11[${string}]`]: undefined;
+            [x: `bytes12[${string}]`]: undefined;
+            [x: `bytes13[${string}]`]: undefined;
+            [x: `bytes14[${string}]`]: undefined;
+            [x: `bytes15[${string}]`]: undefined;
+            [x: `bytes17[${string}]`]: undefined;
+            [x: `bytes18[${string}]`]: undefined;
+            [x: `bytes19[${string}]`]: undefined;
+            [x: `bytes20[${string}]`]: undefined;
+            [x: `bytes21[${string}]`]: undefined;
+            [x: `bytes22[${string}]`]: undefined;
+            [x: `bytes23[${string}]`]: undefined;
+            [x: `bytes24[${string}]`]: undefined;
+            [x: `bytes25[${string}]`]: undefined;
+            [x: `bytes26[${string}]`]: undefined;
+            [x: `bytes27[${string}]`]: undefined;
+            [x: `bytes28[${string}]`]: undefined;
+            [x: `bytes29[${string}]`]: undefined;
+            [x: `bytes30[${string}]`]: undefined;
+            [x: `bytes31[${string}]`]: undefined;
+            [x: `bytes32[${string}]`]: undefined;
+            [x: `int[${string}]`]: undefined;
+            [x: `int40[${string}]`]: undefined;
+            [x: `int16[${string}]`]: undefined;
+            [x: `int56[${string}]`]: undefined;
+            [x: `int8[${string}]`]: undefined;
+            [x: `int24[${string}]`]: undefined;
+            [x: `int32[${string}]`]: undefined;
+            [x: `int48[${string}]`]: undefined;
+            [x: `int64[${string}]`]: undefined;
+            [x: `int72[${string}]`]: undefined;
+            [x: `int80[${string}]`]: undefined;
+            [x: `int88[${string}]`]: undefined;
+            [x: `int96[${string}]`]: undefined;
+            [x: `int104[${string}]`]: undefined;
+            [x: `int112[${string}]`]: undefined;
+            [x: `int120[${string}]`]: undefined;
+            [x: `int128[${string}]`]: undefined;
+            [x: `int136[${string}]`]: undefined;
+            [x: `int144[${string}]`]: undefined;
+            [x: `int152[${string}]`]: undefined;
+            [x: `int160[${string}]`]: undefined;
+            [x: `int168[${string}]`]: undefined;
+            [x: `int176[${string}]`]: undefined;
+            [x: `int184[${string}]`]: undefined;
+            [x: `int192[${string}]`]: undefined;
+            [x: `int200[${string}]`]: undefined;
+            [x: `int208[${string}]`]: undefined;
+            [x: `int216[${string}]`]: undefined;
+            [x: `int224[${string}]`]: undefined;
+            [x: `int232[${string}]`]: undefined;
+            [x: `int240[${string}]`]: undefined;
+            [x: `int248[${string}]`]: undefined;
+            [x: `int256[${string}]`]: undefined;
+            [x: `uint[${string}]`]: undefined;
+            [x: `uint40[${string}]`]: undefined;
+            [x: `uint16[${string}]`]: undefined;
+            [x: `uint56[${string}]`]: undefined;
+            [x: `uint8[${string}]`]: undefined;
+            [x: `uint24[${string}]`]: undefined;
+            [x: `uint32[${string}]`]: undefined;
+            [x: `uint48[${string}]`]: undefined;
+            [x: `uint64[${string}]`]: undefined;
+            [x: `uint72[${string}]`]: undefined;
+            [x: `uint80[${string}]`]: undefined;
+            [x: `uint88[${string}]`]: undefined;
+            [x: `uint96[${string}]`]: undefined;
+            [x: `uint104[${string}]`]: undefined;
+            [x: `uint112[${string}]`]: undefined;
+            [x: `uint120[${string}]`]: undefined;
+            [x: `uint128[${string}]`]: undefined;
+            [x: `uint136[${string}]`]: undefined;
+            [x: `uint144[${string}]`]: undefined;
+            [x: `uint152[${string}]`]: undefined;
+            [x: `uint160[${string}]`]: undefined;
+            [x: `uint168[${string}]`]: undefined;
+            [x: `uint176[${string}]`]: undefined;
+            [x: `uint184[${string}]`]: undefined;
+            [x: `uint192[${string}]`]: undefined;
+            [x: `uint200[${string}]`]: undefined;
+            [x: `uint208[${string}]`]: undefined;
+            [x: `uint216[${string}]`]: undefined;
+            [x: `uint224[${string}]`]: undefined;
+            [x: `uint232[${string}]`]: undefined;
+            [x: `uint240[${string}]`]: undefined;
+            [x: `uint248[${string}]`]: undefined;
+            [x: `uint256[${string}]`]: undefined;
+            string?: undefined;
+            address?: undefined;
+            bool?: undefined;
+            bytes?: undefined;
+            bytes1?: undefined;
+            bytes16?: undefined;
+            bytes2?: undefined;
+            bytes3?: undefined;
+            bytes4?: undefined;
+            bytes5?: undefined;
+            bytes6?: undefined;
+            bytes7?: undefined;
+            bytes8?: undefined;
+            bytes9?: undefined;
+            bytes10?: undefined;
+            bytes11?: undefined;
+            bytes12?: undefined;
+            bytes13?: undefined;
+            bytes14?: undefined;
+            bytes15?: undefined;
+            bytes17?: undefined;
+            bytes18?: undefined;
+            bytes19?: undefined;
+            bytes20?: undefined;
+            bytes21?: undefined;
+            bytes22?: undefined;
+            bytes23?: undefined;
+            bytes24?: undefined;
+            bytes25?: undefined;
+            bytes26?: undefined;
+            bytes27?: undefined;
+            bytes28?: undefined;
+            bytes29?: undefined;
+            bytes30?: undefined;
+            bytes31?: undefined;
+            bytes32?: undefined;
+            int40?: undefined;
+            int16?: undefined;
+            int56?: undefined;
+            int8?: undefined;
+            int24?: undefined;
+            int32?: undefined;
+            int48?: undefined;
+            int64?: undefined;
+            int72?: undefined;
+            int80?: undefined;
+            int88?: undefined;
+            int96?: undefined;
+            int104?: undefined;
+            int112?: undefined;
+            int120?: undefined;
+            int128?: undefined;
+            int136?: undefined;
+            int144?: undefined;
+            int152?: undefined;
+            int160?: undefined;
+            int168?: undefined;
+            int176?: undefined;
+            int184?: undefined;
+            int192?: undefined;
+            int200?: undefined;
+            int208?: undefined;
+            int216?: undefined;
+            int224?: undefined;
+            int232?: undefined;
+            int240?: undefined;
+            int248?: undefined;
+            int256?: undefined;
+            uint40?: undefined;
+            uint16?: undefined;
+            uint56?: undefined;
+            uint8?: undefined;
+            uint24?: undefined;
+            uint32?: undefined;
+            uint48?: undefined;
+            uint64?: undefined;
+            uint72?: undefined;
+            uint80?: undefined;
+            uint88?: undefined;
+            uint96?: undefined;
+            uint104?: undefined;
+            uint112?: undefined;
+            uint120?: undefined;
+            uint128?: undefined;
+            uint136?: undefined;
+            uint144?: undefined;
+            uint152?: undefined;
+            uint160?: undefined;
+            uint168?: undefined;
+            uint176?: undefined;
+            uint184?: undefined;
+            uint192?: undefined;
+            uint200?: undefined;
+            uint208?: undefined;
+            uint216?: undefined;
+            uint224?: undefined;
+            uint232?: undefined;
+            uint240?: undefined;
+            uint248?: undefined;
+            uint256?: undefined;
+        } | {
+            [key: string]: unknown;
+        }, TPrimaryType extends string>(args: import("viem").SignTypedDataParameters<TTypedData, TPrimaryType, import("permissionless/accounts").SmartAccount<"biconomySmartAccount", TTransport, TChain>>) => Promise<`0x${string}`>;
+        deployContract: <const TAbi extends readonly unknown[] | import("viem").Abi, TChainOverride_1 extends Chain | undefined = undefined>(args: import("viem").DeployContractParameters<TAbi, undefined, import("permissionless/accounts").SmartAccount<"biconomySmartAccount", TTransport, TChain>, TChainOverride_1> extends infer T ? { [K in keyof T]: import("viem").DeployContractParameters<TAbi, undefined, import("permissionless/accounts").SmartAccount<"biconomySmartAccount", TTransport, TChain>, TChainOverride_1>[K]; } : never) => Promise<`0x${string}`>;
+        writeContract: <const TAbi_1 extends readonly unknown[] | import("viem").Abi, TFunctionName extends import("viem").ContractFunctionName<TAbi_1, "nonpayable" | "payable"> = import("viem").ContractFunctionName<TAbi_1, "nonpayable" | "payable">, TArgs extends import("viem").ContractFunctionArgs<TAbi_1, "nonpayable" | "payable", TFunctionName> = import("viem").ContractFunctionArgs<TAbi_1, "nonpayable" | "payable", TFunctionName>, TChainOverride_2 extends Chain | undefined = undefined>(args: import("viem").WriteContractParameters<TAbi_1, TFunctionName, TArgs, undefined, import("permissionless/accounts").SmartAccount<"biconomySmartAccount", TTransport, TChain>, TChainOverride_2>) => Promise<`0x${string}`>;
+        prepareUserOperationRequest: <TTransport extends Transport>(args: {
+            userOperation: import("permissionless/types").PartialBy<import("permissionless/types").UserOperation, "sender" | "maxFeePerGas" | "maxPriorityFeePerGas" | "nonce" | "initCode" | "callGasLimit" | "verificationGasLimit" | "preVerificationGas" | "paymasterAndData" | "signature">;
+            account?: import("permissionless/_types/accounts").SmartAccount | undefined;
+            sponsorUserOperation?: ((args: {
+                userOperation: import("permissionless/types").UserOperation;
+                entryPoint: `0x${string}`;
+            }) => Promise<import("permissionless/types").UserOperation>) | undefined;
+        }, stateOverrides?: import("permissionless/_types/types/bundler").StateOverrides | undefined) => Promise<{
+            sender: `0x${string}`;
+            nonce: bigint;
+            initCode: `0x${string}`;
+            callData: `0x${string}`;
+            callGasLimit: bigint;
+            verificationGasLimit: bigint;
+            preVerificationGas: bigint;
+            maxFeePerGas: bigint;
+            maxPriorityFeePerGas: bigint;
+            paymasterAndData: `0x${string}`;
+            signature: `0x${string}`;
+        }>;
+        sendUserOperation: <TTransport_1 extends Transport>(args: {
+            userOperation: import("permissionless/types").PartialBy<import("permissionless/types").UserOperation, "sender" | "maxFeePerGas" | "maxPriorityFeePerGas" | "nonce" | "initCode" | "callGasLimit" | "verificationGasLimit" | "preVerificationGas" | "paymasterAndData" | "signature">;
+            account?: import("permissionless/_types/accounts").SmartAccount | undefined;
+            sponsorUserOperation?: ((args: {
+                userOperation: import("permissionless/types").UserOperation;
+                entryPoint: `0x${string}`;
+            }) => Promise<import("permissionless/types").UserOperation>) | undefined;
+        }) => Promise<`0x${string}`>;
+        sendTransactions: (args: {
+            transactions: {
+                to: `0x${string}`;
+                value: bigint;
+                data: `0x${string}`;
+            }[];
+            account?: import("permissionless/_types/accounts").SmartAccount | undefined;
+            sponsorUserOperation?: ((args: {
+                userOperation: import("permissionless/types").UserOperation;
+                entryPoint: `0x${string}`;
+            }) => Promise<import("permissionless/types").UserOperation>) | undefined;
+            maxFeePerGas?: bigint | undefined;
+            maxPriorityFeePerGas?: bigint | undefined;
+            nonce?: bigint | undefined;
+        }) => Promise<`0x${string}`>;
+        extend: <const client extends {
+            [x: string]: unknown;
+            account?: undefined;
+            batch?: undefined;
+            cacheTime?: undefined;
+            chain?: undefined;
+            key?: undefined;
+            name?: undefined;
+            pollingInterval?: undefined;
+            request?: undefined;
+            transport?: undefined;
+            type?: undefined;
+            uid?: undefined;
+        } & Partial<Pick<import("viem").PublicActions, "call" | "createContractEventFilter" | "createEventFilter" | "estimateContractGas" | "estimateGas" | "getBlock" | "getBlockNumber" | "getChainId" | "getContractEvents" | "getEnsText" | "getFilterChanges" | "getGasPrice" | "getLogs" | "getTransaction" | "getTransactionCount" | "getTransactionReceipt" | "prepareTransactionRequest" | "readContract" | "sendRawTransaction" | "simulateContract" | "uninstallFilter" | "watchBlockNumber" | "watchContractEvent"> & Pick<import("viem").WalletActions, "sendTransaction" | "writeContract">>>(fn: (client: import("viem").Client<TTransport, undefined, import("permissionless/accounts").SmartAccount<"biconomySmartAccount", TTransport, TChain>, import("permissionless/_types/types/bundler").BundlerRpcSchema, import("permissionless").SmartAccountActions<undefined, import("permissionless/accounts").SmartAccount<"biconomySmartAccount", TTransport, TChain>>>) => client) => import("viem").Client<TTransport, undefined, import("permissionless/accounts").SmartAccount<"biconomySmartAccount", TTransport, TChain>, import("permissionless/_types/types/bundler").BundlerRpcSchema, { [K_1 in keyof client]: client[K_1]; } & import("permissionless").SmartAccountActions<undefined, import("permissionless/accounts").SmartAccount<"biconomySmartAccount", TTransport, TChain>>>;
+    } & {
+        estimateGas?: (() => bigint | undefined) | undefined;
+    }>;
+}, {}>>;
+//# sourceMappingURL=biconomySmartAccount.d.ts.map

package/_types/connectors/biconomySmartAccount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"biconomySmartAccount.d.ts","sourceRoot":"","sources":["../../connectors/biconomySmartAccount.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,sCAAsC,EAE9C,MAAM,yBAAyB,CAAA;AAChC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,MAAM,CAAA;AACrD,OAAO,EACH,KAAK,sBAAsB,EAE9B,MAAM,sBAAsB,CAAA;AAE7B,MAAM,MAAM,8BAA8B,CACtC,UAAU,SAAS,SAAS,GAAG,SAAS,EACxC,MAAM,SAAS,KAAK,GAAG,SAAS,GAAG,KAAK,GAAG,SAAS,EACpD,OAAO,SAAS,MAAM,GAAG,QAAQ,EACjC,QAAQ,SAAS,OAAO,GAAG,OAAO,IAClC,QAAQ,CACR,sBAAsB,CAClB,IAAI,CACA,sCAAsC,CAAC,OAAO,EAAE,QAAQ,CAAC,EACzD,QAAQ,CACX,EACD,UAAU,EACV,MAAM,EACN,OAAO,EACP,QAAQ,CACX,CACJ,CAAA;AAED,wBAAsB,oBAAoB,CACtC,UAAU,SAAS,SAAS,GAAG,SAAS,EACxC,MAAM,SAAS,KAAK,GAAG,SAAS,GAAG,KAAK,GAAG,SAAS,EACpD,OAAO,SAAS,MAAM,GAAG,QAAQ,EACjC,QAAQ,SAAS,OAAO,GAAG,OAAO,EACpC,EACE,YAAY,EACZ,MAAM,EACN,gBAAgB,EAChB,oBAAoB,EACpB,GAAG,IAAI,EACV,EAAE,QAAQ,CACP,8BAA8B,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC,CACxE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAUA"}