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

package/src/msca/plugins/session-key/signer.ts

@@ -0,0 +1,98 @@
+import { LocalAccountSigner, type SmartAccountSigner } from "@aa-sdk/core";
+import type {
+  Hex,
+  PrivateKeyAccount,
+  SignableMessage,
+  TypedData,
+  TypedDataDefinition,
+} from "viem";
+import { generatePrivateKey } from "viem/accounts";
+import { z } from "zod";
+
+export const SessionKeySignerSchema = z.object({
+  storageType: z
+    .union([z.literal("local-storage"), z.literal("session-storage")])
+    .or(z.custom<Storage>())
+    .default("local-storage"),
+  storageKey: z.string().default("session-key-signer:session-key"),
+});
+
+export type SessionKeySignerConfig = z.input<typeof SessionKeySignerSchema>;
+
+/**
+ * A simple session key signer that uses localStorage or sessionStorage to store
+ * a private key. If the key is not found, it will generate a new one and store
+ * it in the storage.
+ */
+
+export const SESSION_KEY_SIGNER_TYPE_PFX = "alchemy:session-key";
+export class SessionKeySigner
+  implements SmartAccountSigner<LocalAccountSigner<PrivateKeyAccount>>
+{
+  signerType: string;
+  inner: LocalAccountSigner<PrivateKeyAccount>;
+  private storageType: "local-storage" | "session-storage" | Storage;
+  private storageKey: string;
+
+  constructor(config_: SessionKeySignerConfig = {}) {
+    const config = SessionKeySignerSchema.parse(config_);
+    this.signerType = `${SESSION_KEY_SIGNER_TYPE_PFX}`;
+    this.storageKey = config.storageKey;
+    this.storageType = config.storageType;
+
+    const sessionKey = (() => {
+      const storage =
+        typeof this.storageType !== "string"
+          ? this.storageType
+          : this.storageType === "session-storage"
+          ? sessionStorage
+          : localStorage;
+      const key = storage.getItem(this.storageKey);
+
+      if (key) {
+        return key;
+      } else {
+        const newKey = generatePrivateKey();
+        storage.setItem(this.storageKey, newKey);
+        return newKey;
+      }
+    })() as Hex;
+
+    this.inner = LocalAccountSigner.privateKeyToAccountSigner(sessionKey);
+  }
+
+  getAddress: () => Promise<`0x${string}`> = async () => {
+    return this.inner.getAddress();
+  };
+
+  signMessage: (msg: SignableMessage) => Promise<`0x${string}`> = async (
+    msg
+  ) => {
+    return this.inner.signMessage(msg);
+  };
+
+  signTypedData = async <
+    const TTypedData extends TypedData | { [key: string]: unknown },
+    TPrimaryType extends string = string
+  >(
+    params: TypedDataDefinition<TTypedData, TPrimaryType>
+  ) => {
+    return this.inner.signTypedData(params);
+  };
+
+  /**
+   * Generates a new private key and stores it in the storage.
+   *
+   * @returns The public address of the new key.
+   */
+  generateNewKey = () => {
+    const storage =
+      this.storageType === "session-storage" ? sessionStorage : localStorage;
+
+    const newKey = generatePrivateKey();
+    storage.setItem(this.storageKey, newKey);
+    this.inner = LocalAccountSigner.privateKeyToAccountSigner(newKey);
+
+    return this.inner.inner.address;
+  };
+}

package/src/msca/plugins/session-key/utils.ts

@@ -0,0 +1,40 @@
+import type { GetAccountParameter, SmartContractAccount } from "@aa-sdk/core";
+import { AccountNotFoundError } from "@aa-sdk/core";
+import type { Address, Chain, Client, Transport } from "viem";
+import { SessionKeyPlugin } from "./plugin.js";
+
+// find predecessors for each keys and returned the struct `ISessionKeyPlugin.SessionKeyToRemove[]`
+// where SessionKeyToRemove = { sessionKey: Address, predecessor: Hex }
+export const buildSessionKeysToRemoveStruct: <
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined
+>(
+  client: Client<TTransport, TChain, TAccount>,
+  args: {
+    keys: ReadonlyArray<Address>;
+    pluginAddress?: Address;
+  } & GetAccountParameter<TAccount>
+) => Promise<{ sessionKey: Address; predecessor: Address }[]> = async (
+  client,
+  { keys, pluginAddress, account = client.account }
+) => {
+  if (!account) throw new AccountNotFoundError();
+
+  const contract = SessionKeyPlugin.getContract(client, pluginAddress);
+  return (
+    await Promise.all(
+      keys.map(async (key) => {
+        return [
+          key,
+          await contract.read.findPredecessor([account.address, key]),
+        ];
+      })
+    )
+  ).map(([key, predecessor]) => ({
+    sessionKey: key,
+    predecessor,
+  }));
+};

package/src/msca/plugins/types.ts

@@ -0,0 +1,21 @@
+import {
+  type Abi,
+  type Address,
+  type Client,
+  type GetContractReturnType,
+  type PublicClient,
+} from "viem";
+
+export type GetPluginAddressParameter = { pluginAddress?: Address };
+
+export type Plugin<TAbi extends Abi = Abi> = {
+  meta: {
+    name: string;
+    version: string;
+    addresses: Record<number, Address>;
+  };
+  getContract: <C extends Client>(
+    client: C,
+    address?: Address
+  ) => GetContractReturnType<TAbi, PublicClient, Address>;
+};

package/src/msca/utils.ts

@@ -0,0 +1,198 @@
+import {
+  AccountNotFoundError,
+  ChainNotFoundError,
+  arbitrum,
+  arbitrumSepolia,
+  base,
+  baseSepolia,
+  mainnet,
+  optimism,
+  optimismSepolia,
+  polygon,
+  polygonAmoy,
+  sepolia,
+  type GetAccountParameter,
+  type SmartAccountClient,
+  type SmartAccountSigner,
+  type SmartContractAccount,
+  type SmartContractAccountWithSigner,
+  type UpgradeToData,
+} from "@aa-sdk/core";
+import type { Address, Chain, Transport } from "viem";
+import {
+  custom,
+  encodeAbiParameters,
+  encodeFunctionData,
+  encodeFunctionResult,
+  keccak256,
+  parseAbiParameters,
+} from "viem";
+import { IPluginAbi } from "./abis/IPlugin.js";
+import { MultiOwnerModularAccountFactoryAbi } from "./abis/MultiOwnerModularAccountFactory.js";
+import { UpgradeableModularAccountAbi } from "./abis/UpgradeableModularAccount.js";
+import {
+  createMultiOwnerModularAccount,
+  type MultiOwnerModularAccount,
+} from "./account/multiOwnerAccount.js";
+import { MultiOwnerPlugin } from "./plugins/multi-owner/plugin.js";
+
+/**
+ * Utility method returning the default multi sig msca factory address given a {@link Chain} object
+ *
+ * @param chain - a {@link Chain} object
+ * @returns a {@link Address} for the given chain
+ * @throws if the chain doesn't have an address currently deployed
+ */
+export const getDefaultMultisigModularAccountFactoryAddress = (
+  chain: Chain
+): Address => {
+  switch (chain.id) {
+    case sepolia.id:
+    case baseSepolia.id:
+    case polygon.id:
+    case mainnet.id:
+    case polygonAmoy.id:
+    case optimism.id:
+    case optimismSepolia.id:
+    case arbitrum.id:
+    case arbitrumSepolia.id:
+    case base.id:
+    default:
+      return "0x000000000000204327E6669f00901a57CE15aE15";
+  }
+};
+
+/**
+ * Utility method returning the default multi owner msca factory address given a {@link Chain} object
+ *
+ * @param chain - a {@link Chain} object
+ * @returns a {@link Address} for the given chain
+ * @throws if the chain doesn't have an address currently deployed
+ */
+export const getDefaultMultiOwnerModularAccountFactoryAddress = (
+  chain: Chain
+): Address => {
+  switch (chain.id) {
+    default:
+      return "0x000000e92D78D90000007F0082006FDA09BD5f11";
+  }
+};
+
+export async function getMSCAUpgradeToData<
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TSigner extends SmartAccountSigner = SmartAccountSigner,
+  TAccount extends
+    | SmartContractAccountWithSigner<string, TSigner>
+    | undefined = SmartContractAccountWithSigner<string, TSigner> | undefined
+>(
+  client: SmartAccountClient<TTransport, TChain, TAccount>,
+  args: {
+    multiOwnerPluginAddress?: Address;
+  } & GetAccountParameter<TAccount>
+): Promise<
+  UpgradeToData & {
+    createMAAccount: () => Promise<MultiOwnerModularAccount<TSigner>>;
+  }
+> {
+  const { account: account_ = client.account, multiOwnerPluginAddress } = args;
+
+  if (!account_) {
+    throw new AccountNotFoundError();
+  }
+  const account = account_ as SmartContractAccountWithSigner<string, TSigner>;
+
+  const chain = client.chain;
+  if (!chain) {
+    throw new ChainNotFoundError();
+  }
+
+  const initData = await getMAInitializationData({
+    client,
+    multiOwnerPluginAddress,
+    signerAddress: await account.getSigner().getAddress(),
+  });
+
+  return {
+    ...initData,
+    createMAAccount: async () =>
+      createMultiOwnerModularAccount({
+        transport: custom(client.transport),
+        chain: chain as Chain,
+        signer: account.getSigner(),
+        accountAddress: account.address,
+      }),
+  };
+}
+
+export async function getMAInitializationData<
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined
+>({
+  client,
+  multiOwnerPluginAddress,
+  signerAddress,
+}: {
+  multiOwnerPluginAddress?: Address;
+  client: SmartAccountClient<TTransport, TChain, TAccount>;
+  signerAddress: Address | Address[];
+}): Promise<UpgradeToData> {
+  if (!client.chain) {
+    throw new ChainNotFoundError();
+  }
+
+  const factoryAddress = getDefaultMultiOwnerModularAccountFactoryAddress(
+    client.chain
+  );
+
+  const implAddress = await client.readContract({
+    abi: MultiOwnerModularAccountFactoryAbi,
+    address: factoryAddress,
+    functionName: "IMPL",
+  });
+
+  const multiOwnerAddress =
+    multiOwnerPluginAddress ?? MultiOwnerPlugin.meta.addresses[client.chain.id];
+
+  if (!multiOwnerAddress) {
+    throw new Error("could not get multi owner plugin address");
+  }
+
+  const moPluginManifest = await client.readContract({
+    abi: IPluginAbi,
+    address: multiOwnerAddress,
+    functionName: "pluginManifest",
+  });
+
+  const hashedMultiOwnerPluginManifest = keccak256(
+    encodeFunctionResult({
+      abi: IPluginAbi,
+      functionName: "pluginManifest",
+      result: moPluginManifest,
+    })
+  );
+
+  const encodedOwner = encodeAbiParameters(
+    parseAbiParameters("address[]"),
+    Array.isArray(signerAddress) ? [signerAddress] : [[signerAddress]]
+  );
+
+  const encodedPluginInitData = encodeAbiParameters(
+    parseAbiParameters("bytes32[], bytes[]"),
+    [[hashedMultiOwnerPluginManifest], [encodedOwner]]
+  );
+
+  const encodedMSCAInitializeData = encodeFunctionData({
+    abi: UpgradeableModularAccountAbi,
+    functionName: "initialize",
+    args: [[multiOwnerAddress], encodedPluginInitData],
+  });
+
+  return {
+    implAddress,
+    initializationData: encodedMSCAInitializeData,
+  };
+}