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

package/src/light-account/accounts/account.ts

@@ -0,0 +1,198 @@
+import {
+  createBundlerClient,
+  getAccountAddress,
+  getEntryPoint,
+  type Address,
+  type EntryPointDef,
+  type SmartAccountSigner,
+} from "@aa-sdk/core";
+import {
+  concatHex,
+  encodeFunctionData,
+  type Chain,
+  type Hex,
+  type Transport,
+} from "viem";
+import { LightAccountAbi_v1 } from "../abis/LightAccountAbi_v1.js";
+import { LightAccountAbi_v2 } from "../abis/LightAccountAbi_v2.js";
+import { LightAccountFactoryAbi_v1 } from "../abis/LightAccountFactoryAbi_v1.js";
+import { LightAccountFactoryAbi_v2 } from "../abis/LightAccountFactoryAbi_v2.js";
+import type {
+  GetEntryPointForLightAccountVersion,
+  GetLightAccountVersion,
+} from "../types.js";
+import {
+  AccountVersionRegistry,
+  LightAccountUnsupported1271Factories,
+  defaultLightAccountVersion,
+} from "../utils.js";
+import {
+  createLightAccountBase,
+  type CreateLightAccountBaseParams,
+  type LightAccountBase,
+} from "./base.js";
+
+export type LightAccount<
+  TSigner extends SmartAccountSigner = SmartAccountSigner,
+  TLightAccountVersion extends GetLightAccountVersion<"LightAccount"> = GetLightAccountVersion<"LightAccount">,
+  TEntryPointVersion extends GetEntryPointForLightAccountVersion<
+    "LightAccount",
+    TLightAccountVersion
+  > = GetEntryPointForLightAccountVersion<"LightAccount", TLightAccountVersion>
+> = LightAccountBase<
+  TSigner,
+  "LightAccount",
+  TLightAccountVersion,
+  TEntryPointVersion
+> & {
+  encodeTransferOwnership: (newOwner: Address) => Hex;
+  getOwnerAddress: () => Promise<Address>;
+};
+
+// [!region CreateLightAccountParams]
+export type CreateLightAccountParams<
+  TTransport extends Transport = Transport,
+  TSigner extends SmartAccountSigner = SmartAccountSigner,
+  TLightAccountVersion extends GetLightAccountVersion<"LightAccount"> = GetLightAccountVersion<"LightAccount">,
+  TEntryPointVersion extends GetEntryPointForLightAccountVersion<
+    "LightAccount",
+    TLightAccountVersion
+  > = GetEntryPointForLightAccountVersion<"LightAccount", TLightAccountVersion>
+> = Omit<
+  CreateLightAccountBaseParams<
+    TTransport,
+    TSigner,
+    "LightAccount",
+    TLightAccountVersion,
+    TEntryPointVersion
+  >,
+  "getAccountInitCode" | "entryPoint" | "version" | "abi" | "accountAddress"
+> & {
+  salt?: bigint;
+  initCode?: Hex;
+  accountAddress?: Address;
+  factoryAddress?: Address;
+  version?: TLightAccountVersion;
+  entryPoint?: EntryPointDef<TEntryPointVersion, Chain>;
+};
+// [!endregion CreateLightAccountParams]
+
+export async function createLightAccount<
+  TTransport extends Transport = Transport,
+  TSigner extends SmartAccountSigner = SmartAccountSigner,
+  TLightAccountVersion extends GetLightAccountVersion<"LightAccount"> = "v1.1.0"
+>(
+  config: CreateLightAccountParams<TTransport, TSigner, TLightAccountVersion>
+): Promise<LightAccount<TSigner, TLightAccountVersion>>;
+
+export async function createLightAccount<
+  TTransport extends Transport = Transport,
+  TSigner extends SmartAccountSigner = SmartAccountSigner,
+  TLightAccountVersion extends GetLightAccountVersion<"LightAccount"> = GetLightAccountVersion<"LightAccount">,
+  TEntryPointVersion extends GetEntryPointForLightAccountVersion<
+    "LightAccount",
+    TLightAccountVersion
+  > = GetEntryPointForLightAccountVersion<"LightAccount", TLightAccountVersion>
+>(
+  config: CreateLightAccountParams<
+    TTransport,
+    TSigner,
+    TLightAccountVersion,
+    TEntryPointVersion
+  >
+): Promise<LightAccount<TSigner, TLightAccountVersion, TEntryPointVersion>>;
+
+export async function createLightAccount({
+  transport,
+  chain,
+  signer,
+  initCode,
+  version = defaultLightAccountVersion("LightAccount"),
+  entryPoint = getEntryPoint(chain, {
+    version: AccountVersionRegistry["LightAccount"][version]
+      .entryPointVersion as any,
+  }),
+  accountAddress,
+  factoryAddress = AccountVersionRegistry["LightAccount"][version].address[
+    chain.id
+  ].factory,
+  salt: salt_ = 0n,
+}: CreateLightAccountParams): Promise<LightAccount> {
+  const client = createBundlerClient({
+    transport,
+    chain,
+  });
+
+  const accountAbi =
+    version === "v2.0.0" ? LightAccountAbi_v2 : LightAccountAbi_v1;
+  const factoryAbi =
+    version === "v2.0.0"
+      ? LightAccountFactoryAbi_v1
+      : LightAccountFactoryAbi_v2;
+
+  const getAccountInitCode = async () => {
+    if (initCode) return initCode;
+
+    const salt = LightAccountUnsupported1271Factories.has(
+      factoryAddress.toLowerCase() as Address
+    )
+      ? 0n
+      : salt_;
+
+    return concatHex([
+      factoryAddress,
+      encodeFunctionData({
+        abi: factoryAbi,
+        functionName: "createAccount",
+        args: [await signer.getAddress(), salt],
+      }),
+    ]);
+  };
+
+  const address = await getAccountAddress({
+    client,
+    entryPoint,
+    accountAddress,
+    getAccountInitCode,
+  });
+
+  const account = await createLightAccountBase<
+    Transport,
+    SmartAccountSigner,
+    "LightAccount"
+  >({
+    transport,
+    chain,
+    signer,
+    abi: accountAbi,
+    version: AccountVersionRegistry["LightAccount"][version],
+    entryPoint,
+    accountAddress: address,
+    getAccountInitCode,
+  });
+
+  return {
+    ...account,
+
+    encodeTransferOwnership: (newOwner: Address) => {
+      return encodeFunctionData({
+        abi: accountAbi,
+        functionName: "transferOwnership",
+        args: [newOwner],
+      });
+    },
+    async getOwnerAddress(): Promise<Address> {
+      const callResult = await client.readContract({
+        address,
+        abi: accountAbi,
+        functionName: "owner",
+      });
+
+      if (callResult == null) {
+        throw new Error("could not get on-chain owner");
+      }
+
+      return callResult;
+    },
+  };
+}

package/src/light-account/accounts/base.ts

@@ -0,0 +1,291 @@
+import {
+  FailedToGetStorageSlotError,
+  createBundlerClient,
+  toSmartContractAccount,
+  type Abi,
+  type EntryPointDef,
+  type SmartAccountSigner,
+  type SmartContractAccountWithSigner,
+  type ToSmartContractAccountParams,
+  type UpgradeToAndCallParams,
+} from "@aa-sdk/core";
+import {
+  concat,
+  encodeFunctionData,
+  fromHex,
+  hashMessage,
+  hashTypedData,
+  trim,
+  type Address,
+  type Chain,
+  type Hex,
+  type SignTypedDataParameters,
+  type Transport,
+} from "viem";
+import type {
+  AccountVersionDef,
+  GetEntryPointForLightAccountVersion,
+  GetLightAccountVersion,
+  LightAccountType,
+  LightAccountVersionDef,
+} from "../types.js";
+import { AccountVersionRegistry } from "../utils.js";
+
+enum SignatureType {
+  EOA = "0x00",
+  CONTRACT = "0x01",
+  CONTRACT_WITH_ADDR = "0x02",
+}
+
+export type LightAccountBase<
+  TSigner extends SmartAccountSigner = SmartAccountSigner,
+  TLightAccountType extends LightAccountType = LightAccountType,
+  TLightAccountVersion extends GetLightAccountVersion<TLightAccountType> = GetLightAccountVersion<TLightAccountType>,
+  TEntryPointVersion extends GetEntryPointForLightAccountVersion<
+    TLightAccountType,
+    TLightAccountVersion
+  > = GetEntryPointForLightAccountVersion<
+    TLightAccountType,
+    TLightAccountVersion
+  >
+> = SmartContractAccountWithSigner<
+  TLightAccountType,
+  TSigner,
+  TEntryPointVersion
+> & {
+  getLightAccountVersion: () => TLightAccountVersion;
+};
+
+//#region CreateLightAccountBaseParams
+export type CreateLightAccountBaseParams<
+  TTransport extends Transport = Transport,
+  TSigner extends SmartAccountSigner = SmartAccountSigner,
+  TLightAccountType extends LightAccountType = LightAccountType,
+  TLightAccountVersion extends GetLightAccountVersion<TLightAccountType> = GetLightAccountVersion<TLightAccountType>,
+  TEntryPointVersion extends GetEntryPointForLightAccountVersion<
+    TLightAccountType,
+    TLightAccountVersion
+  > = GetEntryPointForLightAccountVersion<
+    TLightAccountType,
+    TLightAccountVersion
+  >
+> = Pick<
+  ToSmartContractAccountParams<
+    TLightAccountType,
+    TTransport,
+    Chain,
+    TEntryPointVersion
+  >,
+  "transport" | "chain" | "getAccountInitCode"
+> & {
+  abi: Abi;
+  signer: TSigner;
+  accountAddress: Address;
+  version: LightAccountVersionDef<TLightAccountType, TLightAccountVersion>;
+  entryPoint: EntryPointDef<TEntryPointVersion, Chain>;
+};
+//#endregion CreateLightAccountBaseParams
+
+export async function createLightAccountBase<
+  TTransport extends Transport = Transport,
+  TSigner extends SmartAccountSigner = SmartAccountSigner,
+  TLightAccountType extends LightAccountType = LightAccountType,
+  TLightAccountVersion extends GetLightAccountVersion<TLightAccountType> = GetLightAccountVersion<TLightAccountType>,
+  TEntryPointVersion extends GetEntryPointForLightAccountVersion<
+    TLightAccountType,
+    TLightAccountVersion
+  > = GetEntryPointForLightAccountVersion<
+    TLightAccountType,
+    TLightAccountVersion
+  >
+>(
+  config: CreateLightAccountBaseParams<
+    TTransport,
+    TSigner,
+    TLightAccountType,
+    TLightAccountVersion,
+    TEntryPointVersion
+  >
+): Promise<
+  LightAccountBase<
+    TSigner,
+    TLightAccountType,
+    TLightAccountVersion,
+    TEntryPointVersion
+  >
+>;
+
+export async function createLightAccountBase({
+  transport,
+  chain,
+  signer,
+  abi,
+  version: { version, type },
+  entryPoint,
+  accountAddress,
+  getAccountInitCode,
+}: CreateLightAccountBaseParams): Promise<LightAccountBase> {
+  const client = createBundlerClient({
+    transport,
+    chain,
+  });
+
+  const encodeUpgradeToAndCall = async ({
+    upgradeToAddress,
+    upgradeToInitData,
+  }: UpgradeToAndCallParams): Promise<Hex> => {
+    const storage = await client.getStorageAt({
+      address: accountAddress,
+      // the slot at which impl addresses are stored by UUPS
+      slot: "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc",
+    });
+
+    if (storage == null) {
+      throw new FailedToGetStorageSlotError(
+        "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc",
+        "Proxy Implementation Address"
+      );
+    }
+
+    const implementationAddresses = Object.values(
+      AccountVersionRegistry[type]
+    ).map((x: AccountVersionDef) => x.address[chain.id].impl);
+
+    // only upgrade undeployed accounts (storage 0) or deployed light accounts, error otherwise
+    if (
+      fromHex(storage, "number") !== 0 &&
+      !implementationAddresses.some((x) => x === trim(storage))
+    ) {
+      throw new Error(
+        `could not determine if smart account implementation is ${type} ${version}`
+      );
+    }
+
+    return encodeFunctionData({
+      abi,
+      functionName: "upgradeToAndCall",
+      args: [upgradeToAddress, upgradeToInitData],
+    });
+  };
+
+  const signWith1271WrapperV1 = async (hashedMessage: Hex): Promise<Hex> => {
+    return signer.signTypedData({
+      // EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)
+      // https://github.com/alchemyplatform/light-account/blob/main/src/LightAccount.sol#L236
+      domain: {
+        chainId: Number(client.chain.id),
+        name: type,
+        verifyingContract: accountAddress,
+        version: "1",
+      },
+      types: {
+        LightAccountMessage: [{ name: "message", type: "bytes" }],
+      },
+      message: {
+        message: hashedMessage,
+      },
+      primaryType: "LightAccountMessage",
+    });
+  };
+
+  const account = await toSmartContractAccount({
+    transport,
+    chain,
+    entryPoint,
+    accountAddress,
+    source: type,
+    getAccountInitCode,
+    encodeExecute: async ({ target, data, value }) => {
+      return encodeFunctionData({
+        abi,
+        functionName: "execute",
+        args: [target, value ?? 0n, data],
+      });
+    },
+    encodeBatchExecute: async (txs) => {
+      const [targets, values, datas] = txs.reduce(
+        (accum, curr) => {
+          accum[0].push(curr.target);
+          accum[1].push(curr.value ?? 0n);
+          accum[2].push(curr.data);
+
+          return accum;
+        },
+        [[], [], []] as [Address[], bigint[], Hex[]]
+      );
+      return encodeFunctionData({
+        abi,
+        functionName: "executeBatch",
+        args: [targets, values, datas],
+      });
+    },
+    signUserOperationHash: async (uoHash: Hex) => {
+      const signature = await signer.signMessage({ raw: uoHash });
+      switch (version) {
+        case "v2.0.0":
+          // TODO: handle case where signer is an SCA.
+          return concat([SignatureType.EOA, signature]);
+        default:
+          return signature;
+      }
+    },
+    async signMessage({ message }) {
+      switch (version as string) {
+        case "v1.0.1":
+          return signer.signMessage(message);
+        case "v1.0.2":
+          throw new Error(`${type} ${version} doesn't support 1271`);
+        case "v1.1.0":
+          return signWith1271WrapperV1(hashMessage(message));
+        case "v2.0.0":
+          const signature = await signWith1271WrapperV1(hashMessage(message));
+          // TODO: handle case where signer is an SCA.
+          return concat([SignatureType.EOA, signature]);
+        default:
+          throw new Error(`Unknown version ${type} of ${version}`);
+      }
+    },
+    async signTypedData(params) {
+      switch (version as string) {
+        case "v1.0.1":
+          return signer.signTypedData(
+            params as unknown as SignTypedDataParameters
+          );
+        case "v1.0.2":
+          throw new Error(
+            `Version ${version} of LightAccount doesn't support 1271`
+          );
+        case "v1.1.0":
+          return signWith1271WrapperV1(hashTypedData(params));
+        case "v2.0.0":
+          const signature = await signWith1271WrapperV1(hashTypedData(params));
+          // TODO: handle case where signer is an SCA.
+          return concat([SignatureType.EOA, signature]);
+        default:
+          throw new Error(`Unknown version ${version} of LightAccount`);
+      }
+    },
+    getDummySignature: (): Hex => {
+      const signature =
+        "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
+      switch (version as string) {
+        case "v1.0.1":
+        case "v1.0.2":
+        case "v1.1.0":
+          return signature;
+        case "v2.0.0":
+          return concat([SignatureType.EOA, signature]);
+        default:
+          throw new Error(`Unknown version ${type} of ${version}`);
+      }
+    },
+    encodeUpgradeToAndCall,
+  });
+
+  return {
+    ...account,
+    source: type,
+    getLightAccountVersion: () => version,
+    getSigner: () => signer,
+  };
+}

package/src/light-account/accounts/multiOwner.ts

@@ -0,0 +1,204 @@
+import {
+  createBundlerClient,
+  getAccountAddress,
+  getEntryPoint,
+  type EntryPointDef,
+  type SmartAccountSigner,
+} from "@aa-sdk/core";
+import {
+  concatHex,
+  encodeFunctionData,
+  hexToBigInt,
+  type Address,
+  type Chain,
+  type Hex,
+  type Transport,
+} from "viem";
+import { MultiOwnerLightAccountAbi } from "../abis/MultiOwnerLightAccountAbi.js";
+import { MultiOwnerLightAccountFactoryAbi } from "../abis/MultiOwnerLightAccountFactoryAbi.js";
+import type {
+  GetEntryPointForLightAccountVersion,
+  GetLightAccountVersion,
+} from "../types.js";
+import {
+  AccountVersionRegistry,
+  defaultLightAccountVersion,
+} from "../utils.js";
+import {
+  createLightAccountBase,
+  type CreateLightAccountBaseParams,
+  type LightAccountBase,
+} from "./base.js";
+
+export type MultiOwnerLightAccount<
+  TSigner extends SmartAccountSigner = SmartAccountSigner,
+  TLightAccountVersion extends GetLightAccountVersion<"MultiOwnerLightAccount"> = GetLightAccountVersion<"MultiOwnerLightAccount">,
+  TEntryPointVersion extends GetEntryPointForLightAccountVersion<
+    "MultiOwnerLightAccount",
+    TLightAccountVersion
+  > = GetEntryPointForLightAccountVersion<
+    "MultiOwnerLightAccount",
+    TLightAccountVersion
+  >
+> = LightAccountBase<
+  TSigner,
+  "MultiOwnerLightAccount",
+  TLightAccountVersion,
+  TEntryPointVersion
+> & {
+  encodeUpdateOwners: (
+    ownersToAdd: Address[],
+    ownersToRemove: Address[]
+  ) => Hex;
+  getOwnerAddresses: () => Promise<readonly Address[]>;
+};
+
+export type CreateMultiOwnerLightAccountParams<
+  TTransport extends Transport = Transport,
+  TSigner extends SmartAccountSigner = SmartAccountSigner,
+  TLightAccountVersion extends GetLightAccountVersion<"MultiOwnerLightAccount"> = GetLightAccountVersion<"MultiOwnerLightAccount">,
+  TEntryPointVersion extends GetEntryPointForLightAccountVersion<
+    "MultiOwnerLightAccount",
+    TLightAccountVersion
+  > = GetEntryPointForLightAccountVersion<
+    "MultiOwnerLightAccount",
+    TLightAccountVersion
+  >
+> = Omit<
+  CreateLightAccountBaseParams<
+    TTransport,
+    TSigner,
+    "MultiOwnerLightAccount",
+    TLightAccountVersion,
+    TEntryPointVersion
+  >,
+  "getAccountInitCode" | "entryPoint" | "version" | "abi" | "accountAddress"
+> & {
+  salt?: bigint;
+  initCode?: Hex;
+  accountAddress?: Address;
+  factoryAddress?: Address;
+  version?: TLightAccountVersion;
+  entryPoint?: EntryPointDef<TEntryPointVersion, Chain>;
+  owners?: Address[];
+};
+
+export async function createMultiOwnerLightAccount<
+  TTransport extends Transport = Transport,
+  TSigner extends SmartAccountSigner = SmartAccountSigner,
+  TLightAccountVersion extends GetLightAccountVersion<"MultiOwnerLightAccount"> = GetLightAccountVersion<"MultiOwnerLightAccount">,
+  TEntryPointVersion extends GetEntryPointForLightAccountVersion<
+    "MultiOwnerLightAccount",
+    TLightAccountVersion
+  > = GetEntryPointForLightAccountVersion<
+    "MultiOwnerLightAccount",
+    TLightAccountVersion
+  >
+>(
+  config: CreateMultiOwnerLightAccountParams<
+    TTransport,
+    TSigner,
+    TLightAccountVersion,
+    TEntryPointVersion
+  >
+): Promise<
+  MultiOwnerLightAccount<TSigner, TLightAccountVersion, TEntryPointVersion>
+>;
+
+export async function createMultiOwnerLightAccount({
+  transport,
+  chain,
+  signer,
+  initCode,
+  version = defaultLightAccountVersion("MultiOwnerLightAccount"),
+  entryPoint = getEntryPoint(chain, {
+    version:
+      AccountVersionRegistry["MultiOwnerLightAccount"][version]
+        .entryPointVersion,
+  }),
+  accountAddress,
+  factoryAddress = AccountVersionRegistry["MultiOwnerLightAccount"][version]
+    .address[chain.id].factory,
+  salt: salt_ = 0n,
+  owners = [],
+}: CreateMultiOwnerLightAccountParams): Promise<MultiOwnerLightAccount> {
+  const client = createBundlerClient({
+    transport,
+    chain,
+  });
+
+  const getAccountInitCode = async () => {
+    if (initCode) return initCode;
+
+    // NOTE: the current signer connected will be one of the owners as well
+    const ownerAddress = await signer.getAddress();
+    // owners need to be dedupe + ordered in ascending order and not == to zero address
+    const owners_ = Array.from(new Set([...owners, ownerAddress]))
+      .filter((x) => hexToBigInt(x) !== 0n)
+      .sort((a, b) => {
+        const bigintA = hexToBigInt(a);
+        const bigintB = hexToBigInt(b);
+
+        return bigintA < bigintB ? -1 : bigintA > bigintB ? 1 : 0;
+      });
+
+    return concatHex([
+      factoryAddress,
+      encodeFunctionData({
+        abi: MultiOwnerLightAccountFactoryAbi,
+        functionName: "createAccount",
+        args: [owners_, salt_],
+      }),
+    ]);
+  };
+
+  const address = await getAccountAddress({
+    client,
+    entryPoint,
+    accountAddress,
+    getAccountInitCode,
+  });
+
+  const account = await createLightAccountBase<
+    Transport,
+    SmartAccountSigner,
+    "MultiOwnerLightAccount"
+  >({
+    transport,
+    chain,
+    signer,
+    abi: MultiOwnerLightAccountAbi,
+    version: AccountVersionRegistry["MultiOwnerLightAccount"][version],
+    entryPoint,
+    accountAddress: address,
+    getAccountInitCode,
+  });
+
+  return {
+    ...account,
+    encodeUpdateOwners: (ownersToAdd: Address[], ownersToRemove: Address[]) => {
+      return encodeFunctionData({
+        abi: MultiOwnerLightAccountAbi,
+        functionName: "updateOwners",
+        args: [ownersToAdd, ownersToRemove],
+      });
+    },
+    async getOwnerAddresses(): Promise<readonly Address[]> {
+      const callResult = await client.readContract({
+        address,
+        abi: MultiOwnerLightAccountAbi,
+        functionName: "owners",
+      });
+
+      if (callResult == null) {
+        throw new Error("could not get on-chain owners");
+      }
+
+      if (!callResult.includes(await signer.getAddress())) {
+        throw new Error("on-chain owners does not include the current signer");
+      }
+
+      return callResult;
+    },
+  };
+}