@aa-sdk/core 4.0.0-alpha.4 → 4.0.0-alpha.6

package/dist/types/utils/userop.d.ts

@@ -2,53 +2,53 @@ import { type Hex } from "viem";
 import type { EntryPointVersion } from "../entrypoint/types";
 import type { BigNumberish, Multiplier, UserOperationFeeOptionsField, UserOperationOverrides, UserOperationRequest, UserOperationStruct } from "../types";
 /**
- * Utility method for asserting a {@link UserOperationStruct} has valid fields for the given entry point version
+ * Utility method for asserting a UserOperationStruct has valid fields for the given entry point version
  *
- * @param request a {@link UserOperationStruct} to validate
- * @returns a type guard that asserts the {@link UserOperationRequest} is valid
+ * @param {UserOperationStruct} request a UserOperationStruct to validate
+ * @returns {boolean} a type guard that asserts the UserOperationRequest is valid
  */
 export declare function isValidRequest<TEntryPointVersion extends EntryPointVersion = EntryPointVersion>(request: UserOperationStruct<TEntryPointVersion>): request is UserOperationRequest<TEntryPointVersion>;
 /**
- * Utility method for asserting a {@link UserOperationRequest} has valid fields for the paymaster data
+ * Utility method for asserting a UserOperationRequest has valid fields for the paymaster data
  *
- * @param request a {@link UserOperationRequest} to validate
- * @returns a type guard that asserts the {@link UserOperationRequest} is a {@link UserOperationRequest}
+ * @param {UserOperationRequest} request a UserOperationRequest to validate
+ * @returns {boolean}  a type guard that asserts the UserOperationRequest is a UserOperationRequest
  */
 export declare function isValidPaymasterAndData<TEntryPointVersion extends EntryPointVersion = EntryPointVersion>(request: UserOperationStruct<TEntryPointVersion>): boolean;
 /**
- * Utility method for asserting a {@link UserOperationStruct} has valid fields for the paymaster data
+ * Utility method for asserting a UserOperationStruct has valid fields for the paymaster data
  *
- * @param request a {@link UserOperationRequest} to validate
- * @returns a type guard that asserts the {@link UserOperationStruct} is a {@link UserOperationRequest}
+ * @param {UserOperationRequest} request a UserOperationRequest to validate
+ * @returns {boolean} a type guard that asserts the UserOperationStruct is a UserOperationRequest
  */
 export declare function isValidFactoryAndData<TEntryPointVersion extends EntryPointVersion = EntryPointVersion>(request: UserOperationStruct<TEntryPointVersion>): boolean;
 /**
- * Utility method for applying a {@link UserOperationOverrides} field value
+ * Utility method for applying a UserOperationOverrides field value
  * over the current value set for the field
  *
- * @param value the current value of the field
- * @param override the override value to apply
- * @returns the new value of the field after applying the override
+ * @param {BigNumberish} value the current value of the field
+ * @param {BigNumberish | Multiplier} override the override value to apply
+ * @returns {BigNumberish} the new value of the field after applying the override
  */
 export declare function applyUserOpOverride<TValue extends BigNumberish | undefined>(value: TValue, override?: BigNumberish | Multiplier): TValue | BigNumberish;
 /**
- * Utility method for applying a {@link UserOperationFeeOptionsField} value
+ * Utility method for applying a UserOperationFeeOptionsField value
  * over the current value set for the field
  *
- * @param value the current value of the field
- * @param feeOption the fee option field value to apply
- * @returns the new value of the field after applying the fee option
+ * @param {BigNumberish} value the current value of the field
+ * @param {UserOperationFeeOptionsField} feeOption the override value to apply
+ * @returns {BigNumberish} the new value of the field after applying the override
  */
 export declare function applyUserOpFeeOption<TValue extends BigNumberish | undefined>(value: TValue, feeOption?: UserOperationFeeOptionsField): TValue | BigNumberish;
 /**
- * Utility method for applying a {@link UserOperationOverrides} field value and
- * a {@link UserOperationFeeOptionsField} value over the current value set for the field,
+ * Utility method for applying a UserOperationOverrides field value and
+ * a UserOperationFeeOptionsField value over the current value set for the field,
  * with the override taking precedence over the fee option
  *
- * @param value the current value of the field
- * @param [override] the override value to apply
- * @param [feeOption] the fee option field value to apply
- * @returns the new value of the field after applying the override or fee option
+ * @param {BigNumberish} value the current value of the field
+ * @param {BigNumberish | Multiplier} [override] the override value to apply
+ * @param {UserOperationFeeOptionsField} [feeOption] the fee option field value to apply
+ * @returns {BigNumberish} the new value of the field after applying the override or fee option
  */
 export declare function applyUserOpOverrideOrFeeOption<TValue extends BigNumberish | undefined>(value: TValue, override?: BigNumberish | Multiplier, feeOption?: UserOperationFeeOptionsField): TValue | BigNumberish;
 /**
@@ -57,8 +57,8 @@ export declare function applyUserOpOverrideOrFeeOption<TValue extends BigNumberi
  * either because the UserOp is paying for its own gas, or passing a specific paymaster
  *
  * @template EntryPointVersion TEntryPointVersion
- * @param overrides the user operation overrides to check
- * @returns whether the paymaster middleware should be bypassed
+ * @param {UserOperationOverrides<TEntryPointVersion> | undefined} overrides the user operation overrides to check
+ * @returns {boolean} whether the paymaster middleware should be bypassed
  */
 export declare const bypassPaymasterAndData: <TEntryPointVersion extends keyof import("../entrypoint/types").EntryPointRegistryBase<unknown> = keyof import("../entrypoint/types").EntryPointRegistryBase<unknown>>(overrides: Partial<{
     callGasLimit: {
@@ -85,8 +85,8 @@ export declare const bypassPaymasterAndData: <TEntryPointVersion extends keyof i
  * pay for its own gas
  *
  * @template EntryPointVersion TEntryPointVersion
- * @param overrides the user operation overrides to check
- * @returns whether the paymaster middleware should be bypassed
+ * @param {UserOperationOverrides<TEntryPointVersion> | undefined} overrides the user operation overrides to check
+ * @returns {boolean} whether the paymaster middleware should be bypassed
  */
 export declare const bypassPaymasterAndDataEmptyHex: <TEntryPointVersion extends keyof import("../entrypoint/types").EntryPointRegistryBase<unknown> = keyof import("../entrypoint/types").EntryPointRegistryBase<unknown>>(overrides: Partial<{
     callGasLimit: {
@@ -110,20 +110,20 @@ export declare const bypassPaymasterAndDataEmptyHex: <TEntryPointVersion extends
 /**
  * Utility method for parsing the paymaster address and paymasterData from the paymasterAndData hex string
  *
- * @param paymasterAndData the paymaster and data hex string to parse.
+ * @param {Hex} paymasterAndData the paymaster and data hex string to parse.
  *                         The hex string refers to the paymasterAndData field of entrypoint v0.6 user operation request
- * @returns the parsed paymaster and paymasterData fields of entrypoint v0.7 user operation request paymaster and paymasterData field
+ * @returns {{ paymaster: Hex; paymasterData: Hex}} the parsed paymaster and paymasterData fields of entrypoint v0.7 user operation request paymaster and paymasterData field
  */
 export declare const parsePaymasterAndData: (paymasterAndData: Hex) => Pick<UserOperationRequest<"0.7.0">, "paymaster" | "paymasterData">;
 /**
  * Utility method for converting the object containing the paymaster address and paymaster data
  * to the paymaster and data concatenated hex string
  *
- * @param paymasterAndData the object containing the picked paymaster and paymasterData fields of
+ * @param {{ paymaster: Hex; paymasterData: Hex}} paymasterAndData the object containing the picked paymaster and paymasterData fields of
  *                         entrypoint v0.7 user operation request
- * @param paymasterAndData.paymaster the paymaster address
- * @param paymasterAndData.paymasterData the paymaster data
- * @returns the paymasterAndData hex value of entrypoint v0.6 user operation request paymasterAndData field
+ * @param {Hex} paymasterAndData.paymaster the paymaster address
+ * @param {Hex} paymasterAndData.paymasterData the paymaster data
+ * @returns {Hex} the paymasterAndData hex value of entrypoint v0.6 user operation request paymasterAndData field
  */
 export declare const concatPaymasterAndData: ({ paymaster, paymasterData, }: Pick<UserOperationRequest<"0.7.0">, "paymaster" | "paymasterData">) => Hex;
 //# sourceMappingURL=userop.d.ts.map

package/dist/types/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "4.0.0-alpha.4";
+export declare const VERSION = "4.0.0-alpha.6";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aa-sdk/core",
   "license": "MIT",
-  "version": "4.0.0-alpha.4",
+  "version": "4.0.0-alpha.6",
   "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",
@@ -66,5 +67,5 @@
     "url": "https://github.com/alchemyplatform/aa-sdk/issues"
   },
   "homepage": "https://github.com/alchemyplatform/aa-sdk#readme",
-  "gitHead": "07d3a1a98377c9db41d7f48cd89747d9e881267c"
+  "gitHead": "2c35ec701f526c77ea5e00e2e6f147156c7ac0e4"
 }

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
@@ -174,6 +179,13 @@ 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.
  *
@@ -188,11 +200,11 @@ export const parseFactoryAddressFromAccountInitCode = (
  * });
  * ```
  *
- * @param {object} config The configuration object
- * @param {PublicClient} config.client A public client instance to interact with the blockchain
- * @param {EntryPointDef} config.entryPoint The entry point definition which includes the address and ABI
- * @param {Address} config.accountAddress Optional existing account address
- * @param {function(): Promise<Hex>} config.getAccountInitCode A function that returns a Promise resolving to a Hex string representing the initial code of the account
+ * @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 ({
@@ -200,12 +212,7 @@ export const getAccountAddress = async ({
   entryPoint,
   accountAddress,
   getAccountInitCode,
-}: {
-  client: PublicClient;
-  entryPoint: EntryPointDef;
-  accountAddress?: Address;
-  getAccountInitCode: () => Promise<Hex>;
-}) => {
+}: GetAccountAddressParams) => {
   if (accountAddress) return accountAddress;
 
   const entryPointContract = getContract({

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`](/packages/aa-core/smart-account-client/middleware/index) 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/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,

package/src/actions/smartAccount/sendUserOperation.ts

@@ -17,9 +17,23 @@ import type {
 /**
  * Sends a user operation or batch of user operations using the connected account. Before executing, sendUserOperation will run the user operation through the middleware pipeline.
  *
- * @param client the smart account client to use for RPC requests
- * @param args {@link SendUserOperationParameters} containg the UO or batch to send, context, overrides, and account if not hoisted on the client
- * @returns a Promise containing the {@link SendUserOperationResult}
+ * @example
+ * ```ts
+ * import { createSmartAccountClient, toSmartContractAccount } from "@aa-sdk/core";
+ *
+ * const account = await toSmartContractAccount(...);
+ * const result = await createSmartAccountClient(...).sendUserOperation({
+ *  uo: {
+ *    target: "0x...",
+ *    data: "0x...", // or "0x",
+ *    value: 0n, // optional
+ *  }
+ * });
+ * ```
+ *
+ * @param {Client<TTransport, TChain, TAccount>} client the smart account client to use for RPC requests
+ * @param {SendUserOperationParameters<TAccount, TContext>} args contains the UO or batch to send, context, overrides, and account if not hoisted on the client
+ * @returns {Promise<SendUserOperationResult<TEntryPointVersion>>} a Promise containing the result of the user operation
  */
 export async function sendUserOperation<
   TTransport extends Transport = Transport,

package/src/client/bundlerClient.ts

@@ -58,8 +58,8 @@ export const createBundlerClientFromExisting: <
 /**
  * Creates a PublicClient with methods for calling Bundler RPC methods
  *
- * @param args - configuration for the client
- * @returns a PublicClient with methods for calling Bundler RPC methods
+ * @param {PublicClientConfig<TTransport, Chain> & { type?: string }} args - configuration for the client
+ * @returns {BundlerClient<TTransport>} a PublicClient with methods for calling Bundler RPC methods
  */
 export function createBundlerClient<TTransport extends Transport>(
   args: PublicClientConfig<TTransport, Chain> & { type?: string }