@aa-sdk/ethers 4.0.0-alpha.9 → 4.0.0-beta.1

package/dist/esm/account-signer.d.ts

@@ -4,16 +4,186 @@ import type { Deferrable } from "@ethersproject/properties";
 import { type TransactionRequest, type TransactionResponse } from "@ethersproject/providers";
 import { type Transport } from "viem";
 import { EthersProviderAdapter } from "./provider-adapter.js";
+/**
+ * Implementation of the ethers Signer interface to use with Smart Contract Accounts
+ */
 export declare class AccountSigner<TAccount extends SmartContractAccount = SmartContractAccount, TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>> extends Signer {
     provider: EthersProviderAdapter;
     readonly account: TAccount;
     sendUserOperation: (args: UserOperationCallData | BatchUserOperationCallData, overrides?: UserOperationOverrides<TEntryPointVersion>) => Promise<import("@aa-sdk/core").SendUserOperationResult<keyof import("@aa-sdk/core").EntryPointRegistryBase<unknown>>>;
     waitForUserOperationTransaction: (args: import("@aa-sdk/core").WaitForUserOperationTxParameters) => Promise<`0x${string}`>;
+    /**
+     * Creates a new AccountSigner with the given ethers Provider and Smart Contract Account
+     *
+     * @example
+     * ```ts
+     * import { AccountSigner, EthersProviderAdapter } from "@aa-sdk/ethers";
+     * import { LocalAccountSigner } from "@aa-sdk/core";
+     * import { sepolia } from "@account-kit/infra";
+     * import { createLightAccount } from "@account-kit/smart-contracts";
+     * import { http } from "viem";
+     *
+     * const account = await createLightAccount({
+     *  transport: http("https://rpc.testnet.aepps.com"),
+     *  chain: sepolia,
+     *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+     * });
+     *
+     * const provider = new EthersProviderAdapter();
+     * const signer = new AccountSigner(provider, account);
+     * ```
+     *
+     * @template {SmartContractAccount} TAccount the type of the smart contract account
+     * @param {EthersProviderAdapter} provider the ethers provider to use
+     * @param {TAccount} account the smart contract account that will be used to sign user ops and send them
+     */
     constructor(provider: EthersProviderAdapter, account: TAccount);
-    getAddress(): Promise<string>;
+    /**
+     * Returns the account address if the account exists.
+     *
+     * @example
+     * ```ts
+     * import { AccountSigner, EthersProviderAdapter } from "@aa-sdk/ethers";
+     * import { LocalAccountSigner } from "@aa-sdk/core";
+     * import { sepolia } from "@account-kit/infra";
+     * import { createLightAccount } from "@account-kit/smart-contracts";
+     * import { http } from "viem";
+     *
+     * const account = await createLightAccount({
+     *  transport: http("https://rpc.testnet.aepps.com"),
+     *  chain: sepolia,
+     *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+     * });
+     *
+     * const provider = new EthersProviderAdapter();
+     * const signer = new AccountSigner(provider, account);
+     *
+     * const address = await signer.getAddress();
+     * ```
+     *
+     * @returns {Promise<string>} a promise that resolves to the account address
+     * @throws {AccountNotFoundError} if the account is not found
+     */ getAddress(): Promise<string>;
+    /**
+     * Signs a message using the associated account.
+     *
+     * @example
+     * ```ts
+     * import { AccountSigner, EthersProviderAdapter } from "@aa-sdk/ethers";
+     * import { LocalAccountSigner } from "@aa-sdk/core";
+     * import { sepolia } from "@account-kit/infra";
+     * import { createLightAccount } from "@account-kit/smart-contracts";
+     * import { http } from "viem";
+     *
+     * const account = await createLightAccount({
+     *  transport: http("https://rpc.testnet.aepps.com"),
+     *  chain: sepolia,
+     *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+     * });
+     *
+     * const provider = new EthersProviderAdapter();
+     * const signer = new AccountSigner(provider, account);
+     *
+     * const message = await signer.signMessage("hello");
+     * ```
+     *
+     * @param {string | Uint8Array} message the message to be signed
+     * @returns {Promise<string>} a promise that resolves to the signed message
+     * @throws {AccountNotFoundError} if the account is not found
+     */
     signMessage(message: string | Uint8Array): Promise<string>;
+    /**
+     * Sends a transaction using the account provider and returns the transaction response.
+     *
+     * @example
+     * ```ts
+     * import { AccountSigner, EthersProviderAdapter } from "@aa-sdk/ethers";
+     * import { LocalAccountSigner } from "@aa-sdk/core";
+     * import { sepolia } from "@account-kit/infra";
+     * import { createLightAccount } from "@account-kit/smart-contracts";
+     * import { http } from "viem";
+     *
+     * const account = await createLightAccount({
+     *  transport: http("https://rpc.testnet.aepps.com"),
+     *  chain: sepolia,
+     *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+     * });
+     *
+     * const provider = new EthersProviderAdapter();
+     * const signer = new AccountSigner(provider, account);
+     *
+     * const tx = await signer.sendTransaction({
+     *  to: "0x1234567890123456789012345678901234567890",
+     *  value: "0x0",
+     *  data: "0x",
+     * });
+     * ```
+     *
+     * @param {Deferrable<TransactionRequest>} transaction the transaction request to be sent
+     * @returns {Promise<TransactionResponse>} a promise that resolves to the transaction response
+     * @throws {AccountNotFoundError} if the account is not found in the provider
+     */
     sendTransaction(transaction: Deferrable<TransactionRequest>): Promise<TransactionResponse>;
+    /**
+     * Throws an error indicating that transaction signing is not supported and advises to use `sendUserOperation` instead.
+     *
+     * @param {Deferrable<TransactionRequest>} _transaction The transaction request
+     * @throws {Error} Will always throw an error indicating transaction signing is unsupported
+     */
     signTransaction(_transaction: Deferrable<TransactionRequest>): Promise<string>;
+    /**
+     * Retrieves the BundlerClient instance from the provider.
+     *
+     * @example
+     * ```ts
+     * import { AccountSigner, EthersProviderAdapter } from "@aa-sdk/ethers";
+     * import { LocalAccountSigner } from "@aa-sdk/core";
+     * import { sepolia } from "@account-kit/infra";
+     * import { createLightAccount } from "@account-kit/smart-contracts";
+     * import { http } from "viem";
+     *
+     * const account = await createLightAccount({
+     *  transport: http("https://rpc.testnet.aepps.com"),
+     *  chain: sepolia,
+     *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+     * });
+     *
+     * const provider = new EthersProviderAdapter();
+     * const signer = new AccountSigner(provider, account);
+     *
+     * const bundler = signer.getBundlerClient();
+     * ```
+     *
+     * @returns {BundlerClient<Transport>} The BundlerClient instance
+     */
     getBundlerClient(): BundlerClient<Transport>;
+    /**
+     * Sets the provider for the account signer and returns the updated account signer instance.
+     * Note: this is not necessary since the Provider is required by the constructor. This is useful
+     * if you want to change the provider after the account signer has been created.
+     *
+     * @example
+     * ```ts
+     * import { AccountSigner, EthersProviderAdapter } from "@aa-sdk/ethers";
+     * import { LocalAccountSigner } from "@aa-sdk/core";
+     * import { sepolia } from "@account-kit/infra";
+     * import { createLightAccount } from "@account-kit/smart-contracts";
+     * import { http } from "viem";
+     *
+     * const account = await createLightAccount({
+     *  transport: http("https://rpc.testnet.aepps.com"),
+     *  chain: sepolia,
+     *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+     * });
+     *
+     * const provider = new EthersProviderAdapter();
+     * const signer = new AccountSigner(provider, account);
+     *
+     * signer.connect(provider);
+     * ```
+     *
+     * @param {EthersProviderAdapter} provider the provider to be set for the account signer
+     * @returns {AccountSigner<TAccount>} the updated account signer instance
+     */
     connect(provider: EthersProviderAdapter): AccountSigner<TAccount>;
 }

package/dist/esm/account-signer.js

@@ -10,7 +10,35 @@ const hexlifyOptional = (value) => {
     }
     return hexlify(value);
 };
+/**
+ * Implementation of the ethers Signer interface to use with Smart Contract Accounts
+ */
 export class AccountSigner extends Signer {
+    /**
+     * Creates a new AccountSigner with the given ethers Provider and Smart Contract Account
+     *
+     * @example
+     * ```ts
+     * import { AccountSigner, EthersProviderAdapter } from "@aa-sdk/ethers";
+     * import { LocalAccountSigner } from "@aa-sdk/core";
+     * import { sepolia } from "@account-kit/infra";
+     * import { createLightAccount } from "@account-kit/smart-contracts";
+     * import { http } from "viem";
+     *
+     * const account = await createLightAccount({
+     *  transport: http("https://rpc.testnet.aepps.com"),
+     *  chain: sepolia,
+     *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+     * });
+     *
+     * const provider = new EthersProviderAdapter();
+     * const signer = new AccountSigner(provider, account);
+     * ```
+     *
+     * @template {SmartContractAccount} TAccount the type of the smart contract account
+     * @param {EthersProviderAdapter} provider the ethers provider to use
+     * @param {TAccount} account the smart contract account that will be used to sign user ops and send them
+     */
     constructor(provider, account) {
         super();
         Object.defineProperty(this, "provider", {
@@ -46,12 +74,64 @@ export class AccountSigner extends Signer {
         this.waitForUserOperationTransaction =
             this.provider.accountProvider.waitForUserOperationTransaction.bind(this.provider.accountProvider);
     }
-    async getAddress() {
+    /**
+     * Returns the account address if the account exists.
+     *
+     * @example
+     * ```ts
+     * import { AccountSigner, EthersProviderAdapter } from "@aa-sdk/ethers";
+     * import { LocalAccountSigner } from "@aa-sdk/core";
+     * import { sepolia } from "@account-kit/infra";
+     * import { createLightAccount } from "@account-kit/smart-contracts";
+     * import { http } from "viem";
+     *
+     * const account = await createLightAccount({
+     *  transport: http("https://rpc.testnet.aepps.com"),
+     *  chain: sepolia,
+     *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+     * });
+     *
+     * const provider = new EthersProviderAdapter();
+     * const signer = new AccountSigner(provider, account);
+     *
+     * const address = await signer.getAddress();
+     * ```
+     *
+     * @returns {Promise<string>} a promise that resolves to the account address
+     * @throws {AccountNotFoundError} if the account is not found
+     */ async getAddress() {
         if (!this.account) {
             throw new AccountNotFoundError();
         }
         return this.account.address;
     }
+    /**
+     * Signs a message using the associated account.
+     *
+     * @example
+     * ```ts
+     * import { AccountSigner, EthersProviderAdapter } from "@aa-sdk/ethers";
+     * import { LocalAccountSigner } from "@aa-sdk/core";
+     * import { sepolia } from "@account-kit/infra";
+     * import { createLightAccount } from "@account-kit/smart-contracts";
+     * import { http } from "viem";
+     *
+     * const account = await createLightAccount({
+     *  transport: http("https://rpc.testnet.aepps.com"),
+     *  chain: sepolia,
+     *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+     * });
+     *
+     * const provider = new EthersProviderAdapter();
+     * const signer = new AccountSigner(provider, account);
+     *
+     * const message = await signer.signMessage("hello");
+     * ```
+     *
+     * @param {string | Uint8Array} message the message to be signed
+     * @returns {Promise<string>} a promise that resolves to the signed message
+     * @throws {AccountNotFoundError} if the account is not found
+     */
     signMessage(message) {
         if (!this.account) {
             throw new AccountNotFoundError();
@@ -62,6 +142,37 @@ export class AccountSigner extends Signer {
                 : { raw: isHex(message) ? toBytes(message) : message },
         });
     }
+    /**
+     * Sends a transaction using the account provider and returns the transaction response.
+     *
+     * @example
+     * ```ts
+     * import { AccountSigner, EthersProviderAdapter } from "@aa-sdk/ethers";
+     * import { LocalAccountSigner } from "@aa-sdk/core";
+     * import { sepolia } from "@account-kit/infra";
+     * import { createLightAccount } from "@account-kit/smart-contracts";
+     * import { http } from "viem";
+     *
+     * const account = await createLightAccount({
+     *  transport: http("https://rpc.testnet.aepps.com"),
+     *  chain: sepolia,
+     *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+     * });
+     *
+     * const provider = new EthersProviderAdapter();
+     * const signer = new AccountSigner(provider, account);
+     *
+     * const tx = await signer.sendTransaction({
+     *  to: "0x1234567890123456789012345678901234567890",
+     *  value: "0x0",
+     *  data: "0x",
+     * });
+     * ```
+     *
+     * @param {Deferrable<TransactionRequest>} transaction the transaction request to be sent
+     * @returns {Promise<TransactionResponse>} a promise that resolves to the transaction response
+     * @throws {AccountNotFoundError} if the account is not found in the provider
+     */
     async sendTransaction(transaction) {
         if (!this.provider.accountProvider.account || !this.account) {
             throw new AccountNotFoundError();
@@ -75,12 +186,71 @@ export class AccountSigner extends Signer {
         });
         return this.provider.getTransaction(txHash);
     }
+    /**
+     * Throws an error indicating that transaction signing is not supported and advises to use `sendUserOperation` instead.
+     *
+     * @param {Deferrable<TransactionRequest>} _transaction The transaction request
+     * @throws {Error} Will always throw an error indicating transaction signing is unsupported
+     */
     signTransaction(_transaction) {
         throw new Error("Transaction signing is not supported, use sendUserOperation instead");
     }
+    /**
+     * Retrieves the BundlerClient instance from the provider.
+     *
+     * @example
+     * ```ts
+     * import { AccountSigner, EthersProviderAdapter } from "@aa-sdk/ethers";
+     * import { LocalAccountSigner } from "@aa-sdk/core";
+     * import { sepolia } from "@account-kit/infra";
+     * import { createLightAccount } from "@account-kit/smart-contracts";
+     * import { http } from "viem";
+     *
+     * const account = await createLightAccount({
+     *  transport: http("https://rpc.testnet.aepps.com"),
+     *  chain: sepolia,
+     *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+     * });
+     *
+     * const provider = new EthersProviderAdapter();
+     * const signer = new AccountSigner(provider, account);
+     *
+     * const bundler = signer.getBundlerClient();
+     * ```
+     *
+     * @returns {BundlerClient<Transport>} The BundlerClient instance
+     */
     getBundlerClient() {
         return this.provider.getBundlerClient();
     }
+    /**
+     * Sets the provider for the account signer and returns the updated account signer instance.
+     * Note: this is not necessary since the Provider is required by the constructor. This is useful
+     * if you want to change the provider after the account signer has been created.
+     *
+     * @example
+     * ```ts
+     * import { AccountSigner, EthersProviderAdapter } from "@aa-sdk/ethers";
+     * import { LocalAccountSigner } from "@aa-sdk/core";
+     * import { sepolia } from "@account-kit/infra";
+     * import { createLightAccount } from "@account-kit/smart-contracts";
+     * import { http } from "viem";
+     *
+     * const account = await createLightAccount({
+     *  transport: http("https://rpc.testnet.aepps.com"),
+     *  chain: sepolia,
+     *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+     * });
+     *
+     * const provider = new EthersProviderAdapter();
+     * const signer = new AccountSigner(provider, account);
+     *
+     * signer.connect(provider);
+     * ```
+     *
+     * @param {EthersProviderAdapter} provider the provider to be set for the account signer
+     * @returns {AccountSigner<TAccount>} the updated account signer instance
+     */
     connect(provider) {
         this.provider = provider;
         return this;

package/dist/esm/account-signer.js.map

@@ -1 +1 @@
-{"version":3,"file":"account-signer.js","sourceRoot":"","sources":["../../src/account-signer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,iBAAiB,GAOlB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AACxD,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAE/C,OAAO,EAGN,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAkB,MAAM,MAAM,CAAC;AACtD,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,MAAM,eAAe,GAAG,CAAC,KAAU,EAA6B,EAAE;IAChE,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;QAClB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO,OAAO,CAAC,KAAK,CAAkB,CAAC;AACzC,CAAC,CAAC;AAKF,MAAM,OAAO,aAGX,SAAQ,MAAM;IA+Bd,YAAmB,QAA+B,EAAE,OAAiB;QACnE,KAAK,EAAE,CAAC;QADE;;;;mBAAO,QAAQ;WAAuB;QA9BzC;;;;;WAAkB;QAE3B;;;;;WAAkB;QAClB;;;;;WAAgC;QA6B9B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QAEvB,IAAI,CAAC,iBAAiB,GAAG,CACvB,IAAwD,EACxD,SAAsD,EACtD,EAAE,CACF,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,iBAAiB,CAAC;YAC9C,EAAE,EAAE,IAAI;YACR,OAAO;YACP,SAAS;SACV,CAAC,CAAC;QAEL,IAAI,CAAC,+BAA+B;YAClC,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,+BAA+B,CAAC,IAAI,CAChE,IAAI,CAAC,QAAQ,CAAC,eAAe,CAC9B,CAAC;IACN,CAAC;IA2BG,KAAK,CAAC,UAAU;QAClB,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YAClB,MAAM,IAAI,oBAAoB,EAAE,CAAC;QACnC,CAAC;QAED,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;IAC9B,CAAC;IA6BD,WAAW,CAAC,OAA4B;QACtC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YAClB,MAAM,IAAI,oBAAoB,EAAE,CAAC;QACnC,CAAC;QAED,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC;YAC9B,OAAO,EACL,OAAO,OAAO,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;gBAC5C,CAAC,CAAC,OAAO;gBACT,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE;SAC3D,CAAC,CAAC;IACL,CAAC;IAiCD,KAAK,CAAC,eAAe,CACnB,WAA2C;QAE3C,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YAC5D,MAAM,IAAI,oBAAoB,EAAE,CAAC;QACnC,CAAC;QAED,MAAM,QAAQ,GAAG,MAAM,iBAAiB,CAAC,WAAW,CAAC,CAAC;QACtD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,eAAe,CAAC;YACjE,EAAE,EAAE,QAAQ,CAAC,EAA+B;YAC5C,IAAI,EAAE,eAAe,CAAC,QAAQ,CAAC,IAAI,CAAC;YACpC,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,KAAK;YAC1C,OAAO,EAAE,IAAI,CAAC,OAAO;SACtB,CAAC,CAAC;QAEH,OAAO,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IAC9C,CAAC;IAQD,eAAe,CACb,YAA4C;QAE5C,MAAM,IAAI,KAAK,CACb,qEAAqE,CACtE,CAAC;IACJ,CAAC;IA2BD,gBAAgB;QACd,OAAO,IAAI,CAAC,QAAQ,CAAC,gBAAgB,EAAE,CAAC;IAC1C,CAAC;IA8BD,OAAO,CAAC,QAA+B;QACrC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QAEzB,OAAO,IAAI,CAAC;IACd,CAAC;CACF","sourcesContent":["import {\n  AccountNotFoundError,\n  resolveProperties,\n  type BatchUserOperationCallData,\n  type BundlerClient,\n  type GetEntryPointFromAccount,\n  type SmartContractAccount,\n  type UserOperationCallData,\n  type UserOperationOverrides,\n} from \"@aa-sdk/core\";\nimport { Signer } from \"@ethersproject/abstract-signer\";\nimport { hexlify } from \"@ethersproject/bytes\";\nimport type { Deferrable } from \"@ethersproject/properties\";\nimport {\n  type TransactionRequest,\n  type TransactionResponse,\n} from \"@ethersproject/providers\";\nimport { isHex, toBytes, type Transport } from \"viem\";\nimport { EthersProviderAdapter } from \"./provider-adapter.js\";\n\nconst hexlifyOptional = (value: any): `0x${string}` | undefined => {\n  if (value == null) {\n    return undefined;\n  }\n\n  return hexlify(value) as `0x${string}`;\n};\n\n/**\n * Implementation of the ethers Signer interface to use with Smart Contract Accounts\n */\nexport class AccountSigner<\n  TAccount extends SmartContractAccount = SmartContractAccount,\n  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>\n> extends Signer {\n  readonly account: TAccount;\n\n  sendUserOperation;\n  waitForUserOperationTransaction;\n\n  /**\n   * Creates a new AccountSigner with the given ethers Provider and Smart Contract Account\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   * import { http } from \"viem\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter();\n   * const signer = new AccountSigner(provider, account);\n   * ```\n   *\n   * @template {SmartContractAccount} TAccount the type of the smart contract account\n   * @param {EthersProviderAdapter} provider the ethers provider to use\n   * @param {TAccount} account the smart contract account that will be used to sign user ops and send them\n   */\n  constructor(public provider: EthersProviderAdapter, account: TAccount) {\n    super();\n    this.account = account;\n\n    this.sendUserOperation = (\n      args: UserOperationCallData | BatchUserOperationCallData,\n      overrides?: UserOperationOverrides<TEntryPointVersion>\n    ) =>\n      this.provider.accountProvider.sendUserOperation({\n        uo: args,\n        account,\n        overrides,\n      });\n\n    this.waitForUserOperationTransaction =\n      this.provider.accountProvider.waitForUserOperationTransaction.bind(\n        this.provider.accountProvider\n      );\n  }\n\n  /**\n   * Returns the account address if the account exists.\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   * import { http } from \"viem\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter();\n   * const signer = new AccountSigner(provider, account);\n   *\n   * const address = await signer.getAddress();\n   * ```\n   *\n   * @returns {Promise<string>} a promise that resolves to the account address\n   * @throws {AccountNotFoundError} if the account is not found\n   */ async getAddress(): Promise<string> {\n    if (!this.account) {\n      throw new AccountNotFoundError();\n    }\n\n    return this.account.address;\n  }\n\n  /**\n   * Signs a message using the associated account.\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   * import { http } from \"viem\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter();\n   * const signer = new AccountSigner(provider, account);\n   *\n   * const message = await signer.signMessage(\"hello\");\n   * ```\n   *\n   * @param {string | Uint8Array} message the message to be signed\n   * @returns {Promise<string>} a promise that resolves to the signed message\n   * @throws {AccountNotFoundError} if the account is not found\n   */\n  signMessage(message: string | Uint8Array): Promise<string> {\n    if (!this.account) {\n      throw new AccountNotFoundError();\n    }\n\n    return this.account.signMessage({\n      message:\n        typeof message === \"string\" && !isHex(message)\n          ? message\n          : { raw: isHex(message) ? toBytes(message) : message },\n    });\n  }\n\n  /**\n   * Sends a transaction using the account provider and returns the transaction response.\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   * import { http } from \"viem\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter();\n   * const signer = new AccountSigner(provider, account);\n   *\n   * const tx = await signer.sendTransaction({\n   *  to: \"0x1234567890123456789012345678901234567890\",\n   *  value: \"0x0\",\n   *  data: \"0x\",\n   * });\n   * ```\n   *\n   * @param {Deferrable<TransactionRequest>} transaction the transaction request to be sent\n   * @returns {Promise<TransactionResponse>} a promise that resolves to the transaction response\n   * @throws {AccountNotFoundError} if the account is not found in the provider\n   */\n  async sendTransaction(\n    transaction: Deferrable<TransactionRequest>\n  ): Promise<TransactionResponse> {\n    if (!this.provider.accountProvider.account || !this.account) {\n      throw new AccountNotFoundError();\n    }\n\n    const resolved = await resolveProperties(transaction);\n    const txHash = await this.provider.accountProvider.sendTransaction({\n      to: resolved.to as `0x${string}` | undefined,\n      data: hexlifyOptional(resolved.data),\n      chain: this.provider.accountProvider.chain,\n      account: this.account,\n    });\n\n    return this.provider.getTransaction(txHash);\n  }\n\n  /**\n   * Throws an error indicating that transaction signing is not supported and advises to use `sendUserOperation` instead.\n   *\n   * @param {Deferrable<TransactionRequest>} _transaction The transaction request\n   * @throws {Error} Will always throw an error indicating transaction signing is unsupported\n   */\n  signTransaction(\n    _transaction: Deferrable<TransactionRequest>\n  ): Promise<string> {\n    throw new Error(\n      \"Transaction signing is not supported, use sendUserOperation instead\"\n    );\n  }\n\n  /**\n   * Retrieves the BundlerClient instance from the provider.\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   * import { http } from \"viem\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter();\n   * const signer = new AccountSigner(provider, account);\n   *\n   * const bundler = signer.getBundlerClient();\n   * ```\n   *\n   * @returns {BundlerClient<Transport>} The BundlerClient instance\n   */\n  getBundlerClient(): BundlerClient<Transport> {\n    return this.provider.getBundlerClient();\n  }\n\n  /**\n   * Sets the provider for the account signer and returns the updated account signer instance.\n   * Note: this is not necessary since the Provider is required by the constructor. This is useful\n   * if you want to change the provider after the account signer has been created.\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   * import { http } from \"viem\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter();\n   * const signer = new AccountSigner(provider, account);\n   *\n   * signer.connect(provider);\n   * ```\n   *\n   * @param {EthersProviderAdapter} provider the provider to be set for the account signer\n   * @returns {AccountSigner<TAccount>} the updated account signer instance\n   */\n  connect(provider: EthersProviderAdapter): AccountSigner<TAccount> {\n    this.provider = provider;\n\n    return this;\n  }\n}\n"]}
+{"version":3,"file":"account-signer.js","sourceRoot":"","sources":["../../src/account-signer.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AccountNotFoundError,\n  resolveProperties,\n  type BatchUserOperationCallData,\n  type BundlerClient,\n  type GetEntryPointFromAccount,\n  type SmartContractAccount,\n  type UserOperationCallData,\n  type UserOperationOverrides,\n} from \"@aa-sdk/core\";\nimport { Signer } from \"@ethersproject/abstract-signer\";\nimport { hexlify } from \"@ethersproject/bytes\";\nimport type { Deferrable } from \"@ethersproject/properties\";\nimport {\n  type TransactionRequest,\n  type TransactionResponse,\n} from \"@ethersproject/providers\";\nimport { isHex, toBytes, type Transport } from \"viem\";\nimport { EthersProviderAdapter } from \"./provider-adapter.js\";\n\nconst hexlifyOptional = (value: any): `0x${string}` | undefined => {\n  if (value == null) {\n    return undefined;\n  }\n\n  return hexlify(value) as `0x${string}`;\n};\n\n/**\n * Implementation of the ethers Signer interface to use with Smart Contract Accounts\n */\nexport class AccountSigner<\n  TAccount extends SmartContractAccount = SmartContractAccount,\n  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>\n> extends Signer {\n  readonly account: TAccount;\n\n  sendUserOperation;\n  waitForUserOperationTransaction;\n\n  /**\n   * Creates a new AccountSigner with the given ethers Provider and Smart Contract Account\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   * import { http } from \"viem\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter();\n   * const signer = new AccountSigner(provider, account);\n   * ```\n   *\n   * @template {SmartContractAccount} TAccount the type of the smart contract account\n   * @param {EthersProviderAdapter} provider the ethers provider to use\n   * @param {TAccount} account the smart contract account that will be used to sign user ops and send them\n   */\n  constructor(public provider: EthersProviderAdapter, account: TAccount) {\n    super();\n    this.account = account;\n\n    this.sendUserOperation = (\n      args: UserOperationCallData | BatchUserOperationCallData,\n      overrides?: UserOperationOverrides<TEntryPointVersion>\n    ) =>\n      this.provider.accountProvider.sendUserOperation({\n        uo: args,\n        account,\n        overrides,\n      });\n\n    this.waitForUserOperationTransaction =\n      this.provider.accountProvider.waitForUserOperationTransaction.bind(\n        this.provider.accountProvider\n      );\n  }\n\n  /**\n   * Returns the account address if the account exists.\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   * import { http } from \"viem\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter();\n   * const signer = new AccountSigner(provider, account);\n   *\n   * const address = await signer.getAddress();\n   * ```\n   *\n   * @returns {Promise<string>} a promise that resolves to the account address\n   * @throws {AccountNotFoundError} if the account is not found\n   */ async getAddress(): Promise<string> {\n    if (!this.account) {\n      throw new AccountNotFoundError();\n    }\n\n    return this.account.address;\n  }\n\n  /**\n   * Signs a message using the associated account.\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   * import { http } from \"viem\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter();\n   * const signer = new AccountSigner(provider, account);\n   *\n   * const message = await signer.signMessage(\"hello\");\n   * ```\n   *\n   * @param {string | Uint8Array} message the message to be signed\n   * @returns {Promise<string>} a promise that resolves to the signed message\n   * @throws {AccountNotFoundError} if the account is not found\n   */\n  signMessage(message: string | Uint8Array): Promise<string> {\n    if (!this.account) {\n      throw new AccountNotFoundError();\n    }\n\n    return this.account.signMessage({\n      message:\n        typeof message === \"string\" && !isHex(message)\n          ? message\n          : { raw: isHex(message) ? toBytes(message) : message },\n    });\n  }\n\n  /**\n   * Sends a transaction using the account provider and returns the transaction response.\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   * import { http } from \"viem\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter();\n   * const signer = new AccountSigner(provider, account);\n   *\n   * const tx = await signer.sendTransaction({\n   *  to: \"0x1234567890123456789012345678901234567890\",\n   *  value: \"0x0\",\n   *  data: \"0x\",\n   * });\n   * ```\n   *\n   * @param {Deferrable<TransactionRequest>} transaction the transaction request to be sent\n   * @returns {Promise<TransactionResponse>} a promise that resolves to the transaction response\n   * @throws {AccountNotFoundError} if the account is not found in the provider\n   */\n  async sendTransaction(\n    transaction: Deferrable<TransactionRequest>\n  ): Promise<TransactionResponse> {\n    if (!this.provider.accountProvider.account || !this.account) {\n      throw new AccountNotFoundError();\n    }\n\n    const resolved = await resolveProperties(transaction);\n    const txHash = await this.provider.accountProvider.sendTransaction({\n      to: resolved.to as `0x${string}` | undefined,\n      data: hexlifyOptional(resolved.data),\n      chain: this.provider.accountProvider.chain,\n      account: this.account,\n    });\n\n    return this.provider.getTransaction(txHash);\n  }\n\n  /**\n   * Throws an error indicating that transaction signing is not supported and advises to use `sendUserOperation` instead.\n   *\n   * @param {Deferrable<TransactionRequest>} _transaction The transaction request\n   * @throws {Error} Will always throw an error indicating transaction signing is unsupported\n   */\n  signTransaction(\n    _transaction: Deferrable<TransactionRequest>\n  ): Promise<string> {\n    throw new Error(\n      \"Transaction signing is not supported, use sendUserOperation instead\"\n    );\n  }\n\n  /**\n   * Retrieves the BundlerClient instance from the provider.\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   * import { http } from \"viem\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter();\n   * const signer = new AccountSigner(provider, account);\n   *\n   * const bundler = signer.getBundlerClient();\n   * ```\n   *\n   * @returns {BundlerClient<Transport>} The BundlerClient instance\n   */\n  getBundlerClient(): BundlerClient<Transport> {\n    return this.provider.getBundlerClient();\n  }\n\n  /**\n   * Sets the provider for the account signer and returns the updated account signer instance.\n   * Note: this is not necessary since the Provider is required by the constructor. This is useful\n   * if you want to change the provider after the account signer has been created.\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   * import { http } from \"viem\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter();\n   * const signer = new AccountSigner(provider, account);\n   *\n   * signer.connect(provider);\n   * ```\n   *\n   * @param {EthersProviderAdapter} provider the provider to be set for the account signer\n   * @returns {AccountSigner<TAccount>} the updated account signer instance\n   */\n  connect(provider: EthersProviderAdapter): AccountSigner<TAccount> {\n    this.provider = provider;\n\n    return this;\n  }\n}\n"]}

package/dist/esm/provider-adapter.d.ts

@@ -3,11 +3,85 @@ import { JsonRpcProvider } from "@ethersproject/providers";
 import { type Chain, type Transport } from "viem";
 import { AccountSigner } from "./account-signer.js";
 import type { EthersProviderAdapterOpts } from "./types.js";
+/** Lightweight Adapter for SmtAccountProvider to enable Signer Creation */
 export declare class EthersProviderAdapter extends JsonRpcProvider {
     readonly accountProvider: SmartAccountClient;
+    /**
+     * Configures and initializes the account provider based on the given options.
+     *
+     * @example
+     * ```ts
+     * import { AccountSigner, EthersProviderAdapter } from "@aa-sdk/ethers";
+     * import { LocalAccountSigner } from "@aa-sdk/core";
+     * import { sepolia } from "@account-kit/infra";
+     * import { createLightAccount } from "@account-kit/smart-contracts";
+     *
+     * const account = await createLightAccount({
+     *  transport: http("https://rpc.testnet.aepps.com"),
+     *  chain: sepolia,
+     *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+     * });
+     *
+     * const provider = new EthersProviderAdapter({
+     *  account,
+     *  chain: sepolia,
+     *  rpcProvider: "https://eth-sepolia.g.alchemy.com/v2/your-api-key"
+     * });
+     * ```
+     *
+     * @param {EthersProviderAdapterOpts} opts The options for setting up the ethers provider adapter
+     */
     constructor(opts: EthersProviderAdapterOpts);
+    /**
+     * Rewrites the send method to use the account provider's EIP-1193
+     * compliant request method
+     *
+     * @param {any} method - the RPC method to call
+     * @param {any[]} params - the params required by the RPC method
+     * @returns {Promise<any>} the result of the RPC call
+     */
     send(method: any, params: any[]): Promise<any>;
+    /**
+     * Connects the Provider to an Account and returns a Signer
+     *
+     * @param {SmartContractAccount} account - the account to connect to
+     * @returns {AccountSigner} an AccountSigner that can be used to sign and send user operations
+     */
     connectToAccount<TAccount extends SmartContractAccount>(account: TAccount): AccountSigner<TAccount>;
+    /**
+     * Creates and returns a BundlerClient using the existing account provider's transport and chain.
+     *
+     * @example
+     * ```ts
+     * import { AccountSigner, EthersProviderAdapter } from "@aa-sdk/ethers";
+     * import { LocalAccountSigner } from "@aa-sdk/core";
+     * import { sepolia } from "@account-kit/infra";
+     * import { createLightAccount } from "@account-kit/smart-contracts";
+     *
+     * const account = await createLightAccount({
+     *  transport: http("https://rpc.testnet.aepps.com"),
+     *  chain: sepolia,
+     *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+     * });
+     *
+     * const provider = new EthersProviderAdapter({
+     *  account,
+     *  chain: sepolia,
+     *  rpcProvider: "https://eth-sepolia.g.alchemy.com/v2/your-api-key"
+     * });
+     *
+     * const bundlerClient = provider.getBundlerClient();
+     * ```
+     *
+     * @returns {BundlerClient<Transport>} A bundler client configured with the existing account provider.
+     */
     getBundlerClient(): BundlerClient<Transport>;
+    /**
+     * Creates an instance of EthersProviderAdapter from an ethers.js JsonRpcProvider.
+     *
+     * @param {JsonRpcProvider} provider the ethers JSON RPC provider to convert
+     * @param {Chain} chain the chain to connect to
+     * @returns {EthersProviderAdapter} an instance of EthersProviderAdapter
+     */
     static fromEthersProvider(provider: JsonRpcProvider, chain: Chain): EthersProviderAdapter;
 }

package/dist/esm/provider-adapter.js

@@ -2,7 +2,33 @@ import { createBundlerClientFromExisting, createSmartAccountClient, } from "@aa-
 import { JsonRpcProvider } from "@ethersproject/providers";
 import { createPublicClient, custom, http, } from "viem";
 import { AccountSigner } from "./account-signer.js";
+/** Lightweight Adapter for SmtAccountProvider to enable Signer Creation */
 export class EthersProviderAdapter extends JsonRpcProvider {
+    /**
+     * Configures and initializes the account provider based on the given options.
+     *
+     * @example
+     * ```ts
+     * import { AccountSigner, EthersProviderAdapter } from "@aa-sdk/ethers";
+     * import { LocalAccountSigner } from "@aa-sdk/core";
+     * import { sepolia } from "@account-kit/infra";
+     * import { createLightAccount } from "@account-kit/smart-contracts";
+     *
+     * const account = await createLightAccount({
+     *  transport: http("https://rpc.testnet.aepps.com"),
+     *  chain: sepolia,
+     *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+     * });
+     *
+     * const provider = new EthersProviderAdapter({
+     *  account,
+     *  chain: sepolia,
+     *  rpcProvider: "https://eth-sepolia.g.alchemy.com/v2/your-api-key"
+     * });
+     * ```
+     *
+     * @param {EthersProviderAdapterOpts} opts The options for setting up the ethers provider adapter
+     */
     constructor(opts) {
         super();
         Object.defineProperty(this, "accountProvider", {
@@ -32,18 +58,67 @@ export class EthersProviderAdapter extends JsonRpcProvider {
             }
         }
     }
+    /**
+     * Rewrites the send method to use the account provider's EIP-1193
+     * compliant request method
+     *
+     * @param {any} method - the RPC method to call
+     * @param {any[]} params - the params required by the RPC method
+     * @returns {Promise<any>} the result of the RPC call
+     */
     send(method, params) {
+        // @ts-expect-error - viem is strongly typed on the request methods, but ethers is not
         return this.accountProvider.request({ method, params });
     }
+    /**
+     * Connects the Provider to an Account and returns a Signer
+     *
+     * @param {SmartContractAccount} account - the account to connect to
+     * @returns {AccountSigner} an AccountSigner that can be used to sign and send user operations
+     */
     connectToAccount(account) {
         return new AccountSigner(this, account);
     }
+    /**
+     * Creates and returns a BundlerClient using the existing account provider's transport and chain.
+     *
+     * @example
+     * ```ts
+     * import { AccountSigner, EthersProviderAdapter } from "@aa-sdk/ethers";
+     * import { LocalAccountSigner } from "@aa-sdk/core";
+     * import { sepolia } from "@account-kit/infra";
+     * import { createLightAccount } from "@account-kit/smart-contracts";
+     *
+     * const account = await createLightAccount({
+     *  transport: http("https://rpc.testnet.aepps.com"),
+     *  chain: sepolia,
+     *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+     * });
+     *
+     * const provider = new EthersProviderAdapter({
+     *  account,
+     *  chain: sepolia,
+     *  rpcProvider: "https://eth-sepolia.g.alchemy.com/v2/your-api-key"
+     * });
+     *
+     * const bundlerClient = provider.getBundlerClient();
+     * ```
+     *
+     * @returns {BundlerClient<Transport>} A bundler client configured with the existing account provider.
+     */
     getBundlerClient() {
         return createBundlerClientFromExisting(createPublicClient({
             transport: custom(this.accountProvider.transport),
             chain: this.accountProvider.chain,
         }));
     }
+    /**
+     * Creates an instance of EthersProviderAdapter from an ethers.js JsonRpcProvider.
+     *
+     * @param {JsonRpcProvider} provider the ethers JSON RPC provider to convert
+     * @param {Chain} chain the chain to connect to
+     * @returns {EthersProviderAdapter} an instance of EthersProviderAdapter
+     */
     static fromEthersProvider(provider, chain) {
         return new EthersProviderAdapter({
             rpcProvider: provider.connection.url,

package/dist/esm/provider-adapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"provider-adapter.js","sourceRoot":"","sources":["../../src/provider-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,+BAA+B,EAC/B,wBAAwB,GAIzB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EACL,kBAAkB,EAClB,MAAM,EACN,IAAI,GAGL,MAAM,MAAM,CAAC;AACd,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIpD,MAAM,OAAO,qBAAsB,SAAQ,eAAe;IA4BxD,YAAY,IAA+B;QACzC,KAAK,EAAE,CAAC;QA5BD;;;;;WAAoC;QA6B3C,IAAI,iBAAiB,IAAI,IAAI,EAAE,CAAC;YAC9B,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC;QAC9C,CAAC;aAAM,CAAC;YACN,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC;YAEvB,IAAI,OAAO,IAAI,CAAC,WAAW,KAAK,QAAQ,EAAE,CAAC;gBACzC,IAAI,CAAC,eAAe,GAAG,wBAAwB,CAAC;oBAC9C,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC;oBACjC,KAAK;oBACL,OAAO,EAAE,IAAI,CAAC,OAAO;iBACtB,CAAC,CAAC;YACL,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,eAAe,GAAG,wBAAwB,CAAC;oBAC9C,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;oBAC7C,KAAK;oBACL,OAAO,EAAE,IAAI,CAAC,OAAO;iBACtB,CAAC,CAAC;YACL,CAAC;QACH,CAAC;IACH,CAAC;IAUD,IAAI,CAAC,MAAW,EAAE,MAAa;QAE7B,OAAO,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC1D,CAAC;IAQD,gBAAgB,CACd,OAAiB;QAEjB,OAAO,IAAI,aAAa,CAAW,IAAI,EAAE,OAAO,CAAC,CAAC;IACpD,CAAC;IA6BD,gBAAgB;QACd,OAAO,+BAA+B,CACpC,kBAAkB,CAAC;YACjB,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC;YACjD,KAAK,EAAE,IAAI,CAAC,eAAe,CAAC,KAAM;SACnC,CAAC,CACH,CAAC;IACJ,CAAC;IASD,MAAM,CAAC,kBAAkB,CACvB,QAAyB,EACzB,KAAY;QAEZ,OAAO,IAAI,qBAAqB,CAAC;YAC/B,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG;YACpC,KAAK;SACN,CAAC,CAAC;IACL,CAAC;CACF","sourcesContent":["import {\n  createBundlerClientFromExisting,\n  createSmartAccountClient,\n  type BundlerClient,\n  type SmartAccountClient,\n  type SmartContractAccount,\n} from \"@aa-sdk/core\";\nimport { JsonRpcProvider } from \"@ethersproject/providers\";\nimport {\n  createPublicClient,\n  custom,\n  http,\n  type Chain,\n  type Transport,\n} from \"viem\";\nimport { AccountSigner } from \"./account-signer.js\";\nimport type { EthersProviderAdapterOpts } from \"./types.js\";\n\n/** Lightweight Adapter for SmtAccountProvider to enable Signer Creation */\nexport class EthersProviderAdapter extends JsonRpcProvider {\n  readonly accountProvider: SmartAccountClient;\n\n  /**\n   * Configures and initializes the account provider based on the given options.\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter({\n   *  account,\n   *  chain: sepolia,\n   *  rpcProvider: \"https://eth-sepolia.g.alchemy.com/v2/your-api-key\"\n   * });\n   * ```\n   *\n   * @param {EthersProviderAdapterOpts} opts The options for setting up the ethers provider adapter\n   */\n  constructor(opts: EthersProviderAdapterOpts) {\n    super();\n    if (\"accountProvider\" in opts) {\n      this.accountProvider = opts.accountProvider;\n    } else {\n      const { chain } = opts;\n\n      if (typeof opts.rpcProvider === \"string\") {\n        this.accountProvider = createSmartAccountClient({\n          transport: http(opts.rpcProvider),\n          chain,\n          account: opts.account,\n        });\n      } else {\n        this.accountProvider = createSmartAccountClient({\n          transport: custom(opts.rpcProvider.transport),\n          chain,\n          account: opts.account,\n        });\n      }\n    }\n  }\n\n  /**\n   * Rewrites the send method to use the account provider's EIP-1193\n   * compliant request method\n   *\n   * @param {any} method - the RPC method to call\n   * @param {any[]} params - the params required by the RPC method\n   * @returns {Promise<any>} the result of the RPC call\n   */\n  send(method: any, params: any[]): Promise<any> {\n    // @ts-expect-error - viem is strongly typed on the request methods, but ethers is not\n    return this.accountProvider.request({ method, params });\n  }\n\n  /**\n   * Connects the Provider to an Account and returns a Signer\n   *\n   * @param {SmartContractAccount} account - the account to connect to\n   * @returns {AccountSigner} an AccountSigner that can be used to sign and send user operations\n   */\n  connectToAccount<TAccount extends SmartContractAccount>(\n    account: TAccount\n  ): AccountSigner<TAccount> {\n    return new AccountSigner<TAccount>(this, account);\n  }\n\n  /**\n   * Creates and returns a BundlerClient using the existing account provider's transport and chain.\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter({\n   *  account,\n   *  chain: sepolia,\n   *  rpcProvider: \"https://eth-sepolia.g.alchemy.com/v2/your-api-key\"\n   * });\n   *\n   * const bundlerClient = provider.getBundlerClient();\n   * ```\n   *\n   * @returns {BundlerClient<Transport>} A bundler client configured with the existing account provider.\n   */\n  getBundlerClient(): BundlerClient<Transport> {\n    return createBundlerClientFromExisting(\n      createPublicClient({\n        transport: custom(this.accountProvider.transport),\n        chain: this.accountProvider.chain!,\n      })\n    );\n  }\n\n  /**\n   * Creates an instance of EthersProviderAdapter from an ethers.js JsonRpcProvider.\n   *\n   * @param {JsonRpcProvider} provider the ethers JSON RPC provider to convert\n   * @param {Chain} chain the chain to connect to\n   * @returns {EthersProviderAdapter} an instance of EthersProviderAdapter\n   */\n  static fromEthersProvider(\n    provider: JsonRpcProvider,\n    chain: Chain\n  ): EthersProviderAdapter {\n    return new EthersProviderAdapter({\n      rpcProvider: provider.connection.url,\n      chain,\n    });\n  }\n}\n"]}
+{"version":3,"file":"provider-adapter.js","sourceRoot":"","sources":["../../src/provider-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,+BAA+B,EAC/B,wBAAwB,GAIzB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EACL,kBAAkB,EAClB,MAAM,EACN,IAAI,GAGL,MAAM,MAAM,CAAC;AACd,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGpD,2EAA2E;AAC3E,MAAM,OAAO,qBAAsB,SAAQ,eAAe;IAGxD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,YAAY,IAA+B;QACzC,KAAK,EAAE,CAAC;QA5BD;;;;;WAAoC;QA6B3C,IAAI,iBAAiB,IAAI,IAAI,EAAE,CAAC;YAC9B,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC;QAC9C,CAAC;aAAM,CAAC;YACN,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC;YAEvB,IAAI,OAAO,IAAI,CAAC,WAAW,KAAK,QAAQ,EAAE,CAAC;gBACzC,IAAI,CAAC,eAAe,GAAG,wBAAwB,CAAC;oBAC9C,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC;oBACjC,KAAK;oBACL,OAAO,EAAE,IAAI,CAAC,OAAO;iBACtB,CAAC,CAAC;YACL,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,eAAe,GAAG,wBAAwB,CAAC;oBAC9C,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;oBAC7C,KAAK;oBACL,OAAO,EAAE,IAAI,CAAC,OAAO;iBACtB,CAAC,CAAC;YACL,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACH,IAAI,CAAC,MAAW,EAAE,MAAa;QAC7B,sFAAsF;QACtF,OAAO,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC1D,CAAC;IAED;;;;;OAKG;IACH,gBAAgB,CACd,OAAiB;QAEjB,OAAO,IAAI,aAAa,CAAW,IAAI,EAAE,OAAO,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,gBAAgB;QACd,OAAO,+BAA+B,CACpC,kBAAkB,CAAC;YACjB,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC;YACjD,KAAK,EAAE,IAAI,CAAC,eAAe,CAAC,KAAM;SACnC,CAAC,CACH,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,kBAAkB,CACvB,QAAyB,EACzB,KAAY;QAEZ,OAAO,IAAI,qBAAqB,CAAC;YAC/B,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG;YACpC,KAAK;SACN,CAAC,CAAC;IACL,CAAC;CACF","sourcesContent":["import {\n  createBundlerClientFromExisting,\n  createSmartAccountClient,\n  type BundlerClient,\n  type SmartAccountClient,\n  type SmartContractAccount,\n} from \"@aa-sdk/core\";\nimport { JsonRpcProvider } from \"@ethersproject/providers\";\nimport {\n  createPublicClient,\n  custom,\n  http,\n  type Chain,\n  type Transport,\n} from \"viem\";\nimport { AccountSigner } from \"./account-signer.js\";\nimport type { EthersProviderAdapterOpts } from \"./types.js\";\n\n/** Lightweight Adapter for SmtAccountProvider to enable Signer Creation */\nexport class EthersProviderAdapter extends JsonRpcProvider {\n  readonly accountProvider: SmartAccountClient;\n\n  /**\n   * Configures and initializes the account provider based on the given options.\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter({\n   *  account,\n   *  chain: sepolia,\n   *  rpcProvider: \"https://eth-sepolia.g.alchemy.com/v2/your-api-key\"\n   * });\n   * ```\n   *\n   * @param {EthersProviderAdapterOpts} opts The options for setting up the ethers provider adapter\n   */\n  constructor(opts: EthersProviderAdapterOpts) {\n    super();\n    if (\"accountProvider\" in opts) {\n      this.accountProvider = opts.accountProvider;\n    } else {\n      const { chain } = opts;\n\n      if (typeof opts.rpcProvider === \"string\") {\n        this.accountProvider = createSmartAccountClient({\n          transport: http(opts.rpcProvider),\n          chain,\n          account: opts.account,\n        });\n      } else {\n        this.accountProvider = createSmartAccountClient({\n          transport: custom(opts.rpcProvider.transport),\n          chain,\n          account: opts.account,\n        });\n      }\n    }\n  }\n\n  /**\n   * Rewrites the send method to use the account provider's EIP-1193\n   * compliant request method\n   *\n   * @param {any} method - the RPC method to call\n   * @param {any[]} params - the params required by the RPC method\n   * @returns {Promise<any>} the result of the RPC call\n   */\n  send(method: any, params: any[]): Promise<any> {\n    // @ts-expect-error - viem is strongly typed on the request methods, but ethers is not\n    return this.accountProvider.request({ method, params });\n  }\n\n  /**\n   * Connects the Provider to an Account and returns a Signer\n   *\n   * @param {SmartContractAccount} account - the account to connect to\n   * @returns {AccountSigner} an AccountSigner that can be used to sign and send user operations\n   */\n  connectToAccount<TAccount extends SmartContractAccount>(\n    account: TAccount\n  ): AccountSigner<TAccount> {\n    return new AccountSigner<TAccount>(this, account);\n  }\n\n  /**\n   * Creates and returns a BundlerClient using the existing account provider's transport and chain.\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter({\n   *  account,\n   *  chain: sepolia,\n   *  rpcProvider: \"https://eth-sepolia.g.alchemy.com/v2/your-api-key\"\n   * });\n   *\n   * const bundlerClient = provider.getBundlerClient();\n   * ```\n   *\n   * @returns {BundlerClient<Transport>} A bundler client configured with the existing account provider.\n   */\n  getBundlerClient(): BundlerClient<Transport> {\n    return createBundlerClientFromExisting(\n      createPublicClient({\n        transport: custom(this.accountProvider.transport),\n        chain: this.accountProvider.chain!,\n      })\n    );\n  }\n\n  /**\n   * Creates an instance of EthersProviderAdapter from an ethers.js JsonRpcProvider.\n   *\n   * @param {JsonRpcProvider} provider the ethers JSON RPC provider to convert\n   * @param {Chain} chain the chain to connect to\n   * @returns {EthersProviderAdapter} an instance of EthersProviderAdapter\n   */\n  static fromEthersProvider(\n    provider: JsonRpcProvider,\n    chain: Chain\n  ): EthersProviderAdapter {\n    return new EthersProviderAdapter({\n      rpcProvider: provider.connection.url,\n      chain,\n    });\n  }\n}\n"]}

package/dist/esm/utils.d.ts

@@ -1,5 +1,17 @@
 import type { SmartAccountSigner } from "@aa-sdk/core";
 import type { Signer } from "@ethersproject/abstract-signer";
 import { Wallet } from "@ethersproject/wallet";
+/**
+ * Converts a ethersjs Wallet to a SmartAccountSigner
+ *
+ * @param {Wallet} wallet - the Wallet to convert
+ * @returns {SmartAccountSigner<Wallet>} a signer that can be used to sign and send user operations
+ */
 export declare const convertWalletToAccountSigner: (wallet: Wallet) => SmartAccountSigner<Wallet>;
+/**
+ * Converts a ethers.js Signer to a SmartAccountSigner
+ *
+ * @param {Signer} signer - the Signer to convert
+ * @returns {SmartAccountSigner<Signer>} a signer that can be used to sign and send user operations
+ */
 export declare const convertEthersSignerToAccountSigner: (signer: Signer) => SmartAccountSigner<Signer>;

package/dist/esm/utils.js

@@ -1,4 +1,10 @@
 import { Wallet } from "@ethersproject/wallet";
+/**
+ * Converts a ethersjs Wallet to a SmartAccountSigner
+ *
+ * @param {Wallet} wallet - the Wallet to convert
+ * @returns {SmartAccountSigner<Wallet>} a signer that can be used to sign and send user operations
+ */
 export const convertWalletToAccountSigner = (wallet) => {
     return {
         inner: wallet,
@@ -6,10 +12,18 @@ export const convertWalletToAccountSigner = (wallet) => {
         getAddress: async () => Promise.resolve(wallet.address),
         signMessage: async (msg) => (await wallet.signMessage(typeof msg === "string" ? msg : msg.raw)),
         signTypedData: async (params) => {
-            return (await wallet._signTypedData(params.domain ?? {}, params.types, params.message));
+            return (await wallet._signTypedData(params.domain ?? {}, 
+            // @ts-expect-error: these params should line up due to the spec for this function
+            params.types, params.message));
         },
     };
 };
+/**
+ * Converts a ethers.js Signer to a SmartAccountSigner
+ *
+ * @param {Signer} signer - the Signer to convert
+ * @returns {SmartAccountSigner<Signer>} a signer that can be used to sign and send user operations
+ */
 export const convertEthersSignerToAccountSigner = (signer) => {
     return {
         inner: signer,

package/dist/esm/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAS/C,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAC1C,MAAc,EACc,EAAE;IAC9B,OAAO;QACL,KAAK,EAAE,MAAM;QACb,UAAU,EAAE,OAAO;QACnB,UAAU,EAAE,KAAK,IAAI,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,OAAwB,CAAC;QACxE,WAAW,EAAE,KAAK,EAAE,GAAoB,EAAE,EAAE,CAC1C,CAAC,MAAM,MAAM,CAAC,WAAW,CACvB,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CACxC,CAAkB;QACrB,aAAa,EAAE,KAAK,EAIlB,MAAqD,EACrD,EAAE;YACF,OAAO,CAAC,MAAM,MAAM,CAAC,cAAc,CACjC,MAAM,CAAC,MAAM,IAAI,EAAE,EAEnB,MAAM,CAAC,KAAK,EACZ,MAAM,CAAC,OAAO,CACf,CAAkB,CAAC;QACtB,CAAC;KACF,CAAC;AACJ,CAAC,CAAC;AAQF,MAAM,CAAC,MAAM,kCAAkC,GAAG,CAChD,MAAc,EACc,EAAE;IAC9B,OAAO;QACL,KAAK,EAAE,MAAM;QACb,UAAU,EAAE,UAAU;QACtB,UAAU,EAAE,KAAK,IAAI,EAAE,CAAC,MAAM,CAAC,UAAU,EAAsB;QAC/D,WAAW,EAAE,KAAK,EAAE,GAAoB,EAAE,EAAE,CAC1C,CAAC,MAAM,MAAM,CAAC,WAAW,CACvB,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CACxC,CAAkB;QACrB,aAAa,EAAE,KAAK,EAIlB,OAAsD,EACtD,EAAE;YACF,MAAM,IAAI,KAAK,CACb,+DAA+D,CAChE,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC,CAAC","sourcesContent":["import type { Address, SmartAccountSigner } from \"@aa-sdk/core\";\nimport type { Signer } from \"@ethersproject/abstract-signer\";\nimport { Wallet } from \"@ethersproject/wallet\";\nimport type { SignableMessage, TypedData, TypedDataDefinition } from \"viem\";\n\n/**\n * Converts a ethersjs Wallet to a SmartAccountSigner\n *\n * @param {Wallet} wallet - the Wallet to convert\n * @returns {SmartAccountSigner<Wallet>} a signer that can be used to sign and send user operations\n */\nexport const convertWalletToAccountSigner = (\n  wallet: Wallet\n): SmartAccountSigner<Wallet> => {\n  return {\n    inner: wallet,\n    signerType: \"local\",\n    getAddress: async () => Promise.resolve(wallet.address as `0x${string}`),\n    signMessage: async (msg: SignableMessage) =>\n      (await wallet.signMessage(\n        typeof msg === \"string\" ? msg : msg.raw\n      )) as `0x${string}`,\n    signTypedData: async <\n      const TTypedData extends TypedData | { [key: string]: unknown },\n      TPrimaryType extends string = string\n    >(\n      params: TypedDataDefinition<TTypedData, TPrimaryType>\n    ) => {\n      return (await wallet._signTypedData(\n        params.domain ?? {},\n        // @ts-expect-error: these params should line up due to the spec for this function\n        params.types,\n        params.message\n      )) as `0x${string}`;\n    },\n  };\n};\n\n/**\n * Converts a ethers.js Signer to a SmartAccountSigner\n *\n * @param {Signer} signer - the Signer to convert\n * @returns {SmartAccountSigner<Signer>} a signer that can be used to sign and send user operations\n */\nexport const convertEthersSignerToAccountSigner = (\n  signer: Signer\n): SmartAccountSigner<Signer> => {\n  return {\n    inner: signer,\n    signerType: \"json-rpc\",\n    getAddress: async () => signer.getAddress() as Promise<Address>,\n    signMessage: async (msg: SignableMessage) =>\n      (await signer.signMessage(\n        typeof msg === \"string\" ? msg : msg.raw\n      )) as `0x${string}`,\n    signTypedData: async <\n      const TTypedData extends TypedData | { [key: string]: unknown },\n      TPrimaryType extends string = string\n    >(\n      _params: TypedDataDefinition<TTypedData, TPrimaryType>\n    ) => {\n      throw new Error(\n        \"signTypedData is not supported for ethers signers; use Wallet\"\n      );\n    },\n  };\n};\n"]}
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAG/C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAC1C,MAAc,EACc,EAAE;IAC9B,OAAO;QACL,KAAK,EAAE,MAAM;QACb,UAAU,EAAE,OAAO;QACnB,UAAU,EAAE,KAAK,IAAI,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,OAAwB,CAAC;QACxE,WAAW,EAAE,KAAK,EAAE,GAAoB,EAAE,EAAE,CAC1C,CAAC,MAAM,MAAM,CAAC,WAAW,CACvB,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CACxC,CAAkB;QACrB,aAAa,EAAE,KAAK,EAIlB,MAAqD,EACrD,EAAE;YACF,OAAO,CAAC,MAAM,MAAM,CAAC,cAAc,CACjC,MAAM,CAAC,MAAM,IAAI,EAAE;YACnB,kFAAkF;YAClF,MAAM,CAAC,KAAK,EACZ,MAAM,CAAC,OAAO,CACf,CAAkB,CAAC;QACtB,CAAC;KACF,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,kCAAkC,GAAG,CAChD,MAAc,EACc,EAAE;IAC9B,OAAO;QACL,KAAK,EAAE,MAAM;QACb,UAAU,EAAE,UAAU;QACtB,UAAU,EAAE,KAAK,IAAI,EAAE,CAAC,MAAM,CAAC,UAAU,EAAsB;QAC/D,WAAW,EAAE,KAAK,EAAE,GAAoB,EAAE,EAAE,CAC1C,CAAC,MAAM,MAAM,CAAC,WAAW,CACvB,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CACxC,CAAkB;QACrB,aAAa,EAAE,KAAK,EAIlB,OAAsD,EACtD,EAAE;YACF,MAAM,IAAI,KAAK,CACb,+DAA+D,CAChE,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC,CAAC","sourcesContent":["import type { Address, SmartAccountSigner } from \"@aa-sdk/core\";\nimport type { Signer } from \"@ethersproject/abstract-signer\";\nimport { Wallet } from \"@ethersproject/wallet\";\nimport type { SignableMessage, TypedData, TypedDataDefinition } from \"viem\";\n\n/**\n * Converts a ethersjs Wallet to a SmartAccountSigner\n *\n * @param {Wallet} wallet - the Wallet to convert\n * @returns {SmartAccountSigner<Wallet>} a signer that can be used to sign and send user operations\n */\nexport const convertWalletToAccountSigner = (\n  wallet: Wallet\n): SmartAccountSigner<Wallet> => {\n  return {\n    inner: wallet,\n    signerType: \"local\",\n    getAddress: async () => Promise.resolve(wallet.address as `0x${string}`),\n    signMessage: async (msg: SignableMessage) =>\n      (await wallet.signMessage(\n        typeof msg === \"string\" ? msg : msg.raw\n      )) as `0x${string}`,\n    signTypedData: async <\n      const TTypedData extends TypedData | { [key: string]: unknown },\n      TPrimaryType extends keyof TTypedData | \"EIP712Domain\" = keyof TTypedData\n    >(\n      params: TypedDataDefinition<TTypedData, TPrimaryType>\n    ) => {\n      return (await wallet._signTypedData(\n        params.domain ?? {},\n        // @ts-expect-error: these params should line up due to the spec for this function\n        params.types,\n        params.message\n      )) as `0x${string}`;\n    },\n  };\n};\n\n/**\n * Converts a ethers.js Signer to a SmartAccountSigner\n *\n * @param {Signer} signer - the Signer to convert\n * @returns {SmartAccountSigner<Signer>} a signer that can be used to sign and send user operations\n */\nexport const convertEthersSignerToAccountSigner = (\n  signer: Signer\n): SmartAccountSigner<Signer> => {\n  return {\n    inner: signer,\n    signerType: \"json-rpc\",\n    getAddress: async () => signer.getAddress() as Promise<Address>,\n    signMessage: async (msg: SignableMessage) =>\n      (await signer.signMessage(\n        typeof msg === \"string\" ? msg : msg.raw\n      )) as `0x${string}`,\n    signTypedData: async <\n      const TTypedData extends TypedData | { [key: string]: unknown },\n      TPrimaryType extends keyof TTypedData | \"EIP712Domain\" = keyof TTypedData\n    >(\n      _params: TypedDataDefinition<TTypedData, TPrimaryType>\n    ) => {\n      throw new Error(\n        \"signTypedData is not supported for ethers signers; use Wallet\"\n      );\n    },\n  };\n};\n"]}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@aa-sdk/ethers",
   "license": "MIT",
-  "version": "4.0.0-alpha.9",
+  "version": "4.0.0-beta.1",
   "description": "Ethers.js wrapper for @aa-sdk/core",
   "author": "Alchemy",
   "type": "module",
-  "main": "./dist/cjs/index.js",
+  "main": "./dist/esm/index.js",
   "module": "./dist/esm/index.js",
   "types": "./dist/types/index.d.ts",
   "typings": "./dist/types/index.d.ts",
@@ -23,7 +23,7 @@
     ".": {
       "types": "./dist/types/index.d.ts",
       "import": "./dist/esm/index.js",
-      "default": "./dist/cjs/index.js"
+      "default": "./dist/esm/index.js"
     },
     "./package.json": "./package.json"
   },
@@ -32,10 +32,9 @@
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "build": "yarn clean && yarn build:cjs && yarn build:esm && yarn build:types",
-    "build:cjs": "tsc --project tsconfig.build.json --module commonjs --outDir ./dist/cjs --removeComments --verbatimModuleSyntax false && echo > ./dist/cjs/package.json '{\"type\":\"commonjs\"}'",
-    "build:esm": "tsc --project tsconfig.build.json --module es2020 --outDir ./dist/esm --removeComments && echo > ./dist/esm/package.json '{\"type\":\"module\"}'",
-    "build:types": "tsc --project tsconfig.build.json --module esnext --declarationDir ./dist/types --emitDeclarationOnly --declaration --declarationMap",
+    "build": "yarn clean && yarn build:esm && yarn build:types",
+    "build:esm": "tsc --project tsconfig.build.json --outDir ./dist/esm",
+    "build:types": "tsc --project tsconfig.build.json --declarationDir ./dist/types --emitDeclarationOnly --declaration --declarationMap",
     "docs:gen": "npx ak-docgen generate --in ./src/index.ts --out ../../site/pages/reference/aa-sdk/ethers",
     "clean": "rm -rf ./dist",
     "test": "vitest",
@@ -43,7 +42,7 @@
     "test:run-e2e": "vitest run --config vitest.config.e2e.ts"
   },
   "devDependencies": {
-    "@account-kit/smart-contracts": "4.0.0-alpha.4",
+    "@account-kit/smart-contracts": "^4.0.0-beta.1",
     "alchemy-sdk": "^3.0.0",
     "dotenv": "^16.0.3",
     "typescript": "^5.0.4",
@@ -51,7 +50,7 @@
     "vitest": "^2.0.4"
   },
   "dependencies": {
-    "@aa-sdk/core": "^4.0.0-alpha.9",
+    "@aa-sdk/core": "^4.0.0-beta.1",
     "@ethersproject/abi": "^5.7.0",
     "@ethersproject/abstract-signer": "^5.7.0",
     "@ethersproject/bytes": "^5.7.0",
@@ -59,11 +58,10 @@
     "@ethersproject/hash": "^5.7.0",
     "@ethersproject/keccak256": "^5.7.0",
     "@ethersproject/providers": "^5.7.2",
-    "@ethersproject/wallet": "^5.7.0",
-    "viem": "2.8.6"
+    "@ethersproject/wallet": "^5.7.0"
   },
   "peerDependencies": {
-    "viem": "2.8.6"
+    "viem": "^2.20.0"
   },
   "repository": {
     "type": "git",
@@ -72,5 +70,5 @@
   "bugs": {
     "url": "https://github.com/alchemyplatform/aa-sdk/issues"
   },
-  "gitHead": "9616a7ab7dc70320b508e5674bb61ef0723a8b59"
+  "gitHead": "5e0db61aaa6b55e7da3e04d00822392b946b3882"
 }

package/src/utils.ts

@@ -22,7 +22,7 @@ export const convertWalletToAccountSigner = (
       )) as `0x${string}`,
     signTypedData: async <
       const TTypedData extends TypedData | { [key: string]: unknown },
-      TPrimaryType extends string = string
+      TPrimaryType extends keyof TTypedData | "EIP712Domain" = keyof TTypedData
     >(
       params: TypedDataDefinition<TTypedData, TPrimaryType>
     ) => {
@@ -55,7 +55,7 @@ export const convertEthersSignerToAccountSigner = (
       )) as `0x${string}`,
     signTypedData: async <
       const TTypedData extends TypedData | { [key: string]: unknown },
-      TPrimaryType extends string = string
+      TPrimaryType extends keyof TTypedData | "EIP712Domain" = keyof TTypedData
     >(
       _params: TypedDataDefinition<TTypedData, TPrimaryType>
     ) => {

package/dist/cjs/account-signer.d.ts

@@ -1,19 +0,0 @@
-import { type BatchUserOperationCallData, type BundlerClient, type GetEntryPointFromAccount, type SmartContractAccount, type UserOperationCallData, type UserOperationOverrides } from "@aa-sdk/core";
-import { Signer } from "@ethersproject/abstract-signer";
-import type { Deferrable } from "@ethersproject/properties";
-import { type TransactionRequest, type TransactionResponse } from "@ethersproject/providers";
-import { type Transport } from "viem";
-import { EthersProviderAdapter } from "./provider-adapter.js";
-export declare class AccountSigner<TAccount extends SmartContractAccount = SmartContractAccount, TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>> extends Signer {
-    provider: EthersProviderAdapter;
-    readonly account: TAccount;
-    sendUserOperation: (args: UserOperationCallData | BatchUserOperationCallData, overrides?: UserOperationOverrides<TEntryPointVersion>) => Promise<import("@aa-sdk/core").SendUserOperationResult<keyof import("@aa-sdk/core").EntryPointRegistryBase<unknown>>>;
-    waitForUserOperationTransaction: (args: import("@aa-sdk/core").WaitForUserOperationTxParameters) => Promise<`0x${string}`>;
-    constructor(provider: EthersProviderAdapter, account: TAccount);
-    getAddress(): Promise<string>;
-    signMessage(message: string | Uint8Array): Promise<string>;
-    sendTransaction(transaction: Deferrable<TransactionRequest>): Promise<TransactionResponse>;
-    signTransaction(_transaction: Deferrable<TransactionRequest>): Promise<string>;
-    getBundlerClient(): BundlerClient<Transport>;
-    connect(provider: EthersProviderAdapter): AccountSigner<TAccount>;
-}

package/dist/cjs/account-signer.js

@@ -1,91 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AccountSigner = void 0;
-const core_1 = require("@aa-sdk/core");
-const abstract_signer_1 = require("@ethersproject/abstract-signer");
-const bytes_1 = require("@ethersproject/bytes");
-const viem_1 = require("viem");
-const hexlifyOptional = (value) => {
-    if (value == null) {
-        return undefined;
-    }
-    return (0, bytes_1.hexlify)(value);
-};
-class AccountSigner extends abstract_signer_1.Signer {
-    constructor(provider, account) {
-        super();
-        Object.defineProperty(this, "provider", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: provider
-        });
-        Object.defineProperty(this, "account", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "sendUserOperation", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "waitForUserOperationTransaction", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.account = account;
-        this.sendUserOperation = (args, overrides) => this.provider.accountProvider.sendUserOperation({
-            uo: args,
-            account,
-            overrides,
-        });
-        this.waitForUserOperationTransaction =
-            this.provider.accountProvider.waitForUserOperationTransaction.bind(this.provider.accountProvider);
-    }
-    async getAddress() {
-        if (!this.account) {
-            throw new core_1.AccountNotFoundError();
-        }
-        return this.account.address;
-    }
-    signMessage(message) {
-        if (!this.account) {
-            throw new core_1.AccountNotFoundError();
-        }
-        return this.account.signMessage({
-            message: typeof message === "string" && !(0, viem_1.isHex)(message)
-                ? message
-                : { raw: (0, viem_1.isHex)(message) ? (0, viem_1.toBytes)(message) : message },
-        });
-    }
-    async sendTransaction(transaction) {
-        if (!this.provider.accountProvider.account || !this.account) {
-            throw new core_1.AccountNotFoundError();
-        }
-        const resolved = await (0, core_1.resolveProperties)(transaction);
-        const txHash = await this.provider.accountProvider.sendTransaction({
-            to: resolved.to,
-            data: hexlifyOptional(resolved.data),
-            chain: this.provider.accountProvider.chain,
-            account: this.account,
-        });
-        return this.provider.getTransaction(txHash);
-    }
-    signTransaction(_transaction) {
-        throw new Error("Transaction signing is not supported, use sendUserOperation instead");
-    }
-    getBundlerClient() {
-        return this.provider.getBundlerClient();
-    }
-    connect(provider) {
-        this.provider = provider;
-        return this;
-    }
-}
-exports.AccountSigner = AccountSigner;
-//# sourceMappingURL=account-signer.js.map

package/dist/cjs/account-signer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"account-signer.js","sourceRoot":"","sources":["../../src/account-signer.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AccountNotFoundError,\n  resolveProperties,\n  type BatchUserOperationCallData,\n  type BundlerClient,\n  type GetEntryPointFromAccount,\n  type SmartContractAccount,\n  type UserOperationCallData,\n  type UserOperationOverrides,\n} from \"@aa-sdk/core\";\nimport { Signer } from \"@ethersproject/abstract-signer\";\nimport { hexlify } from \"@ethersproject/bytes\";\nimport type { Deferrable } from \"@ethersproject/properties\";\nimport {\n  type TransactionRequest,\n  type TransactionResponse,\n} from \"@ethersproject/providers\";\nimport { isHex, toBytes, type Transport } from \"viem\";\nimport { EthersProviderAdapter } from \"./provider-adapter.js\";\n\nconst hexlifyOptional = (value: any): `0x${string}` | undefined => {\n  if (value == null) {\n    return undefined;\n  }\n\n  return hexlify(value) as `0x${string}`;\n};\n\n/**\n * Implementation of the ethers Signer interface to use with Smart Contract Accounts\n */\nexport class AccountSigner<\n  TAccount extends SmartContractAccount = SmartContractAccount,\n  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>\n> extends Signer {\n  readonly account: TAccount;\n\n  sendUserOperation;\n  waitForUserOperationTransaction;\n\n  /**\n   * Creates a new AccountSigner with the given ethers Provider and Smart Contract Account\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   * import { http } from \"viem\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter();\n   * const signer = new AccountSigner(provider, account);\n   * ```\n   *\n   * @template {SmartContractAccount} TAccount the type of the smart contract account\n   * @param {EthersProviderAdapter} provider the ethers provider to use\n   * @param {TAccount} account the smart contract account that will be used to sign user ops and send them\n   */\n  constructor(public provider: EthersProviderAdapter, account: TAccount) {\n    super();\n    this.account = account;\n\n    this.sendUserOperation = (\n      args: UserOperationCallData | BatchUserOperationCallData,\n      overrides?: UserOperationOverrides<TEntryPointVersion>\n    ) =>\n      this.provider.accountProvider.sendUserOperation({\n        uo: args,\n        account,\n        overrides,\n      });\n\n    this.waitForUserOperationTransaction =\n      this.provider.accountProvider.waitForUserOperationTransaction.bind(\n        this.provider.accountProvider\n      );\n  }\n\n  /**\n   * Returns the account address if the account exists.\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   * import { http } from \"viem\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter();\n   * const signer = new AccountSigner(provider, account);\n   *\n   * const address = await signer.getAddress();\n   * ```\n   *\n   * @returns {Promise<string>} a promise that resolves to the account address\n   * @throws {AccountNotFoundError} if the account is not found\n   */ async getAddress(): Promise<string> {\n    if (!this.account) {\n      throw new AccountNotFoundError();\n    }\n\n    return this.account.address;\n  }\n\n  /**\n   * Signs a message using the associated account.\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   * import { http } from \"viem\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter();\n   * const signer = new AccountSigner(provider, account);\n   *\n   * const message = await signer.signMessage(\"hello\");\n   * ```\n   *\n   * @param {string | Uint8Array} message the message to be signed\n   * @returns {Promise<string>} a promise that resolves to the signed message\n   * @throws {AccountNotFoundError} if the account is not found\n   */\n  signMessage(message: string | Uint8Array): Promise<string> {\n    if (!this.account) {\n      throw new AccountNotFoundError();\n    }\n\n    return this.account.signMessage({\n      message:\n        typeof message === \"string\" && !isHex(message)\n          ? message\n          : { raw: isHex(message) ? toBytes(message) : message },\n    });\n  }\n\n  /**\n   * Sends a transaction using the account provider and returns the transaction response.\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   * import { http } from \"viem\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter();\n   * const signer = new AccountSigner(provider, account);\n   *\n   * const tx = await signer.sendTransaction({\n   *  to: \"0x1234567890123456789012345678901234567890\",\n   *  value: \"0x0\",\n   *  data: \"0x\",\n   * });\n   * ```\n   *\n   * @param {Deferrable<TransactionRequest>} transaction the transaction request to be sent\n   * @returns {Promise<TransactionResponse>} a promise that resolves to the transaction response\n   * @throws {AccountNotFoundError} if the account is not found in the provider\n   */\n  async sendTransaction(\n    transaction: Deferrable<TransactionRequest>\n  ): Promise<TransactionResponse> {\n    if (!this.provider.accountProvider.account || !this.account) {\n      throw new AccountNotFoundError();\n    }\n\n    const resolved = await resolveProperties(transaction);\n    const txHash = await this.provider.accountProvider.sendTransaction({\n      to: resolved.to as `0x${string}` | undefined,\n      data: hexlifyOptional(resolved.data),\n      chain: this.provider.accountProvider.chain,\n      account: this.account,\n    });\n\n    return this.provider.getTransaction(txHash);\n  }\n\n  /**\n   * Throws an error indicating that transaction signing is not supported and advises to use `sendUserOperation` instead.\n   *\n   * @param {Deferrable<TransactionRequest>} _transaction The transaction request\n   * @throws {Error} Will always throw an error indicating transaction signing is unsupported\n   */\n  signTransaction(\n    _transaction: Deferrable<TransactionRequest>\n  ): Promise<string> {\n    throw new Error(\n      \"Transaction signing is not supported, use sendUserOperation instead\"\n    );\n  }\n\n  /**\n   * Retrieves the BundlerClient instance from the provider.\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   * import { http } from \"viem\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter();\n   * const signer = new AccountSigner(provider, account);\n   *\n   * const bundler = signer.getBundlerClient();\n   * ```\n   *\n   * @returns {BundlerClient<Transport>} The BundlerClient instance\n   */\n  getBundlerClient(): BundlerClient<Transport> {\n    return this.provider.getBundlerClient();\n  }\n\n  /**\n   * Sets the provider for the account signer and returns the updated account signer instance.\n   * Note: this is not necessary since the Provider is required by the constructor. This is useful\n   * if you want to change the provider after the account signer has been created.\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   * import { http } from \"viem\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter();\n   * const signer = new AccountSigner(provider, account);\n   *\n   * signer.connect(provider);\n   * ```\n   *\n   * @param {EthersProviderAdapter} provider the provider to be set for the account signer\n   * @returns {AccountSigner<TAccount>} the updated account signer instance\n   */\n  connect(provider: EthersProviderAdapter): AccountSigner<TAccount> {\n    this.provider = provider;\n\n    return this;\n  }\n}\n"]}

package/dist/cjs/index.d.ts

@@ -1,3 +0,0 @@
-export { AccountSigner } from "./account-signer.js";
-export { EthersProviderAdapter } from "./provider-adapter.js";
-export { convertEthersSignerToAccountSigner, convertWalletToAccountSigner, } from "./utils.js";

package/dist/cjs/index.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertWalletToAccountSigner = exports.convertEthersSignerToAccountSigner = exports.EthersProviderAdapter = exports.AccountSigner = void 0;
-var account_signer_js_1 = require("./account-signer.js");
-Object.defineProperty(exports, "AccountSigner", { enumerable: true, get: function () { return account_signer_js_1.AccountSigner; } });
-var provider_adapter_js_1 = require("./provider-adapter.js");
-Object.defineProperty(exports, "EthersProviderAdapter", { enumerable: true, get: function () { return provider_adapter_js_1.EthersProviderAdapter; } });
-var utils_js_1 = require("./utils.js");
-Object.defineProperty(exports, "convertEthersSignerToAccountSigner", { enumerable: true, get: function () { return utils_js_1.convertEthersSignerToAccountSigner; } });
-Object.defineProperty(exports, "convertWalletToAccountSigner", { enumerable: true, get: function () { return utils_js_1.convertWalletToAccountSigner; } });
-//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;AAAA,yDAAoD;AAA3C,kHAAA,aAAa,OAAA;AACtB,6DAA8D;AAArD,4HAAA,qBAAqB,OAAA;AAC9B,uCAGoB;AAFlB,8HAAA,kCAAkC,OAAA;AAClC,wHAAA,4BAA4B,OAAA","sourcesContent":["export { AccountSigner } from \"./account-signer.js\";\nexport { EthersProviderAdapter } from \"./provider-adapter.js\";\nexport {\n  convertEthersSignerToAccountSigner,\n  convertWalletToAccountSigner,\n} from \"./utils.js\";\n"]}

package/dist/cjs/package.json

@@ -1 +0,0 @@
-{"type":"commonjs"}

package/dist/cjs/provider-adapter.d.ts

@@ -1,13 +0,0 @@
-import { type BundlerClient, type SmartAccountClient, type SmartContractAccount } from "@aa-sdk/core";
-import { JsonRpcProvider } from "@ethersproject/providers";
-import { type Chain, type Transport } from "viem";
-import { AccountSigner } from "./account-signer.js";
-import type { EthersProviderAdapterOpts } from "./types.js";
-export declare class EthersProviderAdapter extends JsonRpcProvider {
-    readonly accountProvider: SmartAccountClient;
-    constructor(opts: EthersProviderAdapterOpts);
-    send(method: any, params: any[]): Promise<any>;
-    connectToAccount<TAccount extends SmartContractAccount>(account: TAccount): AccountSigner<TAccount>;
-    getBundlerClient(): BundlerClient<Transport>;
-    static fromEthersProvider(provider: JsonRpcProvider, chain: Chain): EthersProviderAdapter;
-}

package/dist/cjs/provider-adapter.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EthersProviderAdapter = void 0;
-const core_1 = require("@aa-sdk/core");
-const providers_1 = require("@ethersproject/providers");
-const viem_1 = require("viem");
-const account_signer_js_1 = require("./account-signer.js");
-class EthersProviderAdapter extends providers_1.JsonRpcProvider {
-    constructor(opts) {
-        super();
-        Object.defineProperty(this, "accountProvider", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        if ("accountProvider" in opts) {
-            this.accountProvider = opts.accountProvider;
-        }
-        else {
-            const { chain } = opts;
-            if (typeof opts.rpcProvider === "string") {
-                this.accountProvider = (0, core_1.createSmartAccountClient)({
-                    transport: (0, viem_1.http)(opts.rpcProvider),
-                    chain,
-                    account: opts.account,
-                });
-            }
-            else {
-                this.accountProvider = (0, core_1.createSmartAccountClient)({
-                    transport: (0, viem_1.custom)(opts.rpcProvider.transport),
-                    chain,
-                    account: opts.account,
-                });
-            }
-        }
-    }
-    send(method, params) {
-        return this.accountProvider.request({ method, params });
-    }
-    connectToAccount(account) {
-        return new account_signer_js_1.AccountSigner(this, account);
-    }
-    getBundlerClient() {
-        return (0, core_1.createBundlerClientFromExisting)((0, viem_1.createPublicClient)({
-            transport: (0, viem_1.custom)(this.accountProvider.transport),
-            chain: this.accountProvider.chain,
-        }));
-    }
-    static fromEthersProvider(provider, chain) {
-        return new EthersProviderAdapter({
-            rpcProvider: provider.connection.url,
-            chain,
-        });
-    }
-}
-exports.EthersProviderAdapter = EthersProviderAdapter;
-//# sourceMappingURL=provider-adapter.js.map

package/dist/cjs/provider-adapter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"provider-adapter.js","sourceRoot":"","sources":["../../src/provider-adapter.ts"],"names":[],"mappings":";;;AAAA,uCAMsB;AACtB,wDAA2D;AAC3D,+BAMc;AACd,2DAAoD;AAIpD,MAAa,qBAAsB,SAAQ,2BAAe;IA4BxD,YAAY,IAA+B;QACzC,KAAK,EAAE,CAAC;QA5BD;;;;;WAAoC;QA6B3C,IAAI,iBAAiB,IAAI,IAAI,EAAE,CAAC;YAC9B,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC;QAC9C,CAAC;aAAM,CAAC;YACN,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC;YAEvB,IAAI,OAAO,IAAI,CAAC,WAAW,KAAK,QAAQ,EAAE,CAAC;gBACzC,IAAI,CAAC,eAAe,GAAG,IAAA,+BAAwB,EAAC;oBAC9C,SAAS,EAAE,IAAA,WAAI,EAAC,IAAI,CAAC,WAAW,CAAC;oBACjC,KAAK;oBACL,OAAO,EAAE,IAAI,CAAC,OAAO;iBACtB,CAAC,CAAC;YACL,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,eAAe,GAAG,IAAA,+BAAwB,EAAC;oBAC9C,SAAS,EAAE,IAAA,aAAM,EAAC,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;oBAC7C,KAAK;oBACL,OAAO,EAAE,IAAI,CAAC,OAAO;iBACtB,CAAC,CAAC;YACL,CAAC;QACH,CAAC;IACH,CAAC;IAUD,IAAI,CAAC,MAAW,EAAE,MAAa;QAE7B,OAAO,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC1D,CAAC;IAQD,gBAAgB,CACd,OAAiB;QAEjB,OAAO,IAAI,iCAAa,CAAW,IAAI,EAAE,OAAO,CAAC,CAAC;IACpD,CAAC;IA6BD,gBAAgB;QACd,OAAO,IAAA,sCAA+B,EACpC,IAAA,yBAAkB,EAAC;YACjB,SAAS,EAAE,IAAA,aAAM,EAAC,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC;YACjD,KAAK,EAAE,IAAI,CAAC,eAAe,CAAC,KAAM;SACnC,CAAC,CACH,CAAC;IACJ,CAAC;IASD,MAAM,CAAC,kBAAkB,CACvB,QAAyB,EACzB,KAAY;QAEZ,OAAO,IAAI,qBAAqB,CAAC;YAC/B,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG;YACpC,KAAK;SACN,CAAC,CAAC;IACL,CAAC;CACF;AAhID,sDAgIC","sourcesContent":["import {\n  createBundlerClientFromExisting,\n  createSmartAccountClient,\n  type BundlerClient,\n  type SmartAccountClient,\n  type SmartContractAccount,\n} from \"@aa-sdk/core\";\nimport { JsonRpcProvider } from \"@ethersproject/providers\";\nimport {\n  createPublicClient,\n  custom,\n  http,\n  type Chain,\n  type Transport,\n} from \"viem\";\nimport { AccountSigner } from \"./account-signer.js\";\nimport type { EthersProviderAdapterOpts } from \"./types.js\";\n\n/** Lightweight Adapter for SmtAccountProvider to enable Signer Creation */\nexport class EthersProviderAdapter extends JsonRpcProvider {\n  readonly accountProvider: SmartAccountClient;\n\n  /**\n   * Configures and initializes the account provider based on the given options.\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter({\n   *  account,\n   *  chain: sepolia,\n   *  rpcProvider: \"https://eth-sepolia.g.alchemy.com/v2/your-api-key\"\n   * });\n   * ```\n   *\n   * @param {EthersProviderAdapterOpts} opts The options for setting up the ethers provider adapter\n   */\n  constructor(opts: EthersProviderAdapterOpts) {\n    super();\n    if (\"accountProvider\" in opts) {\n      this.accountProvider = opts.accountProvider;\n    } else {\n      const { chain } = opts;\n\n      if (typeof opts.rpcProvider === \"string\") {\n        this.accountProvider = createSmartAccountClient({\n          transport: http(opts.rpcProvider),\n          chain,\n          account: opts.account,\n        });\n      } else {\n        this.accountProvider = createSmartAccountClient({\n          transport: custom(opts.rpcProvider.transport),\n          chain,\n          account: opts.account,\n        });\n      }\n    }\n  }\n\n  /**\n   * Rewrites the send method to use the account provider's EIP-1193\n   * compliant request method\n   *\n   * @param {any} method - the RPC method to call\n   * @param {any[]} params - the params required by the RPC method\n   * @returns {Promise<any>} the result of the RPC call\n   */\n  send(method: any, params: any[]): Promise<any> {\n    // @ts-expect-error - viem is strongly typed on the request methods, but ethers is not\n    return this.accountProvider.request({ method, params });\n  }\n\n  /**\n   * Connects the Provider to an Account and returns a Signer\n   *\n   * @param {SmartContractAccount} account - the account to connect to\n   * @returns {AccountSigner} an AccountSigner that can be used to sign and send user operations\n   */\n  connectToAccount<TAccount extends SmartContractAccount>(\n    account: TAccount\n  ): AccountSigner<TAccount> {\n    return new AccountSigner<TAccount>(this, account);\n  }\n\n  /**\n   * Creates and returns a BundlerClient using the existing account provider's transport and chain.\n   *\n   * @example\n   * ```ts\n   * import { AccountSigner, EthersProviderAdapter } from \"@aa-sdk/ethers\";\n   * import { LocalAccountSigner } from \"@aa-sdk/core\";\n   * import { sepolia } from \"@account-kit/infra\";\n   * import { createLightAccount } from \"@account-kit/smart-contracts\";\n   *\n   * const account = await createLightAccount({\n   *  transport: http(\"https://rpc.testnet.aepps.com\"),\n   *  chain: sepolia,\n   *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())\n   * });\n   *\n   * const provider = new EthersProviderAdapter({\n   *  account,\n   *  chain: sepolia,\n   *  rpcProvider: \"https://eth-sepolia.g.alchemy.com/v2/your-api-key\"\n   * });\n   *\n   * const bundlerClient = provider.getBundlerClient();\n   * ```\n   *\n   * @returns {BundlerClient<Transport>} A bundler client configured with the existing account provider.\n   */\n  getBundlerClient(): BundlerClient<Transport> {\n    return createBundlerClientFromExisting(\n      createPublicClient({\n        transport: custom(this.accountProvider.transport),\n        chain: this.accountProvider.chain!,\n      })\n    );\n  }\n\n  /**\n   * Creates an instance of EthersProviderAdapter from an ethers.js JsonRpcProvider.\n   *\n   * @param {JsonRpcProvider} provider the ethers JSON RPC provider to convert\n   * @param {Chain} chain the chain to connect to\n   * @returns {EthersProviderAdapter} an instance of EthersProviderAdapter\n   */\n  static fromEthersProvider(\n    provider: JsonRpcProvider,\n    chain: Chain\n  ): EthersProviderAdapter {\n    return new EthersProviderAdapter({\n      rpcProvider: provider.connection.url,\n      chain,\n    });\n  }\n}\n"]}

package/dist/cjs/types.d.ts

@@ -1,10 +0,0 @@
-import { type BundlerClient, type SmartAccountClient, type SmartContractAccount } from "@aa-sdk/core";
-import type { Chain, Transport } from "viem";
-export type EthersProviderAdapterOpts<TTransport extends Transport = Transport, TChain extends Chain = Chain, TAccount extends SmartContractAccount | undefined = SmartContractAccount | undefined> = {
-    account?: TAccount;
-} & ({
-    rpcProvider: string | BundlerClient<TTransport>;
-    chain: Chain;
-} | {
-    accountProvider: SmartAccountClient<TTransport, TChain, TAccount>;
-});

package/dist/cjs/types.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map

package/dist/cjs/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"","sourcesContent":["import {\n  type BundlerClient,\n  type SmartAccountClient,\n  type SmartContractAccount,\n} from \"@aa-sdk/core\";\nimport type { Chain, Transport } from \"viem\";\n\nexport type EthersProviderAdapterOpts<\n  TTransport extends Transport = Transport,\n  TChain extends Chain = Chain,\n  TAccount extends SmartContractAccount | undefined =\n    | SmartContractAccount\n    | undefined\n> = {\n  account?: TAccount;\n} & (\n  | {\n      rpcProvider: string | BundlerClient<TTransport>;\n      chain: Chain;\n    }\n  | {\n      accountProvider: SmartAccountClient<TTransport, TChain, TAccount>;\n    }\n);\n"]}

package/dist/cjs/utils.d.ts

@@ -1,5 +0,0 @@
-import type { SmartAccountSigner } from "@aa-sdk/core";
-import type { Signer } from "@ethersproject/abstract-signer";
-import { Wallet } from "@ethersproject/wallet";
-export declare const convertWalletToAccountSigner: (wallet: Wallet) => SmartAccountSigner<Wallet>;
-export declare const convertEthersSignerToAccountSigner: (signer: Signer) => SmartAccountSigner<Signer>;

package/dist/cjs/utils.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertEthersSignerToAccountSigner = exports.convertWalletToAccountSigner = void 0;
-const convertWalletToAccountSigner = (wallet) => {
-    return {
-        inner: wallet,
-        signerType: "local",
-        getAddress: async () => Promise.resolve(wallet.address),
-        signMessage: async (msg) => (await wallet.signMessage(typeof msg === "string" ? msg : msg.raw)),
-        signTypedData: async (params) => {
-            return (await wallet._signTypedData(params.domain ?? {}, params.types, params.message));
-        },
-    };
-};
-exports.convertWalletToAccountSigner = convertWalletToAccountSigner;
-const convertEthersSignerToAccountSigner = (signer) => {
-    return {
-        inner: signer,
-        signerType: "json-rpc",
-        getAddress: async () => signer.getAddress(),
-        signMessage: async (msg) => (await signer.signMessage(typeof msg === "string" ? msg : msg.raw)),
-        signTypedData: async (_params) => {
-            throw new Error("signTypedData is not supported for ethers signers; use Wallet");
-        },
-    };
-};
-exports.convertEthersSignerToAccountSigner = convertEthersSignerToAccountSigner;
-//# sourceMappingURL=utils.js.map

package/dist/cjs/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":";;;AAWO,MAAM,4BAA4B,GAAG,CAC1C,MAAc,EACc,EAAE;IAC9B,OAAO;QACL,KAAK,EAAE,MAAM;QACb,UAAU,EAAE,OAAO;QACnB,UAAU,EAAE,KAAK,IAAI,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,OAAwB,CAAC;QACxE,WAAW,EAAE,KAAK,EAAE,GAAoB,EAAE,EAAE,CAC1C,CAAC,MAAM,MAAM,CAAC,WAAW,CACvB,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CACxC,CAAkB;QACrB,aAAa,EAAE,KAAK,EAIlB,MAAqD,EACrD,EAAE;YACF,OAAO,CAAC,MAAM,MAAM,CAAC,cAAc,CACjC,MAAM,CAAC,MAAM,IAAI,EAAE,EAEnB,MAAM,CAAC,KAAK,EACZ,MAAM,CAAC,OAAO,CACf,CAAkB,CAAC;QACtB,CAAC;KACF,CAAC;AACJ,CAAC,CAAC;AAzBW,QAAA,4BAA4B,gCAyBvC;AAQK,MAAM,kCAAkC,GAAG,CAChD,MAAc,EACc,EAAE;IAC9B,OAAO;QACL,KAAK,EAAE,MAAM;QACb,UAAU,EAAE,UAAU;QACtB,UAAU,EAAE,KAAK,IAAI,EAAE,CAAC,MAAM,CAAC,UAAU,EAAsB;QAC/D,WAAW,EAAE,KAAK,EAAE,GAAoB,EAAE,EAAE,CAC1C,CAAC,MAAM,MAAM,CAAC,WAAW,CACvB,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CACxC,CAAkB;QACrB,aAAa,EAAE,KAAK,EAIlB,OAAsD,EACtD,EAAE;YACF,MAAM,IAAI,KAAK,CACb,+DAA+D,CAChE,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC,CAAC;AAtBW,QAAA,kCAAkC,sCAsB7C","sourcesContent":["import type { Address, SmartAccountSigner } from \"@aa-sdk/core\";\nimport type { Signer } from \"@ethersproject/abstract-signer\";\nimport { Wallet } from \"@ethersproject/wallet\";\nimport type { SignableMessage, TypedData, TypedDataDefinition } from \"viem\";\n\n/**\n * Converts a ethersjs Wallet to a SmartAccountSigner\n *\n * @param {Wallet} wallet - the Wallet to convert\n * @returns {SmartAccountSigner<Wallet>} a signer that can be used to sign and send user operations\n */\nexport const convertWalletToAccountSigner = (\n  wallet: Wallet\n): SmartAccountSigner<Wallet> => {\n  return {\n    inner: wallet,\n    signerType: \"local\",\n    getAddress: async () => Promise.resolve(wallet.address as `0x${string}`),\n    signMessage: async (msg: SignableMessage) =>\n      (await wallet.signMessage(\n        typeof msg === \"string\" ? msg : msg.raw\n      )) as `0x${string}`,\n    signTypedData: async <\n      const TTypedData extends TypedData | { [key: string]: unknown },\n      TPrimaryType extends string = string\n    >(\n      params: TypedDataDefinition<TTypedData, TPrimaryType>\n    ) => {\n      return (await wallet._signTypedData(\n        params.domain ?? {},\n        // @ts-expect-error: these params should line up due to the spec for this function\n        params.types,\n        params.message\n      )) as `0x${string}`;\n    },\n  };\n};\n\n/**\n * Converts a ethers.js Signer to a SmartAccountSigner\n *\n * @param {Signer} signer - the Signer to convert\n * @returns {SmartAccountSigner<Signer>} a signer that can be used to sign and send user operations\n */\nexport const convertEthersSignerToAccountSigner = (\n  signer: Signer\n): SmartAccountSigner<Signer> => {\n  return {\n    inner: signer,\n    signerType: \"json-rpc\",\n    getAddress: async () => signer.getAddress() as Promise<Address>,\n    signMessage: async (msg: SignableMessage) =>\n      (await signer.signMessage(\n        typeof msg === \"string\" ? msg : msg.raw\n      )) as `0x${string}`,\n    signTypedData: async <\n      const TTypedData extends TypedData | { [key: string]: unknown },\n      TPrimaryType extends string = string\n    >(\n      _params: TypedDataDefinition<TTypedData, TPrimaryType>\n    ) => {\n      throw new Error(\n        \"signTypedData is not supported for ethers signers; use Wallet\"\n      );\n    },\n  };\n};\n"]}

package/dist/esm/package.json

@@ -1 +0,0 @@
-{"type":"module"}