@aa-sdk/core 4.0.0-alpha.0

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

@@ -0,0 +1,93 @@
+import type { Chain, Transport } from "viem";
+import type {
+  GetEntryPointFromAccount,
+  SmartContractAccount,
+} from "../../../account/smartContractAccount.js";
+import type { BaseSmartAccountClient } from "../../../client/smartAccountClient.js";
+import { AccountNotFoundError } from "../../../errors/account.js";
+import { ChainNotFoundError } from "../../../errors/client.js";
+import type { UserOperationStruct } from "../../../types.js";
+import { conditionalReturn, type Deferrable } from "../../../utils/index.js";
+import type {
+  BuildUserOperationParameters,
+  SendUserOperationParameters,
+  UserOperationContext,
+} from "../types.js";
+
+/**
+ * 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
+ */
+export async function _initUserOperation<
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined,
+  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>
+>(
+  client: BaseSmartAccountClient<TTransport, TChain, TAccount>,
+  args:
+    | SendUserOperationParameters<TAccount, TContext, TEntryPointVersion>
+    | BuildUserOperationParameters<TAccount, TContext, TEntryPointVersion>
+): Promise<Deferrable<UserOperationStruct<TEntryPointVersion>>> {
+  const { account = client.account, uo, overrides } = args;
+  if (!account) {
+    throw new AccountNotFoundError();
+  }
+
+  if (!client.chain) {
+    throw new ChainNotFoundError();
+  }
+
+  const entryPoint = account.getEntryPoint();
+
+  const callData = Array.isArray(uo)
+    ? account.encodeBatchExecute(uo)
+    : typeof uo === "string"
+    ? uo
+    : account.encodeExecute(uo);
+
+  const signature = account.getDummySignature();
+
+  const nonce = account.getNonce(overrides?.nonceKey);
+
+  const struct =
+    entryPoint.version === "0.6.0"
+      ? ({
+          initCode: account.getInitCode(),
+          sender: account.address,
+          nonce,
+          callData,
+          signature,
+        } as Deferrable<UserOperationStruct<TEntryPointVersion>>)
+      : ({
+          factory: conditionalReturn(
+            account.isAccountDeployed().then((deployed) => !deployed),
+            account.getFactoryAddress
+          ),
+          factoryData: conditionalReturn(
+            account.isAccountDeployed().then((deployed) => !deployed),
+            account.getFactoryData
+          ),
+          sender: account.address,
+          nonce,
+          callData,
+          signature,
+        } as Deferrable<UserOperationStruct<TEntryPointVersion>>);
+
+  return struct;
+}

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

@@ -0,0 +1,121 @@
+import type { Chain, Transport } from "viem";
+import type {
+  GetAccountParameter,
+  GetEntryPointFromAccount,
+  SmartContractAccount,
+} from "../../../account/smartContractAccount";
+import type { BaseSmartAccountClient } from "../../../client/smartAccountClient";
+import { AccountNotFoundError } from "../../../errors/account.js";
+import { noopMiddleware } from "../../../middleware/noopMiddleware.js";
+import type { ClientMiddleware } from "../../../middleware/types";
+import type {
+  UserOperationOverridesParameter,
+  UserOperationStruct,
+} from "../../../types";
+import {
+  bypassPaymasterAndData,
+  resolveProperties,
+  type Deferrable,
+} 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) => {
+    let result = s;
+    for (const fn of fns) {
+      result = await fn(result, opts);
+    }
+    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,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined,
+  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>
+>(
+  client: BaseSmartAccountClient<TTransport, TChain, TAccount>,
+  args: {
+    uo: Deferrable<UserOperationStruct<TEntryPointVersion>>;
+    context?: TContext;
+  } & GetAccountParameter<TAccount> &
+    UserOperationOverridesParameter<TEntryPointVersion>
+): Promise<UserOperationStruct<TEntryPointVersion>> {
+  const { uo, overrides, account = client.account, context } = args;
+  if (!account) {
+    throw new AccountNotFoundError();
+  }
+
+  const {
+    dummyPaymasterAndData,
+    paymasterAndData,
+  }: Pick<
+    ClientMiddleware<TContext>,
+    "dummyPaymasterAndData" | "paymasterAndData"
+  > = bypassPaymasterAndData(overrides)
+    ? {
+        dummyPaymasterAndData: async (uo, { overrides }) => {
+          return {
+            ...uo,
+            ...("paymasterAndData" in overrides!
+              ? { paymasterAndData: overrides.paymasterAndData }
+              : "paymasterData" in overrides! &&
+                "paymaster" in overrides &&
+                overrides.paymasterData !== "0x"
+              ? {
+                  paymasterData: overrides.paymasterData,
+                  paymaster: overrides.paymaster,
+                }
+              : // At this point, nothing has run so no fields are set
+                // for 0.7 when not using a paymaster, all fields should be undefined
+                undefined),
+          };
+        },
+        paymasterAndData: noopMiddleware,
+      }
+    : {
+        dummyPaymasterAndData: client.middleware.dummyPaymasterAndData,
+        paymasterAndData: client.middleware.paymasterAndData,
+      };
+
+  const result = await asyncPipe(
+    dummyPaymasterAndData,
+    client.middleware.feeEstimator,
+    client.middleware.gasEstimator,
+    client.middleware.customMiddleware,
+    paymasterAndData,
+    client.middleware.userOperationSimulator
+  )(uo, { overrides, feeOptions: client.feeOptions, account, client, context });
+
+  return resolveProperties<
+    UserOperationStruct<GetEntryPointFromAccount<TAccount>>
+  >(result);
+}

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

@@ -0,0 +1,64 @@
+import type { Chain, Transport } from "viem";
+import type {
+  GetAccountParameter,
+  GetEntryPointFromAccount,
+  SmartContractAccount,
+} from "../../../account/smartContractAccount";
+import type { BaseSmartAccountClient } from "../../../client/smartAccountClient";
+import type { SendUserOperationResult } from "../../../client/types";
+import { AccountNotFoundError } from "../../../errors/account.js";
+import { ChainNotFoundError } from "../../../errors/client.js";
+import type {
+  UserOperationOverrides,
+  UserOperationStruct,
+} from "../../../types";
+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,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined,
+  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>
+>(
+  client: BaseSmartAccountClient<TTransport, TChain, TAccount>,
+  args: {
+    uoStruct: UserOperationStruct<TEntryPointVersion>;
+    overrides?: UserOperationOverrides<TEntryPointVersion>;
+  } & GetAccountParameter<TAccount> &
+    GetContextParameter<TContext>
+): Promise<SendUserOperationResult<TEntryPointVersion>> {
+  const { account = client.account, uoStruct, context, overrides } = args;
+  if (!account) {
+    throw new AccountNotFoundError();
+  }
+
+  if (!client.chain) {
+    throw new ChainNotFoundError();
+  }
+
+  const entryPoint = account.getEntryPoint();
+  const request = await signUserOperation(client, {
+    uoStruct,
+    account,
+    context,
+    overrides,
+  });
+
+  return {
+    hash: await client.sendRawUserOperation(request, entryPoint.address),
+    request,
+  };
+}

package/src/actions/smartAccount/sendTransaction.ts

@@ -0,0 +1,73 @@
+import type {
+  Chain,
+  Client,
+  Hex,
+  SendTransactionParameters,
+  Transport,
+} from "viem";
+import type {
+  GetEntryPointFromAccount,
+  SmartContractAccount,
+} from "../../account/smartContractAccount.js";
+import { isBaseSmartAccountClient } from "../../client/isSmartAccountClient.js";
+import { AccountNotFoundError } from "../../errors/account.js";
+import { IncompatibleClientError } from "../../errors/client.js";
+import { TransactionMissingToParamError } from "../../errors/transaction.js";
+import { WaitForUserOperationError } from "../../errors/useroperation.js";
+import type { UserOperationOverrides } from "../../types.js";
+import { buildUserOperationFromTx } from "./buildUserOperationFromTx.js";
+import { _sendUserOperation } from "./internal/sendUserOperation.js";
+import type { UserOperationContext } from "./types.js";
+import { waitForUserOperationTransaction } from "./waitForUserOperationTransacation.js";
+
+export async function sendTransaction<
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  TChainOverride extends Chain | undefined = Chain | undefined,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined,
+  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>
+>(
+  client: Client<Transport, TChain, TAccount>,
+  args: SendTransactionParameters<TChain, TAccount, TChainOverride>,
+  overrides?: UserOperationOverrides<TEntryPointVersion>,
+  context?: TContext
+): Promise<Hex> {
+  const { account = client.account } = args;
+  if (!account || typeof account === "string") {
+    throw new AccountNotFoundError();
+  }
+
+  if (!args.to) {
+    throw new TransactionMissingToParamError();
+  }
+
+  if (!isBaseSmartAccountClient(client)) {
+    throw new IncompatibleClientError(
+      "BaseSmartAccountClient",
+      "sendTransaction",
+      client
+    );
+  }
+
+  const uoStruct = await buildUserOperationFromTx(
+    client,
+    args,
+    overrides,
+    context
+  );
+
+  const { hash, request } = await _sendUserOperation(client, {
+    account: account as SmartContractAccount,
+    uoStruct,
+    context,
+    overrides,
+  });
+
+  return waitForUserOperationTransaction(client, { hash }).catch((e) => {
+    throw new WaitForUserOperationError(request, e);
+  });
+}

package/src/actions/smartAccount/sendTransactions.ts

@@ -0,0 +1,53 @@
+import type { Chain, Client, Hex, Transport } from "viem";
+import type { SmartContractAccount } from "../../account/smartContractAccount.js";
+import { isBaseSmartAccountClient } from "../../client/isSmartAccountClient.js";
+import { AccountNotFoundError } from "../../errors/account.js";
+import { IncompatibleClientError } from "../../errors/client.js";
+import { WaitForUserOperationError } from "../../errors/useroperation.js";
+import { buildUserOperationFromTxs } from "./buildUserOperationFromTxs.js";
+import { _sendUserOperation } from "./internal/sendUserOperation.js";
+import type { SendTransactionsParameters, UserOperationContext } from "./types";
+import { waitForUserOperationTransaction } from "./waitForUserOperationTransacation.js";
+
+export async function sendTransactions<
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  TContext extends UserOperationContext | undefined = UserOperationContext
+>(
+  client: Client<TTransport, TChain, TAccount>,
+  args: SendTransactionsParameters<TAccount, TContext>
+): Promise<Hex> {
+  const { requests, overrides, account = client.account, context } = args;
+  if (!account) {
+    throw new AccountNotFoundError();
+  }
+
+  if (!isBaseSmartAccountClient(client)) {
+    throw new IncompatibleClientError(
+      "BaseSmartAccountClient",
+      "sendTransactions",
+      client
+    );
+  }
+
+  const { uoStruct } = await buildUserOperationFromTxs(client, {
+    requests,
+    overrides,
+    account,
+    context,
+  });
+
+  const { hash, request } = await _sendUserOperation(client, {
+    account,
+    uoStruct,
+    context,
+    overrides,
+  });
+
+  return waitForUserOperationTransaction(client, { hash }).catch((e) => {
+    throw new WaitForUserOperationError(request, e);
+  });
+}

package/src/actions/smartAccount/sendUserOperation.ts

@@ -0,0 +1,65 @@
+import type { Chain, Client, Transport } from "viem";
+import type {
+  GetEntryPointFromAccount,
+  SmartContractAccount,
+} from "../../account/smartContractAccount.js";
+import { isBaseSmartAccountClient } from "../../client/isSmartAccountClient.js";
+import type { SendUserOperationResult } from "../../client/types.js";
+import { AccountNotFoundError } from "../../errors/account.js";
+import { IncompatibleClientError } from "../../errors/client.js";
+import { buildUserOperation } from "./buildUserOperation.js";
+import { _sendUserOperation } from "./internal/sendUserOperation.js";
+import type {
+  SendUserOperationParameters,
+  UserOperationContext,
+} from "./types.js";
+
+/**
+ * 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}
+ */
+export async function sendUserOperation<
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined,
+  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>
+>(
+  client: Client<TTransport, TChain, TAccount>,
+  args: SendUserOperationParameters<TAccount, TContext>
+): Promise<SendUserOperationResult<TEntryPointVersion>> {
+  const { account = client.account, context, overrides } = args;
+
+  if (!account) {
+    throw new AccountNotFoundError();
+  }
+
+  if (!isBaseSmartAccountClient(client)) {
+    throw new IncompatibleClientError(
+      "BaseSmartAccountClient",
+      "sendUserOperation",
+      client
+    );
+  }
+
+  const uoStruct = await buildUserOperation(client, {
+    uo: args.uo,
+    account,
+    context,
+    overrides,
+  });
+
+  return _sendUserOperation(client, {
+    account,
+    uoStruct,
+    context,
+    overrides,
+  });
+}

package/src/actions/smartAccount/signMessage.ts

@@ -0,0 +1,28 @@
+import type { Chain, Client, Hex, SignableMessage, Transport } from "viem";
+import type {
+  GetAccountParameter,
+  SmartContractAccount,
+} from "../../account/smartContractAccount";
+import { AccountNotFoundError } from "../../errors/account.js";
+
+export type SignMessageParameters<
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined
+> = { message: SignableMessage } & GetAccountParameter<TAccount>;
+
+export const signMessage: <
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined
+>(
+  client: Client<TTransport, TChain, TAccount>,
+  args: SignMessageParameters<TAccount>
+) => Promise<Hex> = async (client, { account = client.account, message }) => {
+  if (!account) {
+    throw new AccountNotFoundError();
+  }
+  return account.signMessage({ message });
+};

package/src/actions/smartAccount/signMessageWith6492.ts

@@ -0,0 +1,21 @@
+import type { Chain, Client, Hex, Transport } from "viem";
+import type { SmartContractAccount } from "../../account/smartContractAccount";
+import { AccountNotFoundError } from "../../errors/account.js";
+import type { SignMessageParameters } from "./signMessage";
+
+export const signMessageWith6492: <
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined
+>(
+  client: Client<TTransport, TChain, TAccount>,
+  args: SignMessageParameters<TAccount>
+) => Promise<Hex> = async (client, { account = client.account, message }) => {
+  if (!account) {
+    throw new AccountNotFoundError();
+  }
+
+  return account.signMessageWith6492({ message });
+};

package/src/actions/smartAccount/signTypedData.ts

@@ -0,0 +1,42 @@
+import type {
+  Chain,
+  Client,
+  Hex,
+  Transport,
+  TypedData,
+  TypedDataDefinition,
+} from "viem";
+import type {
+  GetAccountParameter,
+  SmartContractAccount,
+} from "../../account/smartContractAccount";
+import { AccountNotFoundError } from "../../errors/account.js";
+
+export type SignTypedDataParameters<
+  TTypedData extends TypedData | { [key: string]: unknown },
+  TPrimaryType extends string = string,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined
+> = {
+  typedData: TypedDataDefinition<TTypedData, TPrimaryType>;
+} & GetAccountParameter<TAccount>;
+
+export const signTypedData: <
+  const TTypedData extends TypedData | { [key: string]: unknown },
+  TPrimaryType extends string = string,
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined
+>(
+  client: Client<TTransport, TChain, TAccount>,
+  args: SignTypedDataParameters<TTypedData, TPrimaryType, TAccount>
+) => Promise<Hex> = async (client, { account = client.account, typedData }) => {
+  if (!account) {
+    throw new AccountNotFoundError();
+  }
+
+  return account.signTypedData(typedData);
+};

package/src/actions/smartAccount/signTypedDataWith6492.ts

@@ -0,0 +1,23 @@
+import type { Chain, Client, Hex, Transport, TypedData } from "viem";
+import type { SmartContractAccount } from "../../account/smartContractAccount";
+import { AccountNotFoundError } from "../../errors/account.js";
+import type { SignTypedDataParameters } from "./signTypedData";
+
+export const signTypedDataWith6492: <
+  const TTypedData extends TypedData | { [key: string]: unknown },
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  TPrimaryType extends string = string
+>(
+  client: Client<TTransport, TChain, TAccount>,
+  args: SignTypedDataParameters<TTypedData, TPrimaryType, TAccount>
+) => Promise<Hex> = async (client, { account = client.account, typedData }) => {
+  if (!account) {
+    throw new AccountNotFoundError();
+  }
+
+  return account.signTypedDataWith6492(typedData);
+};

package/src/actions/smartAccount/signUserOperation.ts

@@ -0,0 +1,54 @@
+import type { Chain, Client, Transport } from "viem";
+import type {
+  GetEntryPointFromAccount,
+  SmartContractAccount,
+} from "../../account/smartContractAccount";
+import { isBaseSmartAccountClient } from "../../client/isSmartAccountClient.js";
+import { AccountNotFoundError } from "../../errors/account.js";
+import {
+  ChainNotFoundError,
+  IncompatibleClientError,
+} from "../../errors/client.js";
+import type { UserOperationRequest } from "../../types";
+import { deepHexlify, resolveProperties } from "../../utils/index.js";
+import type { SignUserOperationParameters } from "./types";
+
+export async function signUserOperation<
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>
+>(
+  client: Client<TTransport, TChain, TAccount>,
+  args: SignUserOperationParameters<TAccount>
+): Promise<UserOperationRequest<TEntryPointVersion>> {
+  const { account = client.account, context } = args;
+
+  if (!account) {
+    throw new AccountNotFoundError();
+  }
+
+  if (!isBaseSmartAccountClient(client)) {
+    throw new IncompatibleClientError(
+      "BaseSmartAccountClient",
+      "signUserOperation",
+      client
+    );
+  }
+
+  if (!client.chain) {
+    throw new ChainNotFoundError();
+  }
+
+  return await client.middleware
+    .signUserOperation(args.uoStruct, {
+      ...args,
+      account,
+      client,
+      context,
+    })
+    .then(resolveProperties)
+    .then(deepHexlify);
+}