permissionless 0.1.48 → 0.1.49

package/_esm/utils/signUserOperationHashWithECDSA.js

@@ -0,0 +1,76 @@
+import { BaseError } from "viem";
+import { parseAccount } from "./index.js";
+import { getUserOperationHash } from "./getUserOperationHash.js";
+export class AccountOrClientNotFoundError extends BaseError {
+    constructor({ docsPath } = {}) {
+        super([
+            "Could not find an Account to execute with this Action.",
+            "Please provide an Account with the `account` argument on the Action, or by supplying an `account` to the WalletClient."
+        ].join("\n"), {
+            docsPath,
+            docsSlug: "account"
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "AccountOrClientNotFoundError"
+        });
+    }
+}
+/**
+ *
+ * Returns signature for user operation. It signs over user operation hash.
+ * If you have a custom way of signing user operation hash, you can use this function to sign it with ECDSA.
+ *
+ * - Docs: https://docs.pimlico.io/permissionless/reference/utils/signUserOperationHashWithECDSA
+ *
+ * @param signer: owner as {@link Client<Transport, TChain, TAccount>}
+ * @param params: account & (userOperation, entryPoint, chainId)  | hash to sign
+ * @returns signature as {@link Hash}
+ *
+ * @example
+ * import { signUserOperationHashWithECDSA } from "permissionless/utils"
+ *
+ * const userOperationSignature = signUserOperationHashWithECDSA(owner, {
+ *      userOperation,
+ *      entryPoint,
+ *      chainId
+ * })
+ *
+ * // Returns "0x7d9ae17d5e617e4bf3221dfcb69d64d824959e5ae2ef7078c6ddc3a4fe26c8301ab39277c61160dca68ca90071eb449d9fb2fbbc78b3614d9d7282c860270e291c"
+ *
+ */
+export const signUserOperationHashWithECDSA = async ({ client, account: account_ = client?.account, hash, userOperation, chainId, entryPoint: entryPointAddress }) => {
+    if (!account_)
+        throw new AccountOrClientNotFoundError({
+            docsPath: "/permissionless/reference/utils/signUserOperationHashWithECDSA"
+        });
+    let userOperationHash;
+    if (hash) {
+        userOperationHash = hash;
+    }
+    else {
+        userOperationHash = getUserOperationHash({
+            userOperation,
+            chainId,
+            entryPoint: entryPointAddress
+        });
+    }
+    const account = parseAccount(account_);
+    if (account.type === "local")
+        return account.signMessage({
+            message: {
+                raw: userOperationHash
+            }
+        });
+    if (!client)
+        throw new AccountOrClientNotFoundError({
+            docsPath: "/permissionless/reference/utils/signUserOperationHashWithECDSA"
+        });
+    return client.request({
+        method: "personal_sign",
+        params: [userOperationHash, account.address]
+    });
+};
+//# sourceMappingURL=signUserOperationHashWithECDSA.js.map

package/_esm/utils/signUserOperationHashWithECDSA.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signUserOperationHashWithECDSA.js","sourceRoot":"","sources":["../../utils/signUserOperationHashWithECDSA.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,SAAS,EAMZ,MAAM,MAAM,CAAA;AAOb,OAAO,EAAE,YAAY,EAAE,MAAM,IAAI,CAAA;AACjC,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAuB7D,MAAM,OAAO,4BAA6B,SAAQ,SAAS;IAEvD,YAAY,EAAE,QAAQ,KAA4B,EAAE;QAChD,KAAK,CACD;YACI,wDAAwD;YACxD,wHAAwH;SAC3H,CAAC,IAAI,CAAC,IAAI,CAAC,EACZ;YACI,QAAQ;YACR,QAAQ,EAAE,SAAS;SACtB,CACJ,CAAA;QAXI;;;;mBAAO,8BAA8B;WAAA;IAY9C,CAAC;CACJ;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,KAAK,EAKjD,EACE,MAAM,EACN,OAAO,EAAE,QAAQ,GAAG,MAAM,EAAE,OAAO,EACnC,IAAI,EACJ,aAAa,EACb,OAAO,EACP,UAAU,EAAE,iBAAiB,EAMhC,EAAgB,EAAE;IACf,IAAI,CAAC,QAAQ;QACT,MAAM,IAAI,4BAA4B,CAAC;YACnC,QAAQ,EACJ,gEAAgE;SACvE,CAAC,CAAA;IAEN,IAAI,iBAAuB,CAAA;IAE3B,IAAI,IAAI,EAAE,CAAC;QACP,iBAAiB,GAAG,IAAI,CAAA;IAC5B,CAAC;SAAM,CAAC;QACJ,iBAAiB,GAAG,oBAAoB,CAAa;YACjD,aAAa;YACb,OAAO;YACP,UAAU,EAAE,iBAAiB;SAChC,CAAC,CAAA;IACN,CAAC;IAED,MAAM,OAAO,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;IAEtC,IAAI,OAAO,CAAC,IAAI,KAAK,OAAO;QACxB,OAAO,OAAO,CAAC,WAAW,CAAC;YACvB,OAAO,EAAE;gBACL,GAAG,EAAE,iBAAiB;aACzB;SACJ,CAAC,CAAA;IAEN,IAAI,CAAC,MAAM;QACP,MAAM,IAAI,4BAA4B,CAAC;YACnC,QAAQ,EACJ,gEAAgE;SACvE,CAAC,CAAA;IAEN,OAAO,MAAM,CAAC,OAAO,CAAC;QAClB,MAAM,EAAE,eAAe;QACvB,MAAM,EAAE,CAAC,iBAAiB,EAAE,OAAO,CAAC,OAAO,CAAC;KAC/C,CAAC,CAAA;AACN,CAAC,CAAA"}

package/_esm/utils/walletClientToSmartAccountSigner.js

@@ -0,0 +1,19 @@
+import { signTypedData } from "viem/actions";
+export function walletClientToSmartAccountSigner(walletClient) {
+    return {
+        address: walletClient.account.address,
+        type: "local",
+        source: "custom",
+        publicKey: walletClient.account.address,
+        signMessage: async ({ message }) => {
+            return walletClient.signMessage({ message });
+        },
+        async signTypedData(typedData) {
+            return signTypedData(walletClient, {
+                account: walletClient.account,
+                ...typedData
+            });
+        }
+    };
+}
+//# sourceMappingURL=walletClientToSmartAccountSigner.js.map

package/_esm/utils/walletClientToSmartAccountSigner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"walletClientToSmartAccountSigner.js","sourceRoot":"","sources":["../../utils/walletClientToSmartAccountSigner.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAG5C,MAAM,UAAU,gCAAgC,CAG5C,YAAsD;IAEtD,OAAO;QACH,OAAO,EAAE,YAAY,CAAC,OAAO,CAAC,OAAO;QACrC,IAAI,EAAE,OAAO;QACb,MAAM,EAAE,QAAQ;QAChB,SAAS,EAAE,YAAY,CAAC,OAAO,CAAC,OAAO;QACvC,WAAW,EAAE,KAAK,EAAE,EAChB,OAAO,EACoB,EAAgB,EAAE;YAC7C,OAAO,YAAY,CAAC,WAAW,CAAC,EAAE,OAAO,EAAE,CAAC,CAAA;QAChD,CAAC;QACD,KAAK,CAAC,aAAa,CAKjB,SAAwD;YACtD,OAAO,aAAa,CAChB,YAAY,EACZ;gBACI,OAAO,EAAE,YAAY,CAAC,OAAO;gBAC7B,GAAG,SAAS;aACf,CACJ,CAAA;QACL,CAAC;KACJ,CAAA;AACL,CAAC"}

package/_esm/vitest.config.js

@@ -0,0 +1,29 @@
+import { join } from "node:path";
+import { defineConfig } from "vitest/config";
+export default defineConfig({
+    test: {
+        coverage: {
+            all: true,
+            provider: "v8",
+            reporter: process.env.CI ? ["lcov"] : ["text", "json", "html"],
+            include: ["**/permissionless/**"],
+            exclude: [
+                "**/errors/utils.ts",
+                "**/*.test.ts",
+                "**/permissionless-test/**",
+                "**/_cjs/**",
+                "**/_esm/**",
+                "**/_types/**"
+            ]
+        },
+        sequence: {
+            concurrent: false
+        },
+        fileParallelism: true,
+        environment: "node",
+        testTimeout: 60_000,
+        hookTimeout: 45_000,
+        include: [join(__dirname, "./**/*.test.ts")]
+    }
+});
+//# sourceMappingURL=vitest.config.js.map

package/_esm/vitest.config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.config.js","sourceRoot":"","sources":["../vitest.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAE5C,eAAe,YAAY,CAAC;IACxB,IAAI,EAAE;QACF,QAAQ,EAAE;YACN,GAAG,EAAE,IAAI;YACT,QAAQ,EAAE,IAAI;YACd,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;YAC9D,OAAO,EAAE,CAAC,sBAAsB,CAAC;YACjC,OAAO,EAAE;gBACL,oBAAoB;gBACpB,cAAc;gBACd,2BAA2B;gBAC3B,YAAY;gBACZ,YAAY;gBACZ,cAAc;aACjB;SACJ;QACD,QAAQ,EAAE;YACN,UAAU,EAAE,KAAK;SACpB;QACD,eAAe,EAAE,IAAI;QACrB,WAAW,EAAE,MAAM;QACnB,WAAW,EAAE,MAAM;QACnB,WAAW,EAAE,MAAM;QACnB,OAAO,EAAE,CAAC,IAAI,CAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;KAC/C;CACJ,CAAC,CAAA"}

package/_types/accounts/biconomy/abi/BiconomySmartAccountAbi.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The exeuctor abi, used to execute transactions on the Biconomy Modular Smart Account
+ */
+export declare const BiconomyExecuteAbi: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "dest";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "value";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "func";
+        readonly type: "bytes";
+    }];
+    readonly name: "execute_ncC";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "dest";
+        readonly type: "address[]";
+    }, {
+        readonly internalType: "uint256[]";
+        readonly name: "value";
+        readonly type: "uint256[]";
+    }, {
+        readonly internalType: "bytes[]";
+        readonly name: "func";
+        readonly type: "bytes[]";
+    }];
+    readonly name: "executeBatch_y6U";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}];
+/**
+ * The init abi, used to initialise Biconomy Modular Smart Account / setup default ECDSA module
+ */
+export declare const BiconomyInitAbi: {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+}[];
+//# sourceMappingURL=BiconomySmartAccountAbi.d.ts.map

package/_types/accounts/biconomy/abi/BiconomySmartAccountAbi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BiconomySmartAccountAbi.d.ts","sourceRoot":"","sources":["../../../../accounts/biconomy/abi/BiconomySmartAccountAbi.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+CrB,CAAA;AAEV;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;GAiD3B,CAAA"}

package/_types/accounts/biconomy/privateKeyToBiconomySmartAccount.d.ts

@@ -0,0 +1,13 @@
+import type { Chain, Client, Hex, PublicActions, PublicRpcSchema, Transport } from "viem";
+import type { ENTRYPOINT_ADDRESS_V06_TYPE, Prettify } from "../../types";
+import { type BiconomySmartAccount, type SignerToBiconomySmartAccountParameters } from "./signerToBiconomySmartAccount";
+export type PrivateKeyToBiconomySmartAccountParameters<entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE> = Prettify<{
+    privateKey: Hex;
+} & Omit<SignerToBiconomySmartAccountParameters<entryPoint>, "signer">>;
+/**
+ * @description Creates a Biconomy Smart Account from a private key.
+ *
+ * @returns A Private Key Biconomy Smart Account using ECDSA as default validation module.
+ */
+export declare function privateKeyToBiconomySmartAccount<entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE, TTransport extends Transport = Transport, TChain extends Chain | undefined = Chain | undefined>(client: Client<TTransport, TChain, undefined, PublicRpcSchema, PublicActions<TTransport, TChain>>, { privateKey, ...rest }: PrivateKeyToBiconomySmartAccountParameters<entryPoint>): Promise<BiconomySmartAccount<entryPoint, TTransport, TChain>>;
+//# sourceMappingURL=privateKeyToBiconomySmartAccount.d.ts.map

package/_types/accounts/biconomy/privateKeyToBiconomySmartAccount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"privateKeyToBiconomySmartAccount.d.ts","sourceRoot":"","sources":["../../../accounts/biconomy/privateKeyToBiconomySmartAccount.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,KAAK,EACL,MAAM,EACN,GAAG,EACH,aAAa,EACb,eAAe,EACf,SAAS,EACZ,MAAM,MAAM,CAAA;AAEb,OAAO,KAAK,EAAE,2BAA2B,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACxE,OAAO,EACH,KAAK,oBAAoB,EACzB,KAAK,sCAAsC,EAE9C,MAAM,gCAAgC,CAAA;AAEvC,MAAM,MAAM,0CAA0C,CAClD,UAAU,SAAS,2BAA2B,IAC9C,QAAQ,CACR;IACI,UAAU,EAAE,GAAG,CAAA;CAClB,GAAG,IAAI,CAAC,sCAAsC,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,CACzE,CAAA;AAED;;;;GAIG;AACH,wBAAsB,gCAAgC,CAClD,UAAU,SAAS,2BAA2B,EAC9C,UAAU,SAAS,SAAS,GAAG,SAAS,EACxC,MAAM,SAAS,KAAK,GAAG,SAAS,GAAG,KAAK,GAAG,SAAS,EAEpD,MAAM,EAAE,MAAM,CACV,UAAU,EACV,MAAM,EACN,SAAS,EACT,eAAe,EACf,aAAa,CAAC,UAAU,EAAE,MAAM,CAAC,CACpC,EACD,EACI,UAAU,EACV,GAAG,IAAI,EACV,EAAE,0CAA0C,CAAC,UAAU,CAAC,GAC1D,OAAO,CAAC,oBAAoB,CAAC,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC,CAW/D"}

package/_types/accounts/biconomy/signerToBiconomySmartAccount.d.ts

@@ -0,0 +1,29 @@
+import type { PublicActions, PublicRpcSchema } from "viem";
+import { type Address, type Chain, type Client, type Transport } from "viem";
+import type { Prettify } from "../../types";
+import type { ENTRYPOINT_ADDRESS_V06_TYPE } from "../../types/entrypoint";
+import { type SmartAccount, type SmartAccountSigner } from "../types";
+export type BiconomySmartAccount<entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE, transport extends Transport = Transport, chain extends Chain | undefined = Chain | undefined> = SmartAccount<entryPoint, "biconomySmartAccount", transport, chain>;
+export type SignerToBiconomySmartAccountParameters<entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE, TSource extends string = string, TAddress extends Address = Address> = Prettify<{
+    nonceKey?: bigint;
+    signer: SmartAccountSigner<TSource, TAddress>;
+    entryPoint: entryPoint;
+    address?: Address;
+    index?: bigint;
+    factoryAddress?: Address;
+    accountLogicAddress?: Address;
+    fallbackHandlerAddress?: Address;
+    ecdsaModuleAddress?: Address;
+}>;
+/**
+ * Build a Biconomy modular smart account from a private key, that use the ECDSA signer behind the scene
+ * @param client
+ * @param privateKey
+ * @param entryPoint
+ * @param index
+ * @param factoryAddress
+ * @param accountLogicAddress
+ * @param ecdsaModuleAddress
+ */
+export declare function signerToBiconomySmartAccount<entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE, TTransport extends Transport = Transport, TChain extends Chain | undefined = Chain | undefined, TSource extends string = string, TAddress extends Address = Address>(client: Client<TTransport, TChain, undefined, PublicRpcSchema, PublicActions<TTransport, TChain>>, { signer, address, entryPoint: entryPointAddress, index, factoryAddress, accountLogicAddress, fallbackHandlerAddress, ecdsaModuleAddress, nonceKey }: SignerToBiconomySmartAccountParameters<entryPoint, TSource, TAddress>): Promise<BiconomySmartAccount<entryPoint, TTransport, TChain>>;
+//# sourceMappingURL=signerToBiconomySmartAccount.d.ts.map

package/_types/accounts/biconomy/signerToBiconomySmartAccount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signerToBiconomySmartAccount.d.ts","sourceRoot":"","sources":["../../../accounts/biconomy/signerToBiconomySmartAccount.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAa,MAAM,MAAM,CAAA;AACrE,OAAO,EACH,KAAK,OAAO,EACZ,KAAK,KAAK,EACV,KAAK,MAAM,EAGX,KAAK,SAAS,EAUjB,MAAM,MAAM,CAAA;AAGb,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAA;AAKzE,OAAO,EAEH,KAAK,YAAY,EACjB,KAAK,kBAAkB,EAC1B,MAAM,UAAU,CAAA;AAMjB,MAAM,MAAM,oBAAoB,CAC5B,UAAU,SAAS,2BAA2B,EAC9C,SAAS,SAAS,SAAS,GAAG,SAAS,EACvC,KAAK,SAAS,KAAK,GAAG,SAAS,GAAG,KAAK,GAAG,SAAS,IACnD,YAAY,CAAC,UAAU,EAAE,sBAAsB,EAAE,SAAS,EAAE,KAAK,CAAC,CAAA;AAgJtE,MAAM,MAAM,sCAAsC,CAC9C,UAAU,SAAS,2BAA2B,EAC9C,OAAO,SAAS,MAAM,GAAG,MAAM,EAC/B,QAAQ,SAAS,OAAO,GAAG,OAAO,IAClC,QAAQ,CAAC;IACT,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,kBAAkB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;IAC7C,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAC7B,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC/B,CAAC,CAAA;AAEF;;;;;;;;;GASG;AACH,wBAAsB,4BAA4B,CAC9C,UAAU,SAAS,2BAA2B,EAC9C,UAAU,SAAS,SAAS,GAAG,SAAS,EACxC,MAAM,SAAS,KAAK,GAAG,SAAS,GAAG,KAAK,GAAG,SAAS,EACpD,OAAO,SAAS,MAAM,GAAG,MAAM,EAC/B,QAAQ,SAAS,OAAO,GAAG,OAAO,EAElC,MAAM,EAAE,MAAM,CACV,UAAU,EACV,MAAM,EACN,SAAS,EACT,eAAe,EACf,aAAa,CAAC,UAAU,EAAE,MAAM,CAAC,CACpC,EACD,EACI,MAAM,EACN,OAAO,EACP,UAAU,EAAE,iBAAiB,EAC7B,KAAiB,EACjB,cAAmD,EACnD,mBAA2D,EAC3D,sBAA4E,EAC5E,kBAAuE,EACvE,QAAQ,EACX,EAAE,sCAAsC,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,CAAC,GACzE,OAAO,CAAC,oBAAoB,CAAC,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC,CA0N/D"}

package/_types/accounts/index.d.ts

@@ -0,0 +1,15 @@
+import { type PrivateKeyToSimpleSmartAccountParameters, privateKeyToSimpleSmartAccount } from "./simple/privateKeyToSimpleSmartAccount";
+import { type SignerToSimpleSmartAccountParameters, type SimpleSmartAccount, signerToSimpleSmartAccount } from "./simple/signerToSimpleSmartAccount";
+import { type PrivateKeyToLightSmartAccountParameters, privateKeyToLightSmartAccount } from "./light/privateKeyToLightSmartAccount";
+import { type LightSmartAccount, type SignerToLightSmartAccountParameters, signerToLightSmartAccount } from "./light/signerToLightSmartAccount";
+import { type SignerToTrustSmartAccountParameters, type TrustSmartAccount, signerToTrustSmartAccount } from "./trust/signerToTrustSmartAccount";
+import { type PrivateKeyToTrustSmartAccountParameters, privateKeyToTrustSmartAccount } from "./trust/privateKeyToTrustSmartAccount";
+import { type PrivateKeyToSafeSmartAccountParameters, privateKeyToSafeSmartAccount } from "./safe/privateKeyToSafeSmartAccount";
+import { type SafeSmartAccount, type SafeVersion, type SignerToSafeSmartAccountParameters, signerToSafeSmartAccount } from "./safe/signerToSafeSmartAccount";
+import { type KernelEcdsaSmartAccount, type SignerToEcdsaKernelSmartAccountParameters, signerToEcdsaKernelSmartAccount } from "./kernel/signerToEcdsaKernelSmartAccount";
+import { type BiconomySmartAccount, type SignerToBiconomySmartAccountParameters, signerToBiconomySmartAccount } from "./biconomy/signerToBiconomySmartAccount";
+import { type PrivateKeyToBiconomySmartAccountParameters, privateKeyToBiconomySmartAccount } from "./biconomy/privateKeyToBiconomySmartAccount";
+import { SignTransactionNotSupportedBySmartAccount, type SmartAccount, type SmartAccountSigner } from "./types";
+import { toSmartAccount } from "./toSmartAccount";
+export { type SafeVersion, type SmartAccountSigner, type SafeSmartAccount, signerToSafeSmartAccount, type SimpleSmartAccount, signerToSimpleSmartAccount, type LightSmartAccount, signerToLightSmartAccount, type TrustSmartAccount, signerToTrustSmartAccount, privateKeyToTrustSmartAccount, SignTransactionNotSupportedBySmartAccount, privateKeyToBiconomySmartAccount, privateKeyToSimpleSmartAccount, privateKeyToLightSmartAccount, type SmartAccount, privateKeyToSafeSmartAccount, type KernelEcdsaSmartAccount, signerToEcdsaKernelSmartAccount, type BiconomySmartAccount, signerToBiconomySmartAccount, toSmartAccount, type SignerToSimpleSmartAccountParameters, type SignerToLightSmartAccountParameters, type SignerToSafeSmartAccountParameters, type PrivateKeyToSimpleSmartAccountParameters, type PrivateKeyToLightSmartAccountParameters, type PrivateKeyToSafeSmartAccountParameters, type SignerToEcdsaKernelSmartAccountParameters, type SignerToBiconomySmartAccountParameters, type PrivateKeyToBiconomySmartAccountParameters, type SignerToTrustSmartAccountParameters, type PrivateKeyToTrustSmartAccountParameters };
+//# sourceMappingURL=index.d.ts.map

package/_types/accounts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../accounts/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,wCAAwC,EAC7C,8BAA8B,EACjC,MAAM,yCAAyC,CAAA;AAEhD,OAAO,EACH,KAAK,oCAAoC,EACzC,KAAK,kBAAkB,EACvB,0BAA0B,EAC7B,MAAM,qCAAqC,CAAA;AAE5C,OAAO,EACH,KAAK,uCAAuC,EAC5C,6BAA6B,EAChC,MAAM,uCAAuC,CAAA;AAE9C,OAAO,EACH,KAAK,iBAAiB,EACtB,KAAK,mCAAmC,EACxC,yBAAyB,EAC5B,MAAM,mCAAmC,CAAA;AAE1C,OAAO,EACH,KAAK,mCAAmC,EACxC,KAAK,iBAAiB,EACtB,yBAAyB,EAC5B,MAAM,mCAAmC,CAAA;AAE1C,OAAO,EACH,KAAK,uCAAuC,EAC5C,6BAA6B,EAChC,MAAM,uCAAuC,CAAA;AAE9C,OAAO,EACH,KAAK,sCAAsC,EAC3C,4BAA4B,EAC/B,MAAM,qCAAqC,CAAA;AAE5C,OAAO,EACH,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAChB,KAAK,kCAAkC,EACvC,wBAAwB,EAC3B,MAAM,iCAAiC,CAAA;AAExC,OAAO,EACH,KAAK,uBAAuB,EAC5B,KAAK,yCAAyC,EAC9C,+BAA+B,EAClC,MAAM,0CAA0C,CAAA;AAEjD,OAAO,EACH,KAAK,oBAAoB,EACzB,KAAK,sCAAsC,EAC3C,4BAA4B,EAC/B,MAAM,yCAAyC,CAAA;AAEhD,OAAO,EACH,KAAK,0CAA0C,EAC/C,gCAAgC,EACnC,MAAM,6CAA6C,CAAA;AAEpD,OAAO,EACH,yCAAyC,EACzC,KAAK,YAAY,EACjB,KAAK,kBAAkB,EAC1B,MAAM,SAAS,CAAA;AAEhB,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAEjD,OAAO,EACH,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,wBAAwB,EACxB,KAAK,kBAAkB,EACvB,0BAA0B,EAC1B,KAAK,iBAAiB,EACtB,yBAAyB,EACzB,KAAK,iBAAiB,EACtB,yBAAyB,EACzB,6BAA6B,EAC7B,yCAAyC,EACzC,gCAAgC,EAChC,8BAA8B,EAC9B,6BAA6B,EAC7B,KAAK,YAAY,EACjB,4BAA4B,EAC5B,KAAK,uBAAuB,EAC5B,+BAA+B,EAC/B,KAAK,oBAAoB,EACzB,4BAA4B,EAC5B,cAAc,EACd,KAAK,oCAAoC,EACzC,KAAK,mCAAmC,EACxC,KAAK,kCAAkC,EACvC,KAAK,wCAAwC,EAC7C,KAAK,uCAAuC,EAC5C,KAAK,sCAAsC,EAC3C,KAAK,yCAAyC,EAC9C,KAAK,sCAAsC,EAC3C,KAAK,0CAA0C,EAC/C,KAAK,mCAAmC,EACxC,KAAK,uCAAuC,EAC/C,CAAA"}

package/_types/accounts/kernel/abi/KernelAccountAbi.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The exeute abi, used to execute a transaction on the kernel smart account
+ */
+export declare const KernelExecuteAbi: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "value";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "enum Operation";
+        readonly name: "";
+        readonly type: "uint8";
+    }];
+    readonly name: "execute";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "value";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "data";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct Call[]";
+        readonly name: "calls";
+        readonly type: "tuple[]";
+    }];
+    readonly name: "executeBatch";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}];
+/**
+ * The init abi, used to initialise kernel account
+ */
+export declare const KernelInitAbi: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "contract IKernelValidator";
+        readonly name: "_defaultValidator";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "_data";
+        readonly type: "bytes";
+    }];
+    readonly name: "initialize";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}];
+//# sourceMappingURL=KernelAccountAbi.d.ts.map

package/_types/accounts/kernel/abi/KernelAccountAbi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KernelAccountAbi.d.ts","sourceRoot":"","sources":["../../../../accounts/kernel/abi/KernelAccountAbi.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2DnB,CAAA;AAEV;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;EAmBhB,CAAA"}

package/_types/accounts/kernel/abi/KernelV3AccountAbi.d.ts

@@ -0,0 +1,135 @@
+export declare const KernelV3InitAbi: readonly [{
+    readonly type: "function";
+    readonly name: "initialize";
+    readonly inputs: readonly [{
+        readonly name: "_rootValidator";
+        readonly type: "bytes21";
+        readonly internalType: "ValidationId";
+    }, {
+        readonly name: "hook";
+        readonly type: "address";
+        readonly internalType: "contract IHook";
+    }, {
+        readonly name: "validatorData";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "hookData";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}];
+export declare const KernelV3_1AccountAbi: readonly [{
+    readonly type: "function";
+    readonly name: "initialize";
+    readonly inputs: readonly [{
+        readonly name: "_rootValidator";
+        readonly type: "bytes21";
+        readonly internalType: "ValidationId";
+    }, {
+        readonly name: "hook";
+        readonly type: "address";
+        readonly internalType: "contract IHook";
+    }, {
+        readonly name: "validatorData";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "hookData";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "initConfig";
+        readonly type: "bytes[]";
+        readonly internalType: "bytes[]";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}];
+export declare const KernelV3ExecuteAbi: readonly [{
+    readonly type: "function";
+    readonly name: "execute";
+    readonly inputs: readonly [{
+        readonly name: "execMode";
+        readonly type: "bytes32";
+        readonly internalType: "ExecMode";
+    }, {
+        readonly name: "executionCalldata";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+}, {
+    readonly type: "function";
+    readonly name: "executeFromExecutor";
+    readonly inputs: readonly [{
+        readonly name: "execMode";
+        readonly type: "bytes32";
+        readonly internalType: "ExecMode";
+    }, {
+        readonly name: "executionCalldata";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "returnData";
+        readonly type: "bytes[]";
+        readonly internalType: "bytes[]";
+    }];
+    readonly stateMutability: "payable";
+}, {
+    readonly type: "function";
+    readonly name: "executeUserOp";
+    readonly inputs: readonly [{
+        readonly name: "userOp";
+        readonly type: "tuple";
+        readonly internalType: "struct PackedUserOperation";
+        readonly components: readonly [{
+            readonly name: "sender";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "initCode";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }, {
+            readonly name: "callData";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }, {
+            readonly name: "accountGasLimits";
+            readonly type: "bytes32";
+            readonly internalType: "bytes32";
+        }, {
+            readonly name: "preVerificationGas";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "gasFees";
+            readonly type: "bytes32";
+            readonly internalType: "bytes32";
+        }, {
+            readonly name: "paymasterAndData";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }, {
+            readonly name: "signature";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }];
+    }, {
+        readonly name: "userOpHash";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+}];
+//# sourceMappingURL=KernelV3AccountAbi.d.ts.map

package/_types/accounts/kernel/abi/KernelV3AccountAbi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KernelV3AccountAbi.d.ts","sourceRoot":"","sources":["../../../../accounts/kernel/abi/KernelV3AccountAbi.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;EAiBlB,CAAA;AAEV,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBvB,CAAA;AAEV,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoErB,CAAA"}

package/_types/accounts/kernel/abi/KernelV3MetaFactoryAbi.d.ts

@@ -0,0 +1,24 @@
+export declare const KernelV3MetaFactoryDeployWithFactoryAbi: readonly [{
+    readonly type: "function";
+    readonly name: "deployWithFactory";
+    readonly inputs: readonly [{
+        readonly name: "factory";
+        readonly type: "address";
+        readonly internalType: "contract KernelFactory";
+    }, {
+        readonly name: "createData";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "salt";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "payable";
+}];
+//# sourceMappingURL=KernelV3MetaFactoryAbi.d.ts.map

package/_types/accounts/kernel/abi/KernelV3MetaFactoryAbi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KernelV3MetaFactoryAbi.d.ts","sourceRoot":"","sources":["../../../../accounts/kernel/abi/KernelV3MetaFactoryAbi.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;EAgB1C,CAAA"}

package/_types/accounts/kernel/constants.d.ts

@@ -0,0 +1,21 @@
+export declare const DUMMY_ECDSA_SIGNATURE = "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
+export declare const ROOT_MODE_KERNEL_V2 = "0x00000000";
+export declare enum CALL_TYPE {
+    SINGLE = "0x00",
+    BATCH = "0x01",
+    DELEGATE_CALL = "0xFF"
+}
+export declare enum EXEC_TYPE {
+    DEFAULT = "0x00",
+    TRY_EXEC = "0x01"
+}
+export declare const VALIDATOR_TYPE: {
+    readonly ROOT: "0x00";
+    readonly VALIDATOR: "0x01";
+    readonly PERMISSION: "0x02";
+};
+export declare enum VALIDATOR_MODE {
+    DEFAULT = "0x00",
+    ENABLE = "0x01"
+}
+//# sourceMappingURL=constants.d.ts.map

package/_types/accounts/kernel/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../accounts/kernel/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,yIACwG,CAAA;AAC1I,eAAO,MAAM,mBAAmB,eAAe,CAAA;AAC/C,oBAAY,SAAS;IACjB,MAAM,SAAS;IACf,KAAK,SAAS;IACd,aAAa,SAAS;CACzB;AACD,oBAAY,SAAS;IACjB,OAAO,SAAS;IAChB,QAAQ,SAAS;CACpB;AACD,eAAO,MAAM,cAAc;;;;CAIjB,CAAA;AACV,oBAAY,cAAc;IACtB,OAAO,SAAS;IAChB,MAAM,SAAS;CAClB"}

package/_types/accounts/kernel/signerToEcdsaKernelSmartAccount.d.ts

@@ -0,0 +1,44 @@
+import type { PublicActions, PublicRpcSchema } from "viem";
+import { type Address, type Chain, type Client, type Transport } from "viem";
+import type { EntryPoint, Prettify } from "../../types";
+import type { ENTRYPOINT_ADDRESS_V06_TYPE } from "../../types/entrypoint";
+import type { SmartAccount } from "../types";
+import { type SmartAccountSigner } from "../types";
+export type KernelEcdsaSmartAccount<entryPoint extends EntryPoint, transport extends Transport = Transport, chain extends Chain | undefined = Chain | undefined> = SmartAccount<entryPoint, "kernelEcdsaSmartAccount", transport, chain>;
+export type KernelVersion<entryPoint extends EntryPoint> = entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE ? "0.2.1" | "0.2.2" | "0.2.3" | "0.2.4" : "0.3.0-beta" | "0.3.1";
+/**
+ * Default addresses map for different kernel smart account versions
+ */
+export declare const KERNEL_VERSION_TO_ADDRESSES_MAP: {
+    [key in KernelVersion<EntryPoint>]: {
+        ECDSA_VALIDATOR: Address;
+        ACCOUNT_LOGIC: Address;
+        FACTORY_ADDRESS: Address;
+        META_FACTORY_ADDRESS?: Address;
+    };
+};
+export declare const getEcdsaRootIdentifierForKernelV3: (validatorAddress: Address) => `0x${string}`;
+export type SignerToEcdsaKernelSmartAccountParameters<entryPoint extends EntryPoint, TSource extends string = string, TAddress extends Address = Address> = Prettify<{
+    signer: SmartAccountSigner<TSource, TAddress>;
+    version?: KernelVersion<entryPoint>;
+    entryPoint: entryPoint;
+    address?: Address;
+    index?: bigint;
+    factoryAddress?: Address;
+    metaFactoryAddress?: Address;
+    accountLogicAddress?: Address;
+    ecdsaValidatorAddress?: Address;
+    nonceKey?: bigint;
+}>;
+/**
+ * Build a kernel smart account from a private key, that use the ECDSA signer behind the scene
+ * @param client
+ * @param privateKey
+ * @param entryPoint
+ * @param index
+ * @param factoryAddress
+ * @param accountLogicAddress
+ * @param ecdsaValidatorAddress
+ */
+export declare function signerToEcdsaKernelSmartAccount<entryPoint extends EntryPoint, TTransport extends Transport = Transport, TChain extends Chain | undefined = Chain | undefined, TSource extends string = string, TAddress extends Address = Address>(client: Client<TTransport, TChain, undefined, PublicRpcSchema, PublicActions<TTransport, TChain>>, { signer, address, version, entryPoint: entryPointAddress, index, factoryAddress: _factoryAddress, metaFactoryAddress: _metaFactoryAddress, accountLogicAddress: _accountLogicAddress, ecdsaValidatorAddress: _ecdsaValidatorAddress, nonceKey }: SignerToEcdsaKernelSmartAccountParameters<entryPoint, TSource, TAddress>): Promise<KernelEcdsaSmartAccount<entryPoint, TTransport, TChain>>;
+//# sourceMappingURL=signerToEcdsaKernelSmartAccount.d.ts.map

package/_types/accounts/kernel/signerToEcdsaKernelSmartAccount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signerToEcdsaKernelSmartAccount.d.ts","sourceRoot":"","sources":["../../../accounts/kernel/signerToEcdsaKernelSmartAccount.ts"],"names":[],"mappings":"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"}

package/_types/accounts/kernel/utils/encodeCallData.d.ts

@@ -0,0 +1,13 @@
+import { type Address, type Hex } from "viem";
+import type { EntryPoint } from "../../../types";
+import type { KernelVersion } from "../signerToEcdsaKernelSmartAccount";
+export declare const encodeCallData: (_tx: {
+    to: Address;
+    value: bigint;
+    data: Hex;
+} | {
+    to: Address;
+    value: bigint;
+    data: Hex;
+}[], accountVersion: KernelVersion<EntryPoint>) => `0x${string}`;
+//# sourceMappingURL=encodeCallData.d.ts.map

package/_types/accounts/kernel/utils/encodeCallData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encodeCallData.d.ts","sourceRoot":"","sources":["../../../../accounts/kernel/utils/encodeCallData.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,OAAO,EACZ,KAAK,GAAG,EAKX,MAAM,MAAM,CAAA;AACb,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAIhD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAA;AAIvE,eAAO,MAAM,cAAc,QAEjB;IACI,EAAE,EAAE,OAAO,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,GAAG,CAAA;CACZ,GACD;IACI,EAAE,EAAE,OAAO,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,GAAG,CAAA;CACZ,EAAE,kBACO,cAAc,UAAU,CAAC,kBAuF5C,CAAA"}

package/_types/accounts/kernel/utils/getExecMode.d.ts

@@ -0,0 +1,7 @@
+import { type Hex } from "viem";
+import type { CALL_TYPE, EXEC_TYPE } from "../constants";
+export declare const getExecMode: ({ callType, execType }: {
+    callType: CALL_TYPE;
+    execType: EXEC_TYPE;
+}) => Hex;
+//# sourceMappingURL=getExecMode.d.ts.map

package/_types/accounts/kernel/utils/getExecMode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getExecMode.d.ts","sourceRoot":"","sources":["../../../../accounts/kernel/utils/getExecMode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,EAAkB,MAAM,MAAM,CAAA;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAExD,eAAO,MAAM,WAAW,2BAGrB;IACC,QAAQ,EAAE,SAAS,CAAA;IACnB,QAAQ,EAAE,SAAS,CAAA;CACtB,KAAG,GAQH,CAAA"}

package/_types/accounts/kernel/utils/getNonceKey.d.ts

@@ -0,0 +1,5 @@
+import { type Address } from "viem";
+import type { EntryPoint } from "../../../types";
+import type { KernelVersion } from "../signerToEcdsaKernelSmartAccount";
+export declare const getNonceKeyWithEncoding: (accountVerion: KernelVersion<EntryPoint>, validatorAddress: Address, nonceKey?: bigint) => bigint;
+//# sourceMappingURL=getNonceKey.d.ts.map