@aa-sdk/core 4.0.0-alpha.0

package/src/actions/smartAccount/types.ts

@@ -0,0 +1,158 @@
+import type { Hex, RpcTransactionRequest } from "viem";
+import type {
+  GetAccountParameter,
+  GetEntryPointFromAccount,
+  SmartContractAccount,
+} from "../../account/smartContractAccount";
+import type { UpgradeToData } from "../../client/types";
+import type { EntryPointVersion } from "../../entrypoint/types";
+import type {
+  BatchUserOperationCallData,
+  UserOperationCallData,
+  UserOperationOverridesParameter,
+  UserOperationRequest,
+  UserOperationStruct,
+} from "../../types";
+import type { IsUndefined } from "../../utils";
+
+// [!region UpgradeAccountParams]
+export type UpgradeAccountParams<
+  TAccount extends SmartContractAccount | undefined,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined,
+  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>
+> = {
+  upgradeTo: UpgradeToData;
+  waitForTx?: boolean;
+} & GetAccountParameter<TAccount> &
+  GetContextParameter<TContext> &
+  UserOperationOverridesParameter<TEntryPointVersion>;
+// [!endregion UpgradeAccountParams]
+
+// [!region SendUserOperationParameters]
+export type SendUserOperationParameters<
+  TAccount extends SmartContractAccount | undefined,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined,
+  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>
+> = {
+  uo: UserOperationCallData | BatchUserOperationCallData;
+} & GetAccountParameter<TAccount> &
+  GetContextParameter<TContext> &
+  UserOperationOverridesParameter<TEntryPointVersion>;
+// [!endregion SendUserOperationParameters]
+
+// [!region BuildUserOperationParameters]
+export type BuildUserOperationParameters<
+  TAccount extends SmartContractAccount | undefined,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined,
+  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>
+> = SendUserOperationParameters<TAccount, TContext, TEntryPointVersion>;
+// [!endregion BuildUserOperationParameters]
+
+// [!region SignUserOperationParameters]
+export type SignUserOperationParameters<
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+> = {
+  uoStruct: UserOperationStruct<TEntryPointVersion>;
+} & GetAccountParameter<TAccount> &
+  GetContextParameter<TContext>;
+// [!endregion SignUserOperationParameters]
+
+// [!region SendTransactionsParameters]
+export type SendTransactionsParameters<
+  TAccount extends SmartContractAccount | undefined,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined,
+  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>
+> = {
+  requests: RpcTransactionRequest[];
+} & GetAccountParameter<TAccount> &
+  GetContextParameter<TContext> &
+  UserOperationOverridesParameter<TEntryPointVersion>;
+// [!endregion SendTransactionsParameters]
+
+// [!region BuildTransactionParameters]
+export type BuildTransactionParameters<
+  TAccount extends SmartContractAccount | undefined,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined,
+  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>
+> = SendTransactionsParameters<TAccount, TContext, TEntryPointVersion>;
+// [!endregion BuildTransactionParameters]
+
+// [!region DropAndReplaceUserOperationParameters]
+export type DropAndReplaceUserOperationParameters<
+  TAccount extends SmartContractAccount | undefined,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined,
+  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>
+> = {
+  uoToDrop: UserOperationRequest<TEntryPointVersion>;
+} & GetAccountParameter<TAccount> &
+  GetContextParameter<TContext> &
+  UserOperationOverridesParameter<TEntryPointVersion>;
+// [!endregion DropAndReplaceUserOperationParameters]
+
+// [!region WaitForUserOperationTxParameters]
+export type WaitForUserOperationTxParameters = {
+  hash: Hex;
+  /**
+   * Exponential backoff paramters that can be used to override
+   * the configuration on the client. If not provided, this method
+   * will use the paramters passed via the `opts` parameter on the
+   * smart account client.
+   */
+  retries?: {
+    /**
+     * the base retry interval or delay between requests
+     */
+    intervalMs: number;
+    /**
+     * the multiplier to exponentiate based on the number retries
+     * setting this to one will result in a linear backoff
+     */
+    multiplier: number;
+    /** the maximum number of retries before failing */
+    maxRetries: number;
+  };
+};
+// [!endregion WaitForUserOperationTxParameters]
+
+// [!region BuildUserOperationFromTransactionsResult]
+export type BuildUserOperationFromTransactionsResult<
+  TEntryPointVersion extends EntryPointVersion = EntryPointVersion
+> = {
+  uoStruct: UserOperationStruct<TEntryPointVersion>;
+  batch: BatchUserOperationCallData;
+} & UserOperationOverridesParameter<TEntryPointVersion, true>;
+// [!endregion BuildUserOperationFromTransactionsResult]
+
+// [!region UserOperationContext]
+export type UserOperationContext = Record<string, any>;
+// [!endregion UserOperationContext]
+
+// [!region GetContextParameter]
+export type GetContextParameter<
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+> = IsUndefined<TContext> extends true
+  ? {
+      context?: TContext;
+    }
+  : { context: TContext };
+// [!endregion GetContextParameter]

package/src/actions/smartAccount/upgradeAccount.ts

@@ -0,0 +1,66 @@
+import type { Chain, Client, Hash, 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 { sendUserOperation } from "./sendUserOperation.js";
+import type { UpgradeAccountParams, UserOperationContext } from "./types.js";
+import { waitForUserOperationTransaction } from "./waitForUserOperationTransacation.js";
+
+export const upgradeAccount: <
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+>(
+  client: Client<TTransport, TChain, TAccount>,
+  args: UpgradeAccountParams<TAccount, TContext>
+) => Promise<Hash> = async (client, args) => {
+  const {
+    account = client.account,
+    upgradeTo,
+    overrides,
+    waitForTx,
+    context,
+  } = args;
+
+  if (!account) {
+    throw new AccountNotFoundError();
+  }
+
+  if (!isBaseSmartAccountClient(client)) {
+    throw new IncompatibleClientError(
+      "BaseSmartAccountClient",
+      "upgradeAccount",
+      client
+    );
+  }
+
+  const { implAddress: accountImplAddress, initializationData } = upgradeTo;
+
+  const encodeUpgradeData = await account.encodeUpgradeToAndCall({
+    upgradeToAddress: accountImplAddress,
+    upgradeToInitData: initializationData,
+  });
+
+  const result = await sendUserOperation(client, {
+    uo: {
+      target: account.address,
+      data: encodeUpgradeData,
+    },
+    account,
+    overrides,
+    context,
+  });
+
+  let hash = result.hash;
+  if (waitForTx) {
+    hash = await waitForUserOperationTransaction(client, result);
+  }
+
+  return hash;
+};

package/src/actions/smartAccount/waitForUserOperationTransacation.ts

@@ -0,0 +1,58 @@
+import type { Chain, Client, Hex, Transport } from "viem";
+import { getTransaction } from "viem/actions";
+import { isBaseSmartAccountClient } from "../../client/isSmartAccountClient.js";
+import { IncompatibleClientError } from "../../errors/client.js";
+import { FailedToFindTransactionError } from "../../errors/transaction.js";
+import { Logger } from "../../logger.js";
+import type { WaitForUserOperationTxParameters } from "./types.js";
+
+export const waitForUserOperationTransaction: <
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined
+>(
+  client: Client<TTransport, TChain, any>,
+  args: WaitForUserOperationTxParameters
+) => Promise<Hex> = async (client, args) => {
+  if (!isBaseSmartAccountClient(client)) {
+    throw new IncompatibleClientError(
+      "BaseSmartAccountClient",
+      "waitForUserOperationTransaction",
+      client
+    );
+  }
+
+  const {
+    hash,
+    retries = {
+      maxRetries: client.txMaxRetries,
+      intervalMs: client.txRetryIntervalMs,
+      multiplier: client.txRetryMultiplier,
+    },
+  } = args;
+
+  for (let i = 0; i < retries.maxRetries; i++) {
+    const txRetryIntervalWithJitterMs =
+      retries.intervalMs * Math.pow(retries.multiplier, i) +
+      Math.random() * 100;
+
+    await new Promise((resolve) =>
+      setTimeout(resolve, txRetryIntervalWithJitterMs)
+    );
+
+    const receipt = await client
+      .getUserOperationReceipt(hash as `0x${string}`)
+      .catch((e) => {
+        Logger.error(
+          `[SmartAccountProvider] waitForUserOperationTransaction error fetching receipt for ${hash}: ${e}`
+        );
+      });
+
+    if (receipt) {
+      return getTransaction(client, {
+        hash: receipt.receipt.transactionHash,
+      }).then((x) => x.hash);
+    }
+  }
+
+  throw new FailedToFindTransactionError(hash);
+};

package/src/chains/index.ts

@@ -0,0 +1,194 @@
+import { defineChain, type Chain } from "viem";
+import {
+  arbitrum as vab,
+  arbitrumGoerli as vabg,
+  arbitrumSepolia as vabs,
+  base as vbase,
+  baseGoerli as vbaseg,
+  baseSepolia as vbases,
+  goerli as vgo,
+  mainnet as vmain,
+  optimism as vop,
+  optimismGoerli as vopg,
+  optimismSepolia as vops,
+  polygon as vpg,
+  polygonMumbai as vpgm,
+  polygonAmoy as vpga,
+  sepolia as vsep,
+  fraxtal as vfrax,
+  zora as vzora,
+  zoraSepolia as vzoras,
+} from "viem/chains";
+
+export const arbitrum: Chain = {
+  ...vab,
+  rpcUrls: {
+    ...vab.rpcUrls,
+    alchemy: {
+      http: ["https://arb-mainnet.g.alchemy.com/v2"],
+    },
+  },
+};
+
+export const arbitrumGoerli: Chain = {
+  ...vabg,
+  rpcUrls: {
+    ...vabg.rpcUrls,
+    alchemy: {
+      http: ["https://arb-goerli.g.alchemy.com/v2"],
+    },
+  },
+};
+
+export const arbitrumSepolia: Chain = {
+  ...vabs,
+  rpcUrls: {
+    ...vabs.rpcUrls,
+    alchemy: {
+      http: ["https://arb-sepolia.g.alchemy.com/v2"],
+    },
+  },
+};
+export const goerli: Chain = {
+  ...vgo,
+  rpcUrls: {
+    ...vgo.rpcUrls,
+    alchemy: {
+      http: ["https://eth-goerli.g.alchemy.com/v2"],
+    },
+  },
+};
+export const mainnet: Chain = {
+  ...vmain,
+  rpcUrls: {
+    ...vmain.rpcUrls,
+    alchemy: {
+      http: ["https://eth-mainnet.g.alchemy.com/v2"],
+    },
+  },
+};
+export const optimism: Chain = {
+  ...vop,
+  rpcUrls: {
+    ...vop.rpcUrls,
+    alchemy: {
+      http: ["https://opt-mainnet.g.alchemy.com/v2"],
+    },
+  },
+};
+export const optimismGoerli: Chain = {
+  ...vopg,
+  rpcUrls: {
+    ...vopg.rpcUrls,
+    alchemy: {
+      http: ["https://opt-goerli.g.alchemy.com/v2"],
+    },
+  },
+};
+export const optimismSepolia: Chain = {
+  ...vops,
+  rpcUrls: {
+    ...vops.rpcUrls,
+    alchemy: {
+      http: ["https://opt-sepolia.g.alchemy.com/v2"],
+    },
+  },
+};
+export const sepolia: Chain = {
+  ...vsep,
+  rpcUrls: {
+    ...vsep.rpcUrls,
+    alchemy: {
+      http: ["https://eth-sepolia.g.alchemy.com/v2"],
+    },
+  },
+};
+export const base: Chain = {
+  ...vbase,
+  rpcUrls: {
+    ...vbase.rpcUrls,
+    alchemy: {
+      http: ["https://base-mainnet.g.alchemy.com/v2"],
+    },
+  },
+};
+export const baseGoerli: Chain = {
+  ...vbaseg,
+  rpcUrls: {
+    ...vbaseg.rpcUrls,
+    alchemy: {
+      http: ["https://base-goerli.g.alchemy.com/v2"],
+    },
+  },
+};
+export const baseSepolia: Chain = {
+  ...vbases,
+  rpcUrls: {
+    ...vbases.rpcUrls,
+    alchemy: {
+      http: ["https://base-sepolia.g.alchemy.com/v2"],
+    },
+  },
+};
+
+export const polygonMumbai: Chain = {
+  ...vpgm,
+  rpcUrls: {
+    ...vpgm.rpcUrls,
+    alchemy: {
+      http: ["https://polygon-mumbai.g.alchemy.com/v2"],
+    },
+  },
+};
+
+export const polygonAmoy: Chain = {
+  ...vpga,
+  rpcUrls: {
+    ...vpga.rpcUrls,
+    alchemy: {
+      http: ["https://polygon-amoy.g.alchemy.com/v2"],
+    },
+  },
+};
+
+export const polygon: Chain = {
+  ...vpg,
+  rpcUrls: {
+    ...vpg.rpcUrls,
+    alchemy: {
+      http: ["https://polygon-mainnet.g.alchemy.com/v2"],
+    },
+  },
+};
+
+export const fraxtal: Chain = {
+  ...vfrax,
+  rpcUrls: {
+    ...vfrax.rpcUrls,
+  },
+};
+
+export const fraxtalSepolia: Chain = defineChain({
+  id: 2523,
+  name: "Fraxtal Sepolia",
+  nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: ["https://rpc.testnet-sepolia.frax.com"],
+    },
+  },
+});
+
+export const zora: Chain = {
+  ...vzora,
+  rpcUrls: {
+    ...vzora.rpcUrls,
+  },
+};
+
+export const zoraSepolia: Chain = {
+  ...vzoras,
+  rpcUrls: {
+    ...vzoras.rpcUrls,
+  },
+};

package/src/client/bundlerClient.ts

@@ -0,0 +1,107 @@
+import {
+  createClient,
+  http,
+  publicActions,
+  type Chain,
+  type Client,
+  type FallbackTransport,
+  type HttpTransportConfig,
+  type PublicActions,
+  type PublicClient,
+  type PublicClientConfig,
+  type PublicRpcSchema,
+  type Transport,
+} from "viem";
+import { ChainNotFoundError } from "../errors/client.js";
+import { VERSION } from "../version.js";
+import {
+  bundlerActions,
+  type BundlerActions,
+  type BundlerRpcSchema,
+} from "./decorators/bundlerClient.js";
+
+// [!region BundlerClient]
+export type BundlerClient<T extends Transport = Transport> = Client<
+  T,
+  Chain,
+  undefined,
+  [...PublicRpcSchema, ...BundlerRpcSchema],
+  PublicActions<T, Chain> & BundlerActions
+>;
+
+export const createBundlerClientFromExisting: <
+  T extends Transport | FallbackTransport = Transport
+>(
+  client: PublicClient<T, Chain>
+) => BundlerClient<T> = <T extends Transport | FallbackTransport = Transport>(
+  client: PublicClient<T, Chain>
+): BundlerClient<T> => {
+  return client.extend(bundlerActions);
+};
+// [!endregion BundlerClient]
+
+/**
+ * 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
+ */
+export function createBundlerClient<TTransport extends Transport>(
+  args: PublicClientConfig<TTransport, Chain> & { type?: string }
+): BundlerClient<TTransport>;
+
+export function createBundlerClient(
+  args: PublicClientConfig & { type?: string }
+): BundlerClient {
+  if (!args.chain) {
+    throw new ChainNotFoundError();
+  }
+  const {
+    key = "bundler-public",
+    name = "Public Bundler Client",
+    type = "bundlerClient",
+  } = args;
+
+  const { transport, ...opts } = args;
+  const resolvedTransport = transport({
+    chain: args.chain,
+    pollingInterval: opts.pollingInterval,
+  });
+
+  const baseParameters = {
+    ...args,
+    key,
+    name,
+    type,
+  };
+
+  const client = (() => {
+    if (resolvedTransport.config.type === "http") {
+      const { url, fetchOptions: fetchOptions_ } = resolvedTransport.value as {
+        fetchOptions: HttpTransportConfig["fetchOptions"];
+        url: string;
+      };
+
+      const fetchOptions = fetchOptions_ ?? {};
+
+      if (url.toLowerCase().indexOf("alchemy") > -1) {
+        fetchOptions.headers = {
+          ...fetchOptions.headers,
+          "Alchemy-AA-Sdk-Version": VERSION,
+        };
+      }
+
+      return createClient<Transport, Chain>({
+        ...baseParameters,
+        transport: http(url, {
+          ...resolvedTransport.config,
+          fetchOptions,
+        }),
+      });
+    }
+
+    return createClient<Transport, Chain>(baseParameters);
+  })();
+
+  return client.extend(publicActions).extend(bundlerActions);
+}

package/src/client/decorators/bundlerClient.ts

@@ -0,0 +1,129 @@
+import type {
+  Address,
+  Chain,
+  Client,
+  Hash,
+  PublicRpcSchema,
+  RpcStateOverride,
+  StateOverride,
+  Transport,
+} from "viem";
+import { estimateUserOperationGas } from "../../actions/bundler/estimateUserOperationGas.js";
+import { getSupportedEntryPoints } from "../../actions/bundler/getSupportedEntryPoints.js";
+import { getUserOperationByHash } from "../../actions/bundler/getUserOperationByHash.js";
+import { getUserOperationReceipt } from "../../actions/bundler/getUserOperationReceipt.js";
+import { sendRawUserOperation } from "../../actions/bundler/sendRawUserOperation.js";
+import type { EntryPointVersion } from "../../entrypoint/types.js";
+import type {
+  UserOperationEstimateGasResponse,
+  UserOperationReceipt,
+  UserOperationRequest,
+  UserOperationResponse,
+} from "../../types.js";
+
+// Reference: https://eips.ethereum.org/EIPS/eip-4337#rpc-methods-eth-namespace
+export type BundlerRpcSchema = [
+  {
+    Method: "eth_sendUserOperation";
+    Parameters: [UserOperationRequest, Address];
+    ReturnType: Hash;
+  },
+  {
+    Method: "eth_estimateUserOperationGas";
+    Parameters: [UserOperationRequest, Address, RpcStateOverride?];
+    ReturnType: UserOperationEstimateGasResponse;
+  },
+  {
+    Method: "eth_getUserOperationReceipt";
+    Parameters: [Hash];
+    ReturnType: UserOperationReceipt | null;
+  },
+  {
+    Method: "eth_getUserOperationByHash";
+    Parameters: [Hash];
+    ReturnType: UserOperationResponse | null;
+  },
+  {
+    Method: "eth_supportedEntryPoints";
+    Parameters: [];
+    ReturnType: Address[];
+  }
+];
+
+// [!region BundlerActions]
+export type BundlerActions = {
+  /**
+   * calls `eth_estimateUserOperationGas` and  returns the result
+   *
+   * @param request - the {@link UserOperationRequest} to estimate gas for
+   * @param entryPoint - the entry point address the op will be sent to
+   * @param stateOverride - the state override to use for the estimation
+   * @returns the gas estimates for the given response (see: {@link UserOperationEstimateGasResponse})
+   */
+  estimateUserOperationGas<
+    TEntryPointVersion extends EntryPointVersion = EntryPointVersion
+  >(
+    request: UserOperationRequest<TEntryPointVersion>,
+    entryPoint: Address,
+    stateOverride?: StateOverride
+  ): Promise<UserOperationEstimateGasResponse<TEntryPointVersion>>;
+
+  /**
+   * calls `eth_sendUserOperation` and returns the hash of the sent UserOperation
+   *
+   * @param request - the {@link UserOperationRequest} to send
+   * @param entryPoint - the entry point address the op will be sent to
+   * @returns the hash of the sent UserOperation
+   */
+  sendRawUserOperation<
+    TEntryPointVersion extends EntryPointVersion = EntryPointVersion
+  >(
+    request: UserOperationRequest<TEntryPointVersion>,
+    entryPoint: Address
+  ): Promise<Hash>;
+
+  /**
+   * calls `eth_getUserOperationByHash` and returns the {@link UserOperationResponse}
+   *
+   * @param hash - the hash of the UserOperation to fetch
+   * @returns - {@link UserOperationResponse}
+   */
+  getUserOperationByHash(hash: Hash): Promise<UserOperationResponse | null>;
+
+  /**
+   * calls `eth_getUserOperationReceipt` and returns the {@link UserOperationReceipt}
+   *
+   * @param hash - the hash of the UserOperation to get the receipt for
+   * @returns - {@link UserOperationReceipt}
+   */
+  getUserOperationReceipt(hash: Hash): Promise<UserOperationReceipt | null>;
+
+  /**
+   * calls `eth_supportedEntryPoints` and returns the entry points the RPC supports
+   *
+   * @returns - {@link Address}[]
+   */
+  getSupportedEntryPoints(): Promise<Address[]>;
+};
+// [!endregion BundlerActions]
+
+export const bundlerActions: <
+  TClient extends Client<
+    Transport,
+    Chain | undefined,
+    any,
+    [...PublicRpcSchema, ...BundlerRpcSchema]
+  >
+>(
+  client: TClient
+) => BundlerActions = (client) => ({
+  estimateUserOperationGas: async (request, entryPoint, stateOverride) =>
+    estimateUserOperationGas(client, { request, entryPoint, stateOverride }),
+  sendRawUserOperation: async (request, entryPoint) =>
+    sendRawUserOperation(client, { request, entryPoint }),
+  getUserOperationByHash: async (hash) =>
+    getUserOperationByHash(client, { hash }),
+  getSupportedEntryPoints: async () => getSupportedEntryPoints(client),
+  getUserOperationReceipt: async (hash) =>
+    getUserOperationReceipt(client, { hash }),
+});