@account-kit/smart-contracts 4.0.0-alpha.0

package/src/light-account/actions/transferOwnership.ts

@@ -0,0 +1,67 @@
+import {
+  AccountNotFoundError,
+  IncompatibleClientError,
+  isSmartAccountClient,
+  type GetAccountParameter,
+  type GetEntryPointFromAccount,
+  type SmartAccountSigner,
+  type UserOperationOverridesParameter,
+} from "@aa-sdk/core";
+import type { Chain, Client, Hex, Transport } from "viem";
+import type { LightAccount } from "../accounts/account";
+
+export type TransferLightAccountOwnershipParams<
+  TSigner extends SmartAccountSigner = SmartAccountSigner,
+  TAccount extends LightAccount<TSigner> | undefined =
+    | LightAccount<TSigner>
+    | undefined,
+  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>
+> = {
+  newOwner: TSigner;
+  waitForTxn?: boolean;
+} & GetAccountParameter<TAccount, LightAccount<TSigner>> &
+  UserOperationOverridesParameter<TEntryPointVersion>;
+
+export const transferOwnership: <
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TSigner extends SmartAccountSigner = SmartAccountSigner,
+  TAccount extends LightAccount<TSigner> | undefined =
+    | LightAccount<TSigner>
+    | undefined
+>(
+  client: Client<TTransport, TChain, TAccount>,
+  args: TransferLightAccountOwnershipParams<TSigner, TAccount>
+) => Promise<Hex> = async (
+  client,
+  { newOwner, waitForTxn, overrides, account = client.account }
+) => {
+  if (!account) {
+    throw new AccountNotFoundError();
+  }
+
+  if (!isSmartAccountClient(client)) {
+    throw new IncompatibleClientError(
+      "SmartAccountClient",
+      "transferOwnership",
+      client
+    );
+  }
+
+  const data = account.encodeTransferOwnership(await newOwner.getAddress());
+
+  const result = await client.sendUserOperation({
+    uo: {
+      target: account.address,
+      data,
+    },
+    account,
+    overrides,
+  });
+
+  if (waitForTxn) {
+    return client.waitForUserOperationTransaction(result);
+  }
+
+  return result.hash;
+};

package/src/light-account/actions/updateOwners.ts

@@ -0,0 +1,74 @@
+import {
+  AccountNotFoundError,
+  IncompatibleClientError,
+  isSmartAccountClient,
+  type GetAccountParameter,
+  type GetEntryPointFromAccount,
+  type SmartAccountSigner,
+  type UserOperationOverridesParameter,
+} from "@aa-sdk/core";
+import type { Address, Chain, Client, Hex, Transport } from "viem";
+import type { MultiOwnerLightAccount } from "../accounts/multiOwner";
+
+export type UpdateMultiOwnerLightAccountOwnersParams<
+  TSigner extends SmartAccountSigner = SmartAccountSigner,
+  TAccount extends MultiOwnerLightAccount<TSigner> | undefined =
+    | MultiOwnerLightAccount<TSigner>
+    | undefined,
+  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>
+> = {
+  ownersToAdd: Address[];
+  ownersToRemove: Address[];
+  waitForTxn?: boolean;
+} & GetAccountParameter<TAccount, MultiOwnerLightAccount<TSigner>> &
+  UserOperationOverridesParameter<TEntryPointVersion>;
+
+export const updateOwners: <
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TSigner extends SmartAccountSigner = SmartAccountSigner,
+  TAccount extends MultiOwnerLightAccount<TSigner> | undefined =
+    | MultiOwnerLightAccount<TSigner>
+    | undefined
+>(
+  client: Client<TTransport, TChain, TAccount>,
+  args: UpdateMultiOwnerLightAccountOwnersParams<TSigner, TAccount>
+) => Promise<Hex> = async (
+  client,
+  {
+    ownersToAdd,
+    ownersToRemove,
+    waitForTxn,
+    overrides,
+    account = client.account,
+  }
+) => {
+  if (!account) {
+    throw new AccountNotFoundError();
+  }
+
+  if (!isSmartAccountClient(client)) {
+    throw new IncompatibleClientError(
+      "SmartAccountClient",
+      "updateOwners",
+      client
+    );
+  }
+
+  const data = account.encodeUpdateOwners(ownersToAdd, ownersToRemove);
+
+  const result = await client.sendUserOperation({
+    uo: {
+      target: account.address,
+      data,
+    },
+    account,
+    overrides,
+  });
+
+  if (waitForTxn) {
+    return client.waitForUserOperationTransaction(result);
+  }
+
+  return result.hash;
+};

package/src/light-account/clients/alchemyClient.ts

@@ -0,0 +1,64 @@
+import {
+  AlchemyProviderConfigSchema,
+  createAlchemyPublicRpcClient,
+  createAlchemySmartAccountClientFromExisting,
+  type AlchemySmartAccountClient,
+  type AlchemySmartAccountClientConfig,
+} from "@account-kit/infra";
+import {
+  createLightAccount,
+  lightAccountClientActions,
+  type CreateLightAccountParams,
+  type LightAccount,
+  type LightAccountClientActions,
+} from "@account-kit/smart-contracts";
+import type { HttpTransport, SmartAccountSigner } from "@aa-sdk/core";
+import { custom, type Chain, type CustomTransport, type Transport } from "viem";
+
+export type AlchemyLightAccountClientConfig<
+  TSigner extends SmartAccountSigner = SmartAccountSigner
+> = Omit<
+  CreateLightAccountParams<HttpTransport, TSigner>,
+  "transport" | "chain"
+> &
+  Omit<
+    AlchemySmartAccountClientConfig<Transport, Chain, LightAccount<TSigner>>,
+    "account"
+  >;
+
+export async function createLightAccountAlchemyClient<
+  TSigner extends SmartAccountSigner = SmartAccountSigner
+>(
+  params: AlchemyLightAccountClientConfig<TSigner>
+): Promise<
+  AlchemySmartAccountClient<
+    CustomTransport,
+    Chain | undefined,
+    LightAccount<TSigner>,
+    LightAccountClientActions<TSigner>
+  >
+>;
+
+export async function createLightAccountAlchemyClient(
+  config: AlchemyLightAccountClientConfig
+): Promise<AlchemySmartAccountClient> {
+  const { chain, opts, ...connectionConfig } =
+    AlchemyProviderConfigSchema.parse(config);
+
+  const client = createAlchemyPublicRpcClient({
+    chain,
+    connectionConfig,
+  });
+
+  const account = await createLightAccount({
+    transport: custom(client),
+    ...config,
+  });
+
+  return createAlchemySmartAccountClientFromExisting({
+    ...config,
+    client,
+    account,
+    opts,
+  }).extend(lightAccountClientActions);
+}

package/src/light-account/clients/client.ts

@@ -0,0 +1,69 @@
+import {
+  createSmartAccountClient,
+  type SmartAccountClient,
+  type SmartAccountClientActions,
+  type SmartAccountClientConfig,
+  type SmartAccountSigner,
+  type SmartContractAccount,
+} from "@aa-sdk/core";
+import { type Chain, type CustomTransport, type Transport } from "viem";
+import {
+  createLightAccount,
+  type CreateLightAccountParams,
+  type LightAccount,
+} from "../accounts/account.js";
+import {
+  lightAccountClientActions,
+  type LightAccountClientActions,
+} from "../decorators/lightAccount.js";
+
+export type CreateLightAccountClientParams<
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TSigner extends SmartAccountSigner = SmartAccountSigner
+> = {
+  transport: CreateLightAccountParams<TTransport, TSigner>["transport"];
+  chain: CreateLightAccountParams<TTransport, TSigner>["chain"];
+  account: Omit<
+    CreateLightAccountParams<TTransport, TSigner>,
+    "transport" | "chain"
+  >;
+} & Omit<
+  SmartAccountClientConfig<TTransport, TChain>,
+  "transport" | "account" | "chain"
+>;
+
+export function createLightAccountClient<
+  TChain extends Chain | undefined = Chain | undefined,
+  TSigner extends SmartAccountSigner = SmartAccountSigner
+>(
+  args: CreateLightAccountClientParams<Transport, TChain, TSigner>
+): Promise<
+  SmartAccountClient<
+    CustomTransport,
+    Chain,
+    LightAccount<TSigner>,
+    SmartAccountClientActions<Chain, SmartContractAccount> &
+      LightAccountClientActions<TSigner, LightAccount<TSigner>>
+  >
+>;
+
+export async function createLightAccountClient({
+  account,
+  transport,
+  chain,
+  ...clientConfig
+}: CreateLightAccountClientParams): Promise<SmartAccountClient> {
+  const lightAccount = await createLightAccount({
+    ...account,
+    transport,
+    chain,
+  });
+
+  return createSmartAccountClient({
+    ...clientConfig,
+    transport,
+    chain: chain,
+    account: lightAccount,
+  }).extend(lightAccountClientActions);
+}

package/src/light-account/clients/multiOwnerAlchemyClient.ts

@@ -0,0 +1,68 @@
+import {
+  AlchemyProviderConfigSchema,
+  createAlchemyPublicRpcClient,
+  createAlchemySmartAccountClientFromExisting,
+  type AlchemySmartAccountClient,
+  type AlchemySmartAccountClientConfig,
+} from "@account-kit/infra";
+import {
+  createMultiOwnerLightAccount,
+  multiOwnerLightAccountClientActions,
+  type CreateMultiOwnerLightAccountParams,
+  type MultiOwnerLightAccount,
+  type MultiOwnerLightAccountClientActions,
+} from "@account-kit/smart-contracts";
+import type { HttpTransport, SmartAccountSigner } from "@aa-sdk/core";
+import { custom, type Chain, type CustomTransport, type Transport } from "viem";
+
+export type AlchemyMultiOwnerLightAccountClientConfig<
+  TSigner extends SmartAccountSigner = SmartAccountSigner
+> = Omit<
+  CreateMultiOwnerLightAccountParams<HttpTransport, TSigner>,
+  "transport" | "chain"
+> &
+  Omit<
+    AlchemySmartAccountClientConfig<
+      Transport,
+      Chain,
+      MultiOwnerLightAccount<TSigner>
+    >,
+    "account"
+  >;
+
+export async function createMultiOwnerLightAccountAlchemyClient<
+  TSigner extends SmartAccountSigner = SmartAccountSigner
+>(
+  params: AlchemyMultiOwnerLightAccountClientConfig<TSigner>
+): Promise<
+  AlchemySmartAccountClient<
+    CustomTransport,
+    Chain | undefined,
+    MultiOwnerLightAccount<TSigner>,
+    MultiOwnerLightAccountClientActions<TSigner>
+  >
+>;
+
+export async function createMultiOwnerLightAccountAlchemyClient(
+  config: AlchemyMultiOwnerLightAccountClientConfig
+): Promise<AlchemySmartAccountClient> {
+  const { chain, opts, ...connectionConfig } =
+    AlchemyProviderConfigSchema.parse(config);
+
+  const client = createAlchemyPublicRpcClient({
+    chain,
+    connectionConfig,
+  });
+
+  const account = await createMultiOwnerLightAccount({
+    transport: custom(client),
+    ...config,
+  });
+
+  return createAlchemySmartAccountClientFromExisting({
+    ...config,
+    client,
+    account,
+    opts,
+  }).extend(multiOwnerLightAccountClientActions);
+}

package/src/light-account/clients/multiOwnerLightAccount.ts

@@ -0,0 +1,75 @@
+import {
+  createSmartAccountClient,
+  type SmartAccountClient,
+  type SmartAccountClientActions,
+  type SmartAccountClientConfig,
+  type SmartAccountSigner,
+  type SmartContractAccount,
+} from "@aa-sdk/core";
+import { type Chain, type CustomTransport, type Transport } from "viem";
+import {
+  createMultiOwnerLightAccount,
+  type CreateMultiOwnerLightAccountParams,
+  type MultiOwnerLightAccount,
+} from "../accounts/multiOwner.js";
+import {
+  multiOwnerLightAccountClientActions,
+  type MultiOwnerLightAccountClientActions,
+} from "../decorators/multiOwnerLightAccount.js";
+
+export type CreateMultiOwnerLightAccountClientParams<
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TSigner extends SmartAccountSigner = SmartAccountSigner
+> = {
+  transport: CreateMultiOwnerLightAccountParams<
+    TTransport,
+    TSigner
+  >["transport"];
+  chain: CreateMultiOwnerLightAccountParams<TTransport, TSigner>["chain"];
+  account: Omit<
+    CreateMultiOwnerLightAccountParams<TTransport, TSigner>,
+    "transport" | "chain"
+  >;
+} & Omit<
+  SmartAccountClientConfig<TTransport, TChain>,
+  "transport" | "account" | "chain"
+>;
+
+export function createMultiOwnerLightAccountClient<
+  TChain extends Chain | undefined = Chain | undefined,
+  TSigner extends SmartAccountSigner = SmartAccountSigner
+>(
+  args: CreateMultiOwnerLightAccountClientParams<Transport, TChain, TSigner>
+): Promise<
+  SmartAccountClient<
+    CustomTransport,
+    Chain,
+    MultiOwnerLightAccount<TSigner>,
+    SmartAccountClientActions<Chain, SmartContractAccount> &
+      MultiOwnerLightAccountClientActions<
+        TSigner,
+        MultiOwnerLightAccount<TSigner>
+      >
+  >
+>;
+
+export async function createMultiOwnerLightAccountClient({
+  account,
+  transport,
+  chain,
+  ...clientConfig
+}: CreateMultiOwnerLightAccountClientParams): Promise<SmartAccountClient> {
+  const lightAccount = await createMultiOwnerLightAccount({
+    ...account,
+    transport,
+    chain,
+  });
+
+  return createSmartAccountClient({
+    ...clientConfig,
+    transport,
+    chain: chain,
+    account: lightAccount,
+  }).extend(multiOwnerLightAccountClientActions);
+}

package/src/light-account/decorators/lightAccount.ts

@@ -0,0 +1,31 @@
+import type { SmartAccountSigner } from "@aa-sdk/core";
+import type { Chain, Client, Hex, Transport } from "viem";
+import type { LightAccount } from "../accounts/account";
+import {
+  transferOwnership,
+  type TransferLightAccountOwnershipParams,
+} from "../actions/transferOwnership.js";
+
+export type LightAccountClientActions<
+  TSigner extends SmartAccountSigner = SmartAccountSigner,
+  TAccount extends LightAccount<TSigner> | undefined =
+    | LightAccount<TSigner>
+    | undefined
+> = {
+  transferOwnership: (
+    args: TransferLightAccountOwnershipParams<TSigner, TAccount>
+  ) => Promise<Hex>;
+};
+
+export const lightAccountClientActions: <
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TSigner extends SmartAccountSigner = SmartAccountSigner,
+  TAccount extends LightAccount<TSigner> | undefined =
+    | LightAccount<TSigner>
+    | undefined
+>(
+  client: Client<TTransport, TChain, TAccount>
+) => LightAccountClientActions<TSigner, TAccount> = (client) => ({
+  transferOwnership: async (args) => transferOwnership(client, args),
+});

package/src/light-account/decorators/multiOwnerLightAccount.ts

@@ -0,0 +1,31 @@
+import type { SmartAccountSigner } from "@aa-sdk/core";
+import type { Chain, Client, Hex, Transport } from "viem";
+import type { MultiOwnerLightAccount } from "../accounts/multiOwner";
+import {
+  updateOwners,
+  type UpdateMultiOwnerLightAccountOwnersParams,
+} from "../actions/updateOwners.js";
+
+export type MultiOwnerLightAccountClientActions<
+  TSigner extends SmartAccountSigner = SmartAccountSigner,
+  TAccount extends MultiOwnerLightAccount<TSigner> | undefined =
+    | MultiOwnerLightAccount<TSigner>
+    | undefined
+> = {
+  updateOwners: (
+    args: UpdateMultiOwnerLightAccountOwnersParams<TSigner, TAccount>
+  ) => Promise<Hex>;
+};
+
+export const multiOwnerLightAccountClientActions: <
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TSigner extends SmartAccountSigner = SmartAccountSigner,
+  TAccount extends MultiOwnerLightAccount<TSigner> | undefined =
+    | MultiOwnerLightAccount<TSigner>
+    | undefined
+>(
+  client: Client<TTransport, TChain, TAccount>
+) => MultiOwnerLightAccountClientActions<TSigner, TAccount> = (client) => ({
+  updateOwners: async (args) => updateOwners(client, args),
+});

package/src/light-account/e2e-tests/constants.ts

@@ -0,0 +1,8 @@
+export const API_KEY = process.env.API_KEY!;
+export const API_KEY_STAGING = process.env.API_KEY_STAGING!;
+export const PAYMASTER_POLICY_ID = process.env.PAYMASTER_POLICY_ID!;
+export const PAYMASTER_POLICY_ID_STAGING =
+  process.env.PAYMASTER_POLICY_ID_STAGING!;
+export const UNDEPLOYED_OWNER_MNEMONIC = process.env.UNDEPLOYED_OWNER_MNEMONIC!;
+export const LIGHT_ACCOUNT_OWNER_MNEMONIC =
+  process.env.LIGHT_ACCOUNT_OWNER_MNEMONIC!;

package/src/light-account/schema.ts

@@ -0,0 +1,39 @@
+import { SignerSchema } from "@aa-sdk/core";
+import { Address } from "abitype/zod";
+import { isHex } from "viem";
+import { z } from "zod";
+import type { LightAccountVersion } from "./types.js";
+import { AccountVersionRegistry } from "./utils.js";
+
+const isLightAccountVersion = (x: unknown): x is LightAccountVersion => {
+  if (
+    typeof x === "string" &&
+    Object.keys(Object.values(AccountVersionRegistry).flat()).includes(x)
+  ) {
+    return true;
+  }
+
+  return false;
+};
+
+export const LightAccountFactoryConfigSchema = z.object({
+  signer: SignerSchema,
+  accountAddress: Address.optional().describe(
+    "Optional override for the account address."
+  ),
+  initCode: z
+    .string()
+    .refine(isHex, "initCode must be a valid hex.")
+    .optional()
+    .describe("Optional override for the account init code."),
+  factoryAddress: Address.optional().describe(
+    "Optional override for the factory address which deploys the smart account."
+  ),
+  version: z
+    .string()
+    .refine<LightAccountVersion>(
+      isLightAccountVersion,
+      "Version must be a valid Light Account version."
+    )
+    .optional(),
+});