@aa-sdk/core 4.0.0-alpha.0

package/src/entrypoint/0.6.ts

@@ -0,0 +1,74 @@
+import {
+  encodeAbiParameters,
+  hexToBigInt,
+  keccak256,
+  type Address,
+  type Chain,
+  type Hash,
+  type Hex,
+} from "viem";
+import { EntryPointAbi_v6 } from "../abis/EntryPointAbi_v6.js";
+import type { UserOperationRequest } from "../types.js";
+import type { SupportedEntryPoint } from "./types.js";
+
+const packUserOperation = (request: UserOperationRequest<"0.6.0">): Hex => {
+  const hashedInitCode = keccak256(request.initCode);
+  const hashedCallData = keccak256(request.callData);
+  const hashedPaymasterAndData = keccak256(request.paymasterAndData);
+
+  return encodeAbiParameters(
+    [
+      { type: "address" },
+      { type: "uint256" },
+      { type: "bytes32" },
+      { type: "bytes32" },
+      { type: "uint256" },
+      { type: "uint256" },
+      { type: "uint256" },
+      { type: "uint256" },
+      { type: "uint256" },
+      { type: "bytes32" },
+    ],
+    [
+      request.sender as Address,
+      hexToBigInt(request.nonce),
+      hashedInitCode,
+      hashedCallData,
+      hexToBigInt(request.callGasLimit),
+      hexToBigInt(request.verificationGasLimit),
+      hexToBigInt(request.preVerificationGas),
+      hexToBigInt(request.maxFeePerGas),
+      hexToBigInt(request.maxPriorityFeePerGas),
+      hashedPaymasterAndData,
+    ]
+  );
+};
+
+export default {
+  version: "0.6.0",
+
+  address: {
+    default: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
+  },
+
+  abi: EntryPointAbi_v6,
+
+  getUserOperationHash: (
+    request: UserOperationRequest<"0.6.0">,
+    entryPointAddress: Address,
+    chainId: number
+  ): Hash => {
+    const encoded = encodeAbiParameters(
+      [{ type: "bytes32" }, { type: "address" }, { type: "uint256" }],
+      [
+        keccak256(packUserOperation(request)),
+        entryPointAddress,
+        BigInt(chainId),
+      ]
+    );
+
+    return keccak256(encoded);
+  },
+
+  packUserOperation,
+} satisfies SupportedEntryPoint<"0.6.0", Chain, typeof EntryPointAbi_v6>;

package/src/entrypoint/0.7.ts

@@ -0,0 +1,153 @@
+import {
+  concat,
+  encodeAbiParameters,
+  hexToBigInt,
+  isAddress,
+  keccak256,
+  pad,
+  type Address,
+  type Chain,
+  type Hash,
+  type Hex,
+} from "viem";
+import { EntryPointAbi_v7 } from "../abis/EntryPointAbi_v7.js";
+import type {
+  UserOperationRequest,
+  UserOperationRequest_v7,
+} from "../types.js";
+import type { SupportedEntryPoint } from "./types.js";
+
+const packUserOperation = (request: UserOperationRequest<"0.7.0">): Hex => {
+  const initCode =
+    request.factory && request.factoryData
+      ? concat([request.factory, request.factoryData])
+      : "0x";
+  const accountGasLimits = packAccountGasLimits(
+    (({ verificationGasLimit, callGasLimit }) => ({
+      verificationGasLimit,
+      callGasLimit,
+    }))(request)
+  );
+
+  const gasFees = packAccountGasLimits(
+    (({ maxPriorityFeePerGas, maxFeePerGas }) => ({
+      maxPriorityFeePerGas,
+      maxFeePerGas,
+    }))(request)
+  );
+
+  const paymasterAndData =
+    request.paymaster && isAddress(request.paymaster)
+      ? packPaymasterData(
+          (({
+            paymaster,
+            paymasterVerificationGasLimit,
+            paymasterPostOpGasLimit,
+            paymasterData,
+          }) => ({
+            paymaster,
+            paymasterVerificationGasLimit,
+            paymasterPostOpGasLimit,
+            paymasterData,
+          }))(request)
+        )
+      : "0x";
+
+  return encodeAbiParameters(
+    [
+      { type: "address" },
+      { type: "uint256" },
+      { type: "bytes32" },
+      { type: "bytes32" },
+      { type: "bytes32" },
+      { type: "uint256" },
+      { type: "bytes32" },
+      { type: "bytes32" },
+    ],
+    [
+      request.sender as Address,
+      hexToBigInt(request.nonce),
+      keccak256(initCode),
+      keccak256(request.callData),
+      accountGasLimits,
+      hexToBigInt(request.preVerificationGas),
+      gasFees,
+      keccak256(paymasterAndData),
+    ]
+  );
+};
+
+export default {
+  version: "0.7.0",
+
+  address: {
+    default: "0x0000000071727De22E5E9d8BAf0edAc6f37da032",
+  },
+
+  abi: EntryPointAbi_v7,
+
+  getUserOperationHash: (
+    request: UserOperationRequest<"0.7.0">,
+    entryPointAddress: Address,
+    chainId: number
+  ): Hash => {
+    const encoded = encodeAbiParameters(
+      [{ type: "bytes32" }, { type: "address" }, { type: "uint256" }],
+      [
+        keccak256(packUserOperation(request)),
+        entryPointAddress,
+        BigInt(chainId),
+      ]
+    );
+
+    return keccak256(encoded);
+  },
+
+  packUserOperation,
+} satisfies SupportedEntryPoint<"0.7.0", Chain, typeof EntryPointAbi_v7>;
+
+export function packAccountGasLimits(
+  data:
+    | Pick<UserOperationRequest_v7, "verificationGasLimit" | "callGasLimit">
+    | Pick<UserOperationRequest_v7, "maxPriorityFeePerGas" | "maxFeePerGas">
+): Hex {
+  return concat(Object.values(data).map((v) => pad(v, { size: 16 })));
+}
+
+export function packPaymasterData({
+  paymaster,
+  paymasterVerificationGasLimit,
+  paymasterPostOpGasLimit,
+  paymasterData,
+}: Pick<
+  UserOperationRequest_v7,
+  | "paymaster"
+  | "paymasterVerificationGasLimit"
+  | "paymasterPostOpGasLimit"
+  | "paymasterData"
+>): Hex {
+  if (
+    !paymaster ||
+    !paymasterVerificationGasLimit ||
+    !paymasterPostOpGasLimit ||
+    !paymasterData
+  ) {
+    return "0x";
+  }
+  return concat([
+    paymaster,
+    pad(paymasterVerificationGasLimit, { size: 16 }),
+    pad(paymasterPostOpGasLimit, { size: 16 }),
+    paymasterData,
+  ]);
+}
+
+export function unpackAccountGasLimits(accountGasLimits: string): {
+  verificationGasLimit: number;
+  callGasLimit: number;
+} {
+  return {
+    verificationGasLimit: parseInt(accountGasLimits.slice(2, 34), 16),
+    callGasLimit: parseInt(accountGasLimits.slice(34), 16),
+  };
+}

package/src/entrypoint/index.ts

@@ -0,0 +1,152 @@
+import { type Chain } from "viem";
+import { EntryPointNotFoundError } from "../errors/entrypoint.js";
+import EntryPoint_v6 from "./0.6.js";
+import EntryPoint_v7 from "./0.7.js";
+import type {
+  DefaultEntryPointVersion,
+  EntryPointDefRegistry,
+  EntryPointRegistry,
+  EntryPointVersion,
+  GetEntryPointOptions,
+} from "./types.js";
+
+export const defaultEntryPointVersion: DefaultEntryPointVersion = "0.6.0";
+
+export const entryPointRegistry: EntryPointRegistry = {
+  "0.6.0": EntryPoint_v6,
+  "0.7.0": EntryPoint_v7,
+};
+
+export const isEntryPointVersion = (
+  value: any
+): value is keyof EntryPointRegistry => {
+  return Object.keys(entryPointRegistry).includes(value);
+};
+
+export function getEntryPoint<
+  TEntryPointVersion extends EntryPointVersion = DefaultEntryPointVersion,
+  TChain extends Chain = Chain
+>(
+  chain: TChain,
+  options: GetEntryPointOptions<TEntryPointVersion>
+): EntryPointDefRegistry<TChain>[TEntryPointVersion];
+
+export function getEntryPoint<
+  TEntryPointVersion extends DefaultEntryPointVersion = DefaultEntryPointVersion,
+  TChain extends Chain = Chain
+>(
+  chain: TChain,
+  options?: GetEntryPointOptions<TEntryPointVersion>
+): EntryPointDefRegistry<TChain>[TEntryPointVersion];
+
+export function getEntryPoint<TChain extends Chain = Chain>(
+  chain: TChain,
+  options?: GetEntryPointOptions<DefaultEntryPointVersion>
+): EntryPointDefRegistry<TChain>[DefaultEntryPointVersion];
+
+export function getEntryPoint<
+  TEntryPointVersion extends EntryPointVersion,
+  TChain extends Chain = Chain
+>(
+  chain: TChain,
+  options: GetEntryPointOptions<TEntryPointVersion>
+): EntryPointDefRegistry<TChain>[EntryPointVersion] {
+  const { version = defaultEntryPointVersion, addressOverride } = options ?? {
+    version: defaultEntryPointVersion,
+  };
+
+  const entryPoint = entryPointRegistry[version ?? defaultEntryPointVersion];
+  const address =
+    addressOverride ??
+    entryPoint.address[chain.id] ??
+    entryPoint.address.default;
+  if (!address) {
+    throw new EntryPointNotFoundError(chain, version);
+  }
+
+  if (entryPoint.version === "0.6.0") {
+    return {
+      version: entryPoint.version,
+      address,
+      chain,
+      abi: entryPoint.abi,
+      getUserOperationHash: (r) =>
+        entryPoint.getUserOperationHash(r, address, chain.id),
+      packUserOperation: entryPoint.packUserOperation,
+    };
+  } else if (entryPoint.version === "0.7.0") {
+    return {
+      version: entryPoint.version,
+      address,
+      chain,
+      abi: entryPoint.abi,
+      getUserOperationHash: (r) =>
+        entryPoint.getUserOperationHash(r, address, chain.id),
+      packUserOperation: entryPoint.packUserOperation,
+    };
+  }
+
+  throw new EntryPointNotFoundError(chain, version);
+}
+
+// // =================================================================================
+// // TODO: Add tests for the following cases
+
+// const chain: Chain = mainnet;
+
+// // 1. left and right hand side version type should match, as well as the param
+
+// // === Error ===
+// const ep1_a: EntryPointDef<"0.6.0"> = getEntryPoint(chain, {
+//   version: "0.7.0",
+// }); // error
+// const ep1_b: EntryPointDef<"0.7.0"> = getEntryPoint(chain); // error
+// const ep1_c: EntryPointDef<"0.6.0"> = getEntryPoint(chain, {
+//   version: "0.7.0",
+// }); // error
+// const ep1_d: EntryPointDef<"0.6.0"> = getEntryPoint<"0.6.0">(chain, {
+//   version: "0.7.0",
+// }); // error
+
+// // === Valid ===
+// const ep1a: EntryPointDef<"0.6.0"> = getEntryPoint(chain);
+// const ep1b: EntryPointDef<"0.6.0"> = getEntryPoint(chain, { version: "0.6.0" });
+// const ep1c: EntryPointDef<"0.7.0"> = getEntryPoint(chain, { version: "0.7.0" });
+// const ep1d: EntryPointDef<"0.6.0"> = getEntryPoint(chain, {
+//   addressOverride: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
+// });
+// const ep1e: EntryPointDef<"0.6.0"> = getEntryPoint(chain, {
+//   addressOverride: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
+//   version: "0.6.0",
+// });
+// const ep1f: EntryPointDef<"0.7.0"> = getEntryPoint(chain, {
+//   addressOverride: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
+//   version: "0.7.0",
+// });
+
+// // 2. If non-default type is specified, version option param of the type is required
+
+// // === Error ===
+// const ep2_a: EntryPointDef<"0.7.0"> = getEntryPoint<"0.7.0">(chain); // error
+// const ep2_b: EntryPointDef<"0.7.0"> = getEntryPoint<"0.7.0">(chain, {
+//   addressOverride: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
+// });
+
+// // === Valid ===
+// const ep2a: EntryPointDef<"0.7.0"> = getEntryPoint<"0.7.0">(chain, {
+//   version: "0.7.0",
+//   addressOverride: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
+// });
+// const ep2b: EntryPointDef<"0.6.0"> = getEntryPoint<"0.6.0">(chain, {
+//   version: "0.6.0",
+// });
+// const ep2c: EntryPointDef<"0.6.0"> = getEntryPoint<"0.6.0">(chain);
+// const ep2d: EntryPointDef<"0.6.0"> = getEntryPoint<"0.6.0">(chain, {
+//   addressOverride: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
+// });
+// const ep2e: EntryPointDef<"0.7.0"> = getEntryPoint<"0.7.0">(chain, {
+//   version: "0.7.0",
+//   addressOverride: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
+// });
+
+// // =================================================================================

package/src/entrypoint/types.ts

@@ -0,0 +1,120 @@
+import type {
+  Abi,
+  Account,
+  Address,
+  Chain,
+  GetContractParameters,
+  Hash,
+  Hex,
+  Transport,
+} from "viem";
+import type { EntryPointAbi_v6 } from "../abis/EntryPointAbi_v6";
+import type { EntryPointAbi_v7 } from "../abis/EntryPointAbi_v7";
+import type { UserOperationRequest } from "../types";
+import type { EQ, IsOneOf, OneOf } from "../utils";
+
+export interface EntryPointRegistryBase<T> {
+  "0.6.0": T;
+  "0.7.0": T;
+}
+export type EntryPointVersion = keyof EntryPointRegistryBase<unknown>;
+export type DefaultEntryPointVersion = OneOf<"0.6.0", EntryPointVersion>;
+
+export type SupportedEntryPoint<
+  TEntryPointVersion extends EntryPointVersion = EntryPointVersion,
+  TChain extends Chain = Chain,
+  TAbi extends Abi | readonly unknown[] = Abi
+> = {
+  version: TEntryPointVersion;
+  address: Record<TChain["id"] | "default", Address>;
+  abi: GetContractParameters<Transport, TChain, Account, TAbi>["abi"];
+
+  /**
+   * Generates a hash for a UserOperation valid from entry point version 0.6 onwards
+   *
+   * @param request - the UserOperation to get the hash for
+   * @param entryPointAddress - the entry point address that will be used to execute the UserOperation
+   * @param chainId - the chain on which this UserOperation will be executed
+   * @returns the hash of the UserOperation
+   */
+  getUserOperationHash: (
+    request: UserOperationRequest<TEntryPointVersion>,
+    entryPointAddress: Address,
+    chainId: number
+  ) => Hash;
+
+  /**
+   * Pack the user operation data into bytes for hashing for entry point version 0.6 onwards
+   * Reference:
+   * v6: https://github.com/eth-infinitism/account-abstraction/blob/releases/v0.6/test/UserOp.ts#L16-L61
+   * v7: https://github.com/eth-infinitism/account-abstraction/blob/releases/v0.7/test/UserOp.ts#L28-L67
+   *
+   * @param request - the UserOperation to get the hash for
+   * @returns the hash of the UserOperation
+   */
+  packUserOperation: (
+    userOperation: UserOperationRequest<TEntryPointVersion>
+  ) => Hex;
+};
+
+export interface EntryPointRegistry<TChain extends Chain = Chain>
+  extends EntryPointRegistryBase<
+    SupportedEntryPoint<EntryPointVersion, TChain, Abi>
+  > {
+  "0.6.0": SupportedEntryPoint<"0.6.0", TChain, typeof EntryPointAbi_v6>;
+  "0.7.0": SupportedEntryPoint<"0.7.0", TChain, typeof EntryPointAbi_v7>;
+}
+
+// [!region EntryPointDef]
+export type EntryPointDef<
+  TEntryPointVersion extends EntryPointVersion = EntryPointVersion,
+  TChain extends Chain = Chain,
+  TAbi extends Abi | readonly unknown[] = Abi
+> = {
+  version: TEntryPointVersion;
+  address: Address;
+  chain: TChain;
+  abi: GetContractParameters<Transport, TChain, Account, TAbi>["abi"];
+  getUserOperationHash: (
+    request: UserOperationRequest<TEntryPointVersion>
+  ) => Hex;
+  packUserOperation: (
+    userOperation: UserOperationRequest<TEntryPointVersion>
+  ) => Hex;
+};
+// [!endregion EntryPointDef]
+
+export interface EntryPointDefRegistry<TChain extends Chain = Chain>
+  extends EntryPointRegistryBase<
+    EntryPointDef<EntryPointVersion, TChain, Abi>
+  > {
+  "0.6.0": EntryPointDef<"0.6.0", TChain, typeof EntryPointAbi_v6>;
+  "0.7.0": EntryPointDef<"0.7.0", TChain, typeof EntryPointAbi_v7>;
+}
+
+export type GetEntryPointOptions<
+  TEntryPointVersion extends EntryPointVersion = DefaultEntryPointVersion
+> = EQ<TEntryPointVersion, DefaultEntryPointVersion> extends true
+  ?
+      | {
+          addressOverride?: Address;
+          version?: OneOf<TEntryPointVersion, EntryPointVersion>;
+        }
+      | undefined
+  : {
+      addressOverride?: Address;
+      version: OneOf<TEntryPointVersion, EntryPointVersion>;
+    };
+
+export type EntryPointParameter<
+  TEntryPointVersion extends EntryPointVersion,
+  TChain extends Chain = Chain
+> = EQ<TEntryPointVersion, DefaultEntryPointVersion> extends true
+  ? {
+      entryPoint?: EntryPointDef<TEntryPointVersion, TChain>;
+    }
+  : {
+      entryPoint: IsOneOf<TEntryPointVersion, EntryPointVersion> extends true
+        ? EntryPointDef<TEntryPointVersion, TChain>
+        : never;
+    };

package/src/errors/account.ts

@@ -0,0 +1,87 @@
+import type { Chain } from "viem";
+import type { EntryPointVersion } from "../entrypoint/types.js";
+import { BaseError } from "./base.js";
+
+export class AccountNotFoundError extends BaseError {
+  override name = "AccountNotFoundError";
+
+  // TODO: extend this further using docs path as well
+  constructor() {
+    super("Could not find an Account to execute with this Action.");
+  }
+}
+
+export class DefaultFactoryNotDefinedError extends BaseError {
+  override name = "DefaultFactoryNotDefinedError";
+  constructor(accountType: string, chain: Chain, version: EntryPointVersion) {
+    super(
+      [
+        `No default factory for ${accountType} found on chain ${chain.name} for entrypoint version ${version}`,
+        "Supply an override via the `factoryAddress` parameter when creating an account",
+      ].join("\n")
+    );
+  }
+}
+
+export class GetCounterFactualAddressError extends BaseError {
+  override name = "GetCounterFactualAddressError";
+  constructor() {
+    super("getCounterFactualAddress failed");
+  }
+}
+
+export class UpgradesNotSupportedError extends BaseError {
+  override name = "UpgradesNotSupported";
+  constructor(accountType: string) {
+    super(`Upgrades are not supported by ${accountType}`);
+  }
+}
+
+export class SignTransactionNotSupportedError extends BaseError {
+  override name = "SignTransactionNotSupported";
+  constructor() {
+    super(`SignTransaction is not supported by smart contracts`);
+  }
+}
+
+export class FailedToGetStorageSlotError extends BaseError {
+  override name = "FailedToGetStorageSlotError";
+  constructor(slot: string, slotDescriptor: string) {
+    super(`Failed to get storage slot ${slot} (${slotDescriptor})`);
+  }
+}
+
+export class BatchExecutionNotSupportedError extends BaseError {
+  override name = "BatchExecutionNotSupportedError";
+  constructor(accountType: string) {
+    super(`Batch execution is not supported by ${accountType}`);
+  }
+}
+
+export class AccountRequiresOwnerError extends BaseError {
+  override name = "AccountRequiresOwnerError";
+  constructor(accountType: string) {
+    super(`Account of type ${accountType} requires an owner to execute`);
+  }
+}
+
+export class UpgradeToAndCallNotSupportedError extends BaseError {
+  override name = "UpgradeToAndCallNotSupportedError";
+  constructor(accountType: string) {
+    super(`UpgradeToAndCall is not supported by ${accountType}`);
+  }
+}
+
+export class IncorrectAccountType extends BaseError {
+  override name = "IncorrectAccountTypeError";
+  constructor(expected: string, actual: string) {
+    super(`Expected account type ${expected}, got ${actual}`);
+  }
+}
+
+export class SmartAccountWithSignerRequiredError extends BaseError {
+  override name = "SmartAccountWithSignerRequiredError";
+  constructor() {
+    super("Smart account requires a signer");
+  }
+}

package/src/errors/base.ts

@@ -0,0 +1,48 @@
+import { BaseError as ViemBaseError } from "viem";
+import { VERSION } from "../version.js";
+
+type BaseErrorParameters = {
+  docsPath?: string;
+  docsSlug?: string;
+  metaMessages?: string[];
+} & (
+  | {
+      cause?: never;
+      details?: string;
+    }
+  | {
+      cause: BaseError | Error;
+      details?: never;
+    }
+);
+
+// This is based on on viem's BaseError type (obviously from the import and extend)
+// we want the errors here to point to our docs if we supply a docsPath though
+export class BaseError extends ViemBaseError {
+  override name = "AASDKError";
+  override version = VERSION;
+
+  constructor(shortMessage: string, args: BaseErrorParameters = {}) {
+    super(shortMessage, args);
+
+    const docsPath =
+      args.cause instanceof BaseError
+        ? args.cause.docsPath || args.docsPath
+        : args.docsPath;
+
+    this.message = [
+      shortMessage || "An error occurred.",
+      "",
+      ...(args.metaMessages ? [...args.metaMessages, ""] : []),
+      ...(docsPath
+        ? [
+            `Docs: https://accountkit.alchemy.com${docsPath}${
+              args.docsSlug ? `#${args.docsSlug}` : ""
+            }`,
+          ]
+        : []),
+      ...(this.details ? [`Details: ${this.details}`] : []),
+      `Version: ${this.version}`,
+    ].join("\n");
+  }
+}

package/src/errors/client.ts

@@ -0,0 +1,28 @@
+import type { Client } from "viem";
+import { BaseError } from "./base.js";
+
+export class IncompatibleClientError extends BaseError {
+  override name = "IncompatibleClientError";
+  constructor(expectedClient: string, method: string, client: Client) {
+    super(
+      [
+        `Client of type (${client.type}) is not a ${expectedClient}.`,
+        `Create one with \`createSmartAccountClient\` first before using \`${method}\``,
+      ].join("\n")
+    );
+  }
+}
+
+export class InvalidRpcUrlError extends BaseError {
+  override name = "InvalidRpcUrlError";
+  constructor(rpcUrl?: string) {
+    super(`Invalid RPC URL ${rpcUrl}`);
+  }
+}
+
+export class ChainNotFoundError extends BaseError {
+  override name = "ChainNotFoundError";
+  constructor() {
+    super("No chain supplied to the client");
+  }
+}

package/src/errors/entrypoint.ts

@@ -0,0 +1,25 @@
+import type { Chain } from "viem";
+import { BaseError } from "./base.js";
+
+export class EntryPointNotFoundError extends BaseError {
+  override name = "EntryPointNotFoundError";
+
+  constructor(chain: Chain, entryPointVersion: any) {
+    super(
+      [
+        `No default entry point v${entryPointVersion} exists for ${chain.name}.`,
+        `Supply an override.`,
+      ].join("\n")
+    );
+  }
+}
+
+export class InvalidEntryPointError extends BaseError {
+  override name = "InvalidEntryPointError";
+
+  constructor(chain: Chain, entryPointVersion: any) {
+    super(
+      `Invalid entry point: unexpected version ${entryPointVersion} for ${chain.name}.`
+    );
+  }
+}