@aa-sdk/core 4.0.0-alpha.0 → 4.0.0-alpha.10

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aa-sdk/core",
   "license": "MIT",
-  "version": "4.0.0-alpha.0",
+  "version": "4.0.0-alpha.10",
   "description": "viem based SDK that enables interactions with ERC-4337 Smart Accounts. ABIs are based off the definitions generated in @account-abstraction/contracts",
   "author": "Alchemy",
   "type": "module",
@@ -37,6 +37,7 @@
     "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",
+    "docs:gen": "npx ak-docgen generate --in ./src/index.ts --out ../../site/pages/reference/aa-sdk/core",
     "clean": "rm -rf ./dist",
     "test": "vitest",
     "test:run": "vitest run",
@@ -47,7 +48,7 @@
     "ts-node": "^10.9.1",
     "typescript": "^5.0.4",
     "typescript-template": "*",
-    "vitest": "^0.31.0"
+    "vitest": "^2.0.4"
   },
   "dependencies": {
     "abitype": "^0.8.3",
@@ -66,5 +67,5 @@
     "url": "https://github.com/alchemyplatform/aa-sdk/issues"
   },
   "homepage": "https://github.com/alchemyplatform/aa-sdk#readme",
-  "gitHead": "bd1788c2bd7f28ba762a06c649f30b544f8bade9"
+  "gitHead": "e3446b95cdee38c248f336857b24f78a32694076"
 }

package/src/account/smartContractAccount.ts

@@ -34,7 +34,6 @@ import type { SmartAccountSigner } from "../signer/types.js";
 import { wrapSignatureWith6492 } from "../signer/utils.js";
 import type { NullAddress } from "../types.js";
 import type { IsUndefined } from "../utils/types.js";
-import { DeploymentState } from "./base.js";
 
 export type AccountOp = {
   target: Address;
@@ -42,6 +41,12 @@ export type AccountOp = {
   data: Hex | "0x";
 };
 
+export enum DeploymentState {
+  UNDEFINED = "0x0",
+  NOT_DEPLOYED = "0x1",
+  DEPLOYED = "0x2",
+}
+
 export type GetEntryPointFromAccount<
   TAccount extends SmartContractAccount | undefined,
   TAccountOverride extends SmartContractAccount = SmartContractAccount
@@ -74,6 +79,21 @@ export type SmartContractAccountWithSigner<
   getSigner: () => TSigner;
 };
 
+/**
+ * Determines if the given SmartContractAccount has a signer associated with it.
+ *
+ * @example
+ * ```ts
+ * import { toSmartContractAccount } from "@aa-sdk/core";
+ *
+ * const account = await toSmartContractAccount(...);
+ *
+ * console.log(isSmartAccountWithSigner(account)); // false: the base account does not have a publicly accessible signer
+ * ```
+ *
+ * @param {SmartContractAccount} account The account to check.
+ * @returns {boolean} true if the account has a signer, otherwise false.
+ */
 export const isSmartAccountWithSigner = (
   account: SmartContractAccount
 ): account is SmartContractAccountWithSigner => {
@@ -138,6 +158,19 @@ export type ToSmartContractAccountParams<
 } & Omit<CustomSource, "signTransaction" | "address">;
 // [!endregion ToSmartContractAccountParams]
 
+/**
+ * Parses the factory address and factory calldata from the provided account initialization code (initCode).
+ *
+ * @example
+ * ```ts
+ * import { parseFactoryAddressFromAccountInitCode } from "@aa-sdk/core";
+ *
+ * const [address, calldata] = parseFactoryAddressFromAccountInitCode("0xAddressCalldata");
+ * ```
+ *
+ * @param {Hex} initCode The initialization code from which to parse the factory address and calldata
+ * @returns {[Address, Hex]} A tuple containing the parsed factory address and factory calldata
+ */
 export const parseFactoryAddressFromAccountInitCode = (
   initCode: Hex
 ): [Address, Hex] => {
@@ -146,17 +179,40 @@ export const parseFactoryAddressFromAccountInitCode = (
   return [factoryAddress, factoryCalldata];
 };
 
+export type GetAccountAddressParams = {
+  client: PublicClient;
+  entryPoint: EntryPointDef;
+  accountAddress?: Address;
+  getAccountInitCode: () => Promise<Hex>;
+};
+
+/**
+ * Retrieves the account address. Uses a provided `accountAddress` if available; otherwise, it computes the address using the entry point contract and the initial code.
+ *
+ * @example
+ * ```ts
+ * import { getEntryPoint, getAccountAddress } from "@aa-sdk/core";
+ *
+ * const accountAddress = await getAccountAddress({
+ *  client,
+ *  entryPoint: getEntryPoint(chain),
+ *  getAccountInitCode: async () => "0x{factoryAddress}{factoryCallData}",
+ * });
+ * ```
+ *
+ * @param {GetAccountAddressParams} params The configuration object
+ * @param {PublicClient} params.client A public client instance to interact with the blockchain
+ * @param {EntryPointDef} params.entryPoint The entry point definition which includes the address and ABI
+ * @param {Address} params.accountAddress Optional existing account address
+ * @param {() => Promise<Hex>} params.getAccountInitCode A function that returns a Promise resolving to a Hex string representing the initial code of the account
+ * @returns {Promise<Address>} A promise that resolves to the account address
+ */
 export const getAccountAddress = async ({
   client,
   entryPoint,
   accountAddress,
   getAccountInitCode,
-}: {
-  client: PublicClient;
-  entryPoint: EntryPointDef;
-  accountAddress?: Address;
-  getAccountInitCode: () => Promise<Hex>;
-}) => {
+}: GetAccountAddressParams) => {
   if (accountAddress) return accountAddress;
 
   const entryPointContract = getContract({
@@ -220,21 +276,77 @@ export async function toSmartContractAccount<
 >): Promise<SmartContractAccount<Name, TEntryPointVersion>>;
 // [!endregion toSmartContractAccount]
 
-export async function toSmartContractAccount({
-  transport,
-  chain,
-  entryPoint,
-  source,
-  accountAddress,
-  getAccountInitCode,
-  signMessage,
-  signTypedData,
-  encodeBatchExecute,
-  encodeExecute,
-  getDummySignature,
-  signUserOperationHash,
-  encodeUpgradeToAndCall,
-}: ToSmartContractAccountParams): Promise<SmartContractAccount> {
+/**
+ * Converts an account to a smart contract account and sets up various account-related methods using the provided parameters like transport, chain, entry point, and other utilities.
+ *
+ * @example
+ * ```ts
+ * import { http, type SignableMessage } from "viem";
+ * import { sepolia } from "viem/chains";
+ *
+ * const myAccount = await toSmartContractAccount({
+ *  /// REQUIRED PARAMS ///
+ *  source: "MyAccount",
+ *  transport: http("RPC_URL"),
+ *  chain: sepolia,
+ *  // The EntryPointDef that your account is com"patible with
+ *  entryPoint: getEntryPoint(sepolia, { version: "0.6.0" }),
+ *  // This should return a concatenation of your `factoryAddress` and the `callData` for your factory's create account method
+ *  getAccountInitCode: async () => "0x{factoryAddress}{callData}",
+ *  // an invalid signature that doesn't cause your account to revert during validation
+ *  getDummySignature: () => "0x1234...",
+ *  // given a UO in the form of {target, data, value} should output the calldata for calling your contract's execution method
+ *  encodeExecute: async (uo) => "0xcalldata",
+ *  signMessage: async ({ message }: { message: SignableMessage }) => "0x...",
+ *  signTypedData: async (typedData) => "0x000",
+ *
+ *  /// OPTIONAL PARAMS ///
+ *  // if you already know your account's address, pass that in here to avoid generating a new counterfactual
+ *  accountAddress: "0xaddressoverride",
+ *  // if your account supports batching, this should take an array of UOs and return the calldata for calling your contract's batchExecute method
+ *  encodeBatchExecute: async (uos) => "0x...",
+ *  // if your contract expects a different signing scheme than the default signMessage scheme, you can override that here
+ *  signUserOperationHash: async (hash) => "0x...",
+ *  // allows you to define the calldata for upgrading your account
+ *  encodeUpgradeToAndCall: async (params) => "0x...",
+ * });
+ * ```
+ *
+ * @param {ToSmartContractAccountParams} params the parameters required for converting to a smart contract account
+ * @param {Transport} params.transport the transport mechanism used for communication
+ * @param {Chain} params.chain the blockchain chain used in the account
+ * @param {EntryPoint} params.entryPoint the entry point of the smart contract
+ * @param {string} params.source the source identifier for the account
+ * @param {Address} [params.accountAddress] the address of the account
+ * @param {() => Promise<Hex>} params.getAccountInitCode a function to get the initial state code of the account
+ * @param {(message: { message: SignableMessage }) => Promise<Hex>} params.signMessage a function to sign a message
+ * @param {(typedDataDefinition: TypedDataDefinition<typedData, primaryType>) => Promise<Hex>} params.signTypedData a function to sign typed data
+ * @param {(transactions: Transaction[]) => Hex} [params.encodeBatchExecute] a function to encode batch transactions
+ * @param {(tx: Transaction) => Hex} params.encodeExecute a function to encode a single transaction
+ * @param {() => Promise<Hex>} params.getDummySignature a function to get a dummy signature
+ * @param {(uoHash: Hex) => Promise<Hex>} [params.signUserOperationHash] a function to sign user operations
+ * @param {(implementationAddress: Address, implementationCallData: Hex) => Hex} [params.encodeUpgradeToAndCall] a function to encode upgrade call
+ * @returns {Promise<SmartContractAccount>} a promise that resolves to a SmartContractAccount object with methods and properties for interacting with the smart contract account
+ */
+export async function toSmartContractAccount(
+  params: ToSmartContractAccountParams
+): Promise<SmartContractAccount> {
+  const {
+    transport,
+    chain,
+    entryPoint,
+    source,
+    accountAddress,
+    getAccountInitCode,
+    signMessage,
+    signTypedData,
+    encodeBatchExecute,
+    encodeExecute,
+    getDummySignature,
+    signUserOperationHash,
+    encodeUpgradeToAndCall,
+  } = params;
+
   const client = createBundlerClient({
     // we set the retry count to 0 so that viem doesn't retry during
     // getting the address. That call always reverts and without this
@@ -262,7 +374,6 @@ export async function toSmartContractAccount({
     if (deploymentState === DeploymentState.DEPLOYED) {
       return "0x";
     }
-
     const contractCode = await client.getBytecode({
       address: accountAddress_,
     });

package/src/actions/smartAccount/buildUserOperation.ts

@@ -14,6 +14,29 @@ import type {
   UserOperationContext,
 } from "./types";
 
+/**
+ * Builds a user operation using the provided client and operation parameters. Ensures that the account exists and the client is compatible.
+ *
+ * @example
+ * ```ts
+ * import { createSmartAccountClient } from "@aa-sdk/core";
+ *
+ * // smart account client is already extended with buildUserOperation
+ * const client = createSmartAccountClient(...);
+ * const result = await client.buildUserOperation({
+ *  uo: {
+ *    target: "0x...",
+ *    data: "0x...", // or "0x",
+ *    value: 0n, // optional
+ *  },
+ *  account, // only required if the client above is not connected to an account
+ * });
+ * ```
+ *
+ * @param {Client<TTransport, TChain, TAccount>} client the client instance used to build the user operation
+ * @param {BuildUserOperationParameters<TAccount, TContext, TEntryPointVersion>} args the parameters required to build the user operation, including account, overrides, and context
+ * @returns {Promise<UserOperationStruct<TEntryPointVersion>>} a promise that resolves to a `UserOperationStruct` object containing the built user operation details
+ */
 export async function buildUserOperation<
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,

package/src/actions/smartAccount/buildUserOperationFromTx.ts

@@ -20,43 +20,43 @@ import { buildUserOperation } from "./buildUserOperation.js";
 import type { UserOperationContext } from "./types.js";
 
 /**
- * Performs [`buildUserOperationFromTx`](./buildUserOperationFromTx.md) in batch and builds into a single, yet to be signed `UserOperation` (UO) struct. The output user operation struct will be filled with all gas fields (and paymaster data if a paymaster is used) based on the transactions data (`to`, `data`, `value`, `maxFeePerGas`, `maxPriorityFeePerGas`) computed using the configured [`ClientMiddlewares`](/packages/aa-core/smart-account-client/middleware/index) on the `SmartAccountClient`
- * 
+ * Performs `buildUserOperationFromTx` in batch and builds into a single, yet to be signed `UserOperation` (UO) struct. The output user operation struct will be filled with all gas fields (and paymaster data if a paymaster is used) based on the transactions data (`to`, `data`, `value`, `maxFeePerGas`, `maxPriorityFeePerGas`) computed using the configured `ClientMiddlewares` on the `SmartAccountClient`
+ *
  * @example
  * ```ts
-import type { RpcTransactionRequest } from "viem";
-import { smartAccountClient } from "./smartAccountClient";
-// [!code focus:99]
-// buildUserOperationFromTx converts a traditional Ethereum transaction and returns
-// the unsigned user operation struct after constructing the user operation struct
-// through the middleware pipeline
-const tx: RpcTransactionRequest = {
-  from, // ignored
-  to,
-  data: encodeFunctionData({
-    abi: ContractABI.abi,
-    functionName: "func",
-    args: [arg1, arg2, ...],
-  }),
-};
-const uoStruct = await smartAccountClient.buildUserOperationFromTx(tx);
- 
-// signUserOperation signs the above unsigned user operation struct built
-// using the account connected to the smart account client
-const request = await smartAccountClient.signUserOperation({ uoStruct });
- 
-// You can use the BundlerAction `sendRawUserOperation` (packages/core/src/actions/bundler/sendRawUserOperation.ts)
-// to send the signed user operation request to the bundler, requesting the bundler to send the signed uo to the
-// EntryPoint contract pointed at by the entryPoint address parameter
-const entryPointAddress = client.account.getEntryPoint().address;
-const uoHash = await smartAccountClient.sendRawUserOperation({ request, entryPoint: entryPointAddress });
-```
- * 
- * @param client the smart account client to use for RPC requests
- * @param args {@link SendTransactionParameters}
- * @param overrides optional {@link UserOperationOverrides} to use for any of the fields
- * @param context if the smart account client requires additinoal context for building UOs
- * @returns a Promise containing the built user operation
+ * import type { RpcTransactionRequest } from "viem";
+ * import { smartAccountClient } from "./smartAccountClient";
+ * // [!code focus:99]
+ * // buildUserOperationFromTx converts a traditional Ethereum transaction and returns
+ * // the unsigned user operation struct after constructing the user operation struct
+ * // through the middleware pipeline
+ * const tx: RpcTransactionRequest = {
+ *   from, // ignored
+ *   to,
+ *   data: encodeFunctionData({
+ *     abi: ContractABI.abi,
+ *     functionName: "func",
+ *     args: [arg1, arg2, ...],
+ *   }),
+ * };
+ * const uoStruct = await smartAccountClient.buildUserOperationFromTx(tx);
+ *
+ * // signUserOperation signs the above unsigned user operation struct built
+ * // using the account connected to the smart account client
+ * const request = await smartAccountClient.signUserOperation({ uoStruct });
+ *
+ * // You can use the BundlerAction `sendRawUserOperation` (packages/core/src/actions/bundler/sendRawUserOperation.ts)
+ * // to send the signed user operation request to the bundler, requesting the bundler to send the signed uo to the
+ * // EntryPoint contract pointed at by the entryPoint address parameter
+ * const entryPointAddress = client.account.getEntryPoint().address;
+ * const uoHash = await smartAccountClient.sendRawUserOperation({ request, entryPoint: entryPointAddress });
+ * ```
+ *
+ * @param {Client<Transport, TChain, TAccount>} client the smart account client to use for RPC requests
+ * @param {SendTransactionParameters} args the send tx parameters
+ * @param {UserOperationOverrides} overrides optional overrides to use for any of the fields
+ * @param {TContext} context if the smart account client requires additinoal context for building UOs
+ * @returns {Promise<UserOperationStruct<TEntryPointVersion>>} a Promise containing the built user operation
  */
 export async function buildUserOperationFromTx<
   TChain extends Chain | undefined = Chain | undefined,

package/src/actions/smartAccount/buildUserOperationFromTxs.ts

@@ -17,74 +17,58 @@ import type {
 } from "./types";
 
 /**
- * Performs {@link buildUserOperationFromTx} in batch and builds into a single,
+ * Performs `buildUserOperationFromTx` in batch and builds into a single,
  * yet to be signed `UserOperation` (UO) struct. The output user operation struct
  * will be filled with all gas fields (and paymaster data if a paymaster is used)
  * based on the transactions data (`to`, `data`, `value`, `maxFeePerGas`,
- * `maxPriorityFeePerGas`) computed using the configured
- * [`ClientMiddlewares`](/packages/aa-core/smart-account-client/middleware/index) on the `SmartAccountClient`
- * 
+ * `maxPriorityFeePerGas`) computed using the configured ClientMiddlewares on the SmartAccountClient.
+ *
  * @example
  * ```ts
  * import type { RpcTransactionRequest } from "viem";
-import { smartAccountClient } from "./smartAccountClient";
-// [!code focus:99]
-// buildUserOperationFromTxs converts traditional Ethereum transactions in batch and returns
-// the unsigned user operation struct after constructing the user operation struct
-// through the middleware pipeline
-const requests: RpcTransactionRequest[] = [
-  {
-    from, // ignored
-    to,
-    data: encodeFunctionData({
-      abi: ContractABI.abi,
-      functionName: "func",
-      args: [arg1, arg2, ...],
-    }),
-  },
-  {
-    from, // ignored
-    to,
-    data: encodeFunctionData({
-      abi: ContractABI.abi,
-      functionName: "func",
-      args: [arg1, arg2, ...],
-    }),
-  },
-  ...
-  {
-    from, // ignored
-    to,
-    data: encodeFunctionData({
-      abi: ContractABI.abi,
-      functionName: "func",
-      args: [arg1, arg2, ...],
-    }),
-  },
-];
-const uoStruct = await smartAccountClient.buildUserOperationFromTxs({
-  requests,
-});
- 
-// signUserOperation signs the above unsigned user operation struct built
-// using the account connected to the smart account client
-const request = await smartAccountClient.signUserOperation({ uoStruct });
- 
-// You can use the BundlerAction `sendRawUserOperation` (packages/core/src/actions/bundler/sendRawUserOperation.ts)
-// to send the signed user operation request to the bundler, requesting the bundler to send the signed uo to the
-// EntryPoint contract pointed at by the entryPoint address parameter
-const entryPointAddress = client.account.getEntryPoint().address;
-const uoHash = await smartAccountClient.sendRawUserOperation({
-  request,
-  entryPoint: entryPointAddress,
-});
+ * import { smartAccountClient } from "./smartAccountClient";
+ *
+ * const requests: RpcTransactionRequest[] = [
+ *   {
+ *     from, // ignored
+ *     to,
+ *     data: encodeFunctionData({
+ *       abi: ContractABI.abi,
+ *       functionName: "func",
+ *       args: [arg1, arg2, ...],
+ *     }),
+ *   },
+ *   {
+ *     from, // ignored
+ *     to,
+ *     data: encodeFunctionData({
+ *       abi: ContractABI.abi,
+ *       functionName: "func",
+ *       args: [arg1, arg2, ...],
+ *     }),
+ *   },
+ * ];
+ * const uoStruct = await smartAccountClient.buildUserOperationFromTxs({
+ *   requests,
+ * });
+ *
+ * // signUserOperation signs the above unsigned user operation struct built
+ * // using the account connected to the smart account client
+ * const request = await smartAccountClient.signUserOperation({ uoStruct });
+ *
+ * // You can use the BundlerAction `sendRawUserOperation` (packages/core/src/actions/bundler/sendRawUserOperation.ts)
+ * // to send the signed user operation request to the bundler, requesting the bundler to send the signed uo to the
+ * // EntryPoint contract pointed at by the entryPoint address parameter
+ * const entryPointAddress = client.account.getEntryPoint().address;
+ * const uoHash = await smartAccountClient.sendRawUserOperation({
+ *   request,
+ *   entryPoint: entryPointAddress,
+ * });
  * ```
  *
- * @param client the smart account client to use to make RPC calls
- * @param args {@link BuildTransactionParameters} an object containing the requests
- * to build as well as, the account if not hoisted, the context, the overrides, and
- * optionally a flag to enable signing of the UO via the underlying middleware
- * @returns a Promise containing the built user operation
+ * @param {Client<TTransport, TChain, TAccount>} client the smart account client to use to make RPC calls
+ * @param {BuildTransactionParameters} args  an object containing the requests to build as well as, the account if not hoisted, the context, the overrides, and optionally a flag to enable signing of the UO via the underlying middleware
+ * @returns {Promise<BuildUserOperationFromTransactionsResult<TEntryPointVersion>>} a Promise containing the built user operation
  */
 export async function buildUserOperationFromTxs<
   TTransport extends Transport = Transport,

package/src/actions/smartAccount/checkGasSponsorshipEligibility.ts

@@ -12,31 +12,31 @@ import type {
 
 /**
  * This function verifies the eligibility of the connected account for gas sponsorship concerning the upcoming `UserOperation` (UO) that is intended to be sent.
- * Internally, this method invokes [`buildUserOperation`](./buildUserOperation.md), which navigates through the middleware pipeline, including the `PaymasterMiddleware`. Its purpose is to construct the UO struct meant for transmission to the bundler. Following the construction of the UO struct, this function verifies if the resulting structure contains a non-empty `paymasterAndData` field.
+ * Internally, this method invokes `buildUserOperation`, which navigates through the middleware pipeline, including the `PaymasterMiddleware`. Its purpose is to construct the UO struct meant for transmission to the bundler. Following the construction of the UO struct, this function verifies if the resulting structure contains a non-empty `paymasterAndData` field.
  * You can utilize this method before sending the user operation to confirm its eligibility for gas sponsorship. Depending on the outcome, it allows you to tailor the user experience accordingly, based on eligibility.
  *
  * @example
  * ```ts
  * import { smartAccountClient } from "./smartAccountClient";
-// [!code focus:99]
-const eligible = await smartAccountClient.checkGasSponsorshipEligibility({
-  uo: {
-    data: "0xCalldata",
-    target: "0xTarget",
-    value: 0n,
-  },
-});
- 
-console.log(
-  `User Operation is ${
-    eligible ? "eligible" : "ineligible"
-  } for gas sponsorship.`
-);
+ * // [!code focus:99]
+ * const eligible = await smartAccountClient.checkGasSponsorshipEligibility({
+ *   uo: {
+ *     data: "0xCalldata",
+ *     target: "0xTarget",
+ *     value: 0n,
+ *   },
+ * });
+ *
+ * console.log(
+ *   `User Operation is ${
+ *     eligible ? "eligible" : "ineligible"
+ *   } for gas sponsorship.`
+ * );
  * ```
- * 
- * @param client the smart account client to use for making RPC calls
- * @param args {@link SendUserOperationParameters} containing the user operation, account, context, and overrides
- * @returns a Promise containing a boolean indicating if the account is elgibile for sponsorship
+ *
+ * @param {Client<TTransport, TChain, TAccount>} client the smart account client to use for making RPC calls
+ * @param {SendUserOperationParameters} args containing the user operation, account, context, and overrides
+ * @returns {Promise<boolean>} a Promise containing a boolean indicating if the account is elgibile for sponsorship
  */
 export function checkGasSponsorshipEligibility<
   TTransport extends Transport = Transport,

package/src/actions/smartAccount/dropAndReplaceUserOperation.ts

@@ -20,6 +20,28 @@ import type {
   UserOperationContext,
 } from "./types";
 
+/**
+ * Drops an existing user operation and replaces it with a new one while ensuring the appropriate fees and overrides are applied.
+ *
+ * @example
+ * ```ts
+ * import {
+ *  createSmartAccountClient,
+ * } from "@aa-sdk/core";
+ *
+ * // smart account client is already extended with dropAndReplaceUserOperation
+ * const client = createSmartAccountClient(...);
+ * const { request } = await client.sendUserOperation(...);
+ * const result = await client.dropAndReplaceUserOperation({
+ *  uoToDrop: request,
+ *  account, // only required if the client above is not connected to an account
+ * });
+ * ```
+ *
+ * @param {Client<TTransport, TChain, TAccount>} client The client instance with the transport, chain, and account information
+ * @param {DropAndReplaceUserOperationParameters<TAccount, TContext>} args The parameters required for dropping and replacing the user operation including the account, operation to drop, overrides, and context
+ * @returns {Promise<SendUserOperationResult<TEntryPointVersion>>} A promise that resolves to the result of sending the new user operation
+ */
 export async function dropAndReplaceUserOperation<
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,

package/src/actions/smartAccount/estimateUserOperationGas.ts

@@ -23,9 +23,9 @@ import type {
  * @template {SmartContractAccount | undefined} TAccount
  * @template {UserOperationContext | undefined} TContext
  * @template {GetEntryPointFromAccount<TAccount>} TEntryPointVersion
- * @param client smart account client
- * @param args send user operation parameters
- * @returns user operation gas estimate response
+ * @param {Client<TTransport, TChain, TAccount>} client smart account client
+ * @param {SendUserOperationParameters<TAccount, TContext>} args send user operation parameters
+ * @returns {Promise<UserOperationEstimateGasResponse<TEntryPointVersion>>}user operation gas estimate response
  */
 export async function estimateUserOperationGas<
   TTransport extends Transport = Transport,

package/src/actions/smartAccount/internal/initUserOperation.ts

@@ -18,15 +18,14 @@ import type {
  * Description internal action function of SmartAccountClient for initializing
  * a user operation for the sender account
  *
- * @async
  * @template {Transport} TTransport
  * @template {Chain | undefined} TChain
  * @template {SmartContractAccount | undefined} TAccount
  * @template {UserOperationContext | undefined} TContext
  * @template {GetEntryPointFromAccount} TEntryPointVersion
- * @param client smart account client
- * @param args send user operation parameters
- * @returns initialized user operation struct
+ * @param {BaseSmartAccountClient<TTransport, TChain, TAccount>} client smart account client
+ * @param {SendUserOperationParameters<TAccount, TContext, TEntryPointVersion> | BuildUserOperationParameters<TAccount, TContext, TEntryPointVersion>} args send user operation parameters
+ * @returns {Promise<Deferrable<UserOperationStruct<TEntryPointVersion>>>} initialized user operation struct
  */
 export async function _initUserOperation<
   TTransport extends Transport = Transport,

package/src/actions/smartAccount/internal/runMiddlewareStack.ts

@@ -19,14 +19,6 @@ import {
 } from "../../../utils/index.js";
 import type { UserOperationContext } from "../types";
 
-/**
- * Utility method for running a sequence of async functions as a pipeline
- *
- * @template S
- * @template Opts
- * @param fns async functions to run in a pipeline sequence
- * @returns a function that runs the async functions in a pipeline sequence
- */
 const asyncPipe =
   <S, Opts>(...fns: ((s: S, opts: Opts) => Promise<S>)[]) =>
   async (s: S, opts: Opts) => {
@@ -37,20 +29,6 @@ const asyncPipe =
     return result;
   };
 
-/**
- * Internal method of {@link SmartAccountClient} running the middleware stack for a user operation
- *
- * @async
- * @template TTransport
- * @template TChain
- * @template TAccount
- * @template TContext the {@link UserOperationContext} passed to the middleware
- * @template TEntryPointVersion
- * @param client the smart account client instance that runs the middleware pipeline with
- * @param args the Deferrable {@link UserOperationStruct} to run the middleware pipeline on
- *
- * @returns the resolved {@link UserOperationStruct} after running the middleware pipeline
- */
 export async function _runMiddlewareStack<
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,

package/src/actions/smartAccount/internal/sendUserOperation.ts

@@ -15,13 +15,6 @@ import type {
 import { signUserOperation } from "../signUserOperation.js";
 import type { GetContextParameter, UserOperationContext } from "../types";
 
-/**
- * Used internally to send a user operation that has **already** been signed
- *
- * @param client a base smart account client instance with middleware configured
- * @param args user operation struct, overrides, account, and context to be used in sending
- * @returns A Promise containing the send user operation result {@link SendUserOperationResult}
- */
 export async function _sendUserOperation<
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,