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

package/src/msca/plugins/multi-owner/signer.ts

@@ -0,0 +1,76 @@
+import type { Address, BundlerClient, SmartAccountSigner } from "@aa-sdk/core";
+import {
+  hashMessage,
+  hashTypedData,
+  type Hash,
+  type Hex,
+  type SignableMessage,
+  type Transport,
+  type TypedData,
+  type TypedDataDefinition,
+} from "viem";
+import { MultiOwnerPlugin, MultiOwnerPluginAbi } from "./plugin.js";
+
+export const multiOwnerMessageSigner = <
+  TTransport extends Transport,
+  TSigner extends SmartAccountSigner
+>(
+  client: BundlerClient<TTransport>,
+  accountAddress: Address,
+  signer: () => TSigner,
+  pluginAddress: Address = MultiOwnerPlugin.meta.addresses[client.chain.id]
+) => {
+  const signWith712Wrapper = async (msg: Hash): Promise<`0x${string}`> => {
+    const [, name, version, chainId, verifyingContract, salt] =
+      await client.readContract({
+        abi: MultiOwnerPluginAbi,
+        address: pluginAddress,
+        functionName: "eip712Domain",
+        account: accountAddress,
+      });
+
+    return signer().signTypedData({
+      domain: {
+        chainId: Number(chainId),
+        name,
+        salt,
+        verifyingContract,
+        version,
+      },
+      types: {
+        AlchemyModularAccountMessage: [{ name: "message", type: "bytes" }],
+      },
+      message: {
+        message: msg,
+      },
+      primaryType: "AlchemyModularAccountMessage",
+    });
+  };
+
+  return {
+    getDummySignature: (): Hex => {
+      return "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
+    },
+
+    signUserOperationHash: (uoHash: `0x${string}`): Promise<`0x${string}`> => {
+      return signer().signMessage({ raw: uoHash });
+    },
+
+    signMessage({
+      message,
+    }: {
+      message: SignableMessage;
+    }): Promise<`0x${string}`> {
+      return signWith712Wrapper(hashMessage(message));
+    },
+
+    signTypedData: <
+      const typedData extends TypedData | Record<string, unknown>,
+      primaryType extends keyof typedData | "EIP712Domain" = keyof typedData
+    >(
+      typedDataDefinition: TypedDataDefinition<typedData, primaryType>
+    ): Promise<Hex> => {
+      return signWith712Wrapper(hashTypedData(typedDataDefinition));
+    },
+  };
+};

package/src/msca/plugins/multisig/actions/getThreshold.ts

@@ -0,0 +1,37 @@
+import {
+  AccountNotFoundError,
+  type GetAccountParameter,
+  type SmartContractAccount,
+} from "@aa-sdk/core";
+import { type Chain, type Client, type Transport } from "viem";
+import { isMultisigModularAccount } from "../../../account/multisigAccount.js";
+import type { GetPluginAddressParameter } from "../../types.js";
+import { MultisigPlugin } from "../plugin.js";
+import { MultisigAccountExpectedError } from "../../../errors.js";
+
+export async function getThreshold<
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined
+>(
+  client: Client<TTransport, TChain, TAccount>,
+  args: GetPluginAddressParameter & GetAccountParameter<TAccount>
+) {
+  const account = args.account ?? client.account;
+  if (!account) {
+    throw new AccountNotFoundError();
+  }
+
+  if (!isMultisigModularAccount(account)) {
+    throw new MultisigAccountExpectedError();
+  }
+
+  const [, threshold] = await MultisigPlugin.getContract(
+    client,
+    args.pluginAddress
+  ).read.ownershipInfoOf([account.address]);
+
+  return threshold === 0n ? account.getLocalThreshold() : threshold;
+}

package/src/msca/plugins/multisig/actions/isOwnerOf.ts

@@ -0,0 +1,30 @@
+import {
+  AccountNotFoundError,
+  type Address,
+  type GetAccountParameter,
+  type SmartContractAccount,
+} from "@aa-sdk/core";
+import { type Chain, type Client, type Transport } from "viem";
+import type { GetPluginAddressParameter } from "../../types.js";
+import { MultisigPlugin } from "../plugin.js";
+
+export async function isOwnerOf<
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined
+>(
+  client: Client<TTransport, TChain, TAccount>,
+  args: { address: Address } & GetPluginAddressParameter &
+    GetAccountParameter<TAccount>
+) {
+  const account = args.account ?? client.account;
+  if (!account) {
+    throw new AccountNotFoundError();
+  }
+  // TODO: check if the account actually has the plugin installed
+  // either via account loupe or checking if the supports interface call passes on the account
+  const contract = MultisigPlugin.getContract(client, args.pluginAddress);
+  return await contract.read.isOwnerOf([account.address, args.address]);
+}

package/src/msca/plugins/multisig/actions/proposeUserOperation.ts

@@ -0,0 +1,82 @@
+import {
+  AccountNotFoundError,
+  IncompatibleClientError,
+  isSmartAccountClient,
+  isSmartAccountWithSigner,
+  SmartAccountWithSignerRequiredError,
+  type GetEntryPointFromAccount,
+  type SendUserOperationParameters,
+  type SmartContractAccount,
+  type UserOperationOverrides,
+} from "@aa-sdk/core";
+import { type Chain, type Client, type Transport } from "viem";
+import { splitAggregatedSignature } from "../index.js";
+import { type ProposeUserOperationResult } from "../types.js";
+
+export async function proposeUserOperation<
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>
+>(
+  client: Client<TTransport, TChain, TAccount>,
+  {
+    uo,
+    account = client.account,
+    overrides: overrides_,
+  }: SendUserOperationParameters<TAccount, undefined>
+): Promise<ProposeUserOperationResult> {
+  // these overrides allow us to set a high max fee and PVG upper bound
+  const overrides = {
+    maxFeePerGas: { multiplier: 3 },
+    maxPriorityFeePerGas: { multiplier: 2 },
+    preVerificationGas: { multiplier: 1000 },
+    ...overrides_,
+  } as UserOperationOverrides<TEntryPointVersion>;
+
+  if (!account) {
+    throw new AccountNotFoundError();
+  }
+
+  if (!isSmartAccountClient(client)) {
+    throw new IncompatibleClientError(
+      "SmartAccountClient",
+      "proposeUserOperation",
+      client
+    );
+  }
+
+  if (!isSmartAccountWithSigner(account)) {
+    throw new SmartAccountWithSignerRequiredError();
+  }
+
+  const builtUo = await client.buildUserOperation({
+    account,
+    uo,
+    overrides,
+  });
+
+  const request = await client.signUserOperation({
+    uoStruct: builtUo,
+    account,
+    context: {
+      userOpSignatureType: "UPPERLIMIT",
+    },
+  });
+
+  const splitSignatures = await splitAggregatedSignature({
+    request,
+    aggregatedSignature: request.signature,
+    account,
+    // split works on the assumption that we have t - 1 signatures
+    threshold: 2,
+  });
+
+  return {
+    request,
+    signatureObj: splitSignatures.signatures[0],
+    aggregatedSignature: request.signature,
+  };
+}

package/src/msca/plugins/multisig/actions/readOwners.ts

@@ -0,0 +1,31 @@
+import {
+  AccountNotFoundError,
+  type GetAccountParameter,
+  type SmartContractAccount,
+} from "@aa-sdk/core";
+import { type Chain, type Client, type Transport } from "viem";
+import type { GetPluginAddressParameter } from "../../types.js";
+import { MultisigPlugin } from "../plugin.js";
+
+export async function readOwners<
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined
+>(
+  client: Client<TTransport, TChain, TAccount>,
+  args: GetPluginAddressParameter & GetAccountParameter<TAccount>
+) {
+  const account = args?.account ?? client.account;
+  if (!account) {
+    throw new AccountNotFoundError();
+  }
+  // TODO: check if the account actually has the plugin installed
+  // either via account loupe or checking if the supports interface call passes on the account
+  const [owners] = await MultisigPlugin.getContract(
+    client,
+    args?.pluginAddress
+  ).read.ownershipInfoOf([account.address]);
+  return owners;
+}

package/src/msca/plugins/multisig/actions/signMultisigUserOperation.ts

@@ -0,0 +1,93 @@
+import {
+  AccountNotFoundError,
+  IncompatibleClientError,
+  SmartAccountWithSignerRequiredError,
+  isSmartAccountClient,
+  isSmartAccountWithSigner,
+  type SmartContractAccount,
+} from "@aa-sdk/core";
+import { type Chain, type Client, type Transport } from "viem";
+import { MultisigMissingSignatureError } from "../../../errors.js";
+import { combineSignatures, splitAggregatedSignature } from "../index.js";
+import {
+  type SignMultisigUserOperationParams,
+  type SignMultisigUserOperationResult,
+} from "../types.js";
+
+export async function signMultisigUserOperation<
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined
+>(
+  client: Client<TTransport, TChain, TAccount>,
+  params: SignMultisigUserOperationParams<TAccount>
+): Promise<SignMultisigUserOperationResult> {
+  const { account = client.account, signatures, userOperationRequest } = params;
+
+  if (!account) {
+    throw new AccountNotFoundError();
+  }
+
+  if (!isSmartAccountClient(client)) {
+    throw new IncompatibleClientError(
+      "SmartAccountClient",
+      "signMultisigUserOperation",
+      client
+    );
+  }
+
+  if (!isSmartAccountWithSigner(account)) {
+    throw new SmartAccountWithSignerRequiredError();
+  }
+
+  if (!signatures.length) {
+    throw new MultisigMissingSignatureError();
+  }
+
+  const signerAddress = await account.getSigner().getAddress();
+
+  const signedRequest = await client.signUserOperation({
+    account,
+    uoStruct: userOperationRequest,
+    context: {
+      aggregatedSignature: combineSignatures({
+        signatures,
+        upperLimitMaxFeePerGas: userOperationRequest.maxFeePerGas,
+        upperLimitMaxPriorityFeePerGas:
+          userOperationRequest.maxPriorityFeePerGas,
+        upperLimitPvg: userOperationRequest.preVerificationGas,
+        usingMaxValues: false,
+      }),
+      signatures,
+      userOpSignatureType: "UPPERLIMIT",
+    },
+  });
+
+  const splitSignatures = await splitAggregatedSignature({
+    account,
+    request: signedRequest,
+    aggregatedSignature: signedRequest.signature,
+    // split works on the assumption that we have t - 1 signatures
+    // we have signatures.length + 1 signatures now, so we need sl + 1 + 1
+    threshold: signatures.length + 2,
+  });
+
+  const signatureObj = splitSignatures.signatures.find(
+    (x) => x.signer === signerAddress
+  );
+
+  if (!signatureObj) {
+    // TODO: strongly type this
+    throw new Error(
+      "INTERNAL ERROR: signature not found in split signatures, this is an internal bug please report"
+    );
+  }
+
+  return {
+    signatureObj,
+    signature: signatureObj.signature,
+    aggregatedSignature: signedRequest.signature,
+  };
+}

package/src/msca/plugins/multisig/extension.ts

@@ -0,0 +1,100 @@
+import {
+  type GetAccountParameter,
+  type GetEntryPointFromAccount,
+  type IsUndefined,
+  type SendUserOperationParameters,
+  type SmartContractAccount,
+} from "@aa-sdk/core";
+import { type Address, type Chain, type Client, type Transport } from "viem";
+import type { GetPluginAddressParameter } from "../types.js";
+import { getThreshold } from "./actions/getThreshold.js";
+import { isOwnerOf } from "./actions/isOwnerOf.js";
+import { proposeUserOperation } from "./actions/proposeUserOperation.js";
+import { readOwners } from "./actions/readOwners.js";
+import { signMultisigUserOperation } from "./actions/signMultisigUserOperation.js";
+import {
+  multisigPluginActions as multisigPluginActions_,
+  type MultisigPluginActions as MultisigPluginActions_,
+} from "./plugin.js";
+import {
+  type MultisigUserOperationContext,
+  type ProposeUserOperationResult,
+  type SignMultisigUserOperationParams,
+  type SignMultisigUserOperationResult,
+} from "./types.js";
+
+export type MultisigPluginActions<
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined
+> = MultisigPluginActions_<TAccount, MultisigUserOperationContext> & {
+  readOwners: (
+    params: GetPluginAddressParameter & GetAccountParameter<TAccount>
+  ) => Promise<ReadonlyArray<Address>>;
+
+  isOwnerOf: (
+    params: { address: Address } & GetPluginAddressParameter &
+      GetAccountParameter<TAccount>
+  ) => Promise<boolean>;
+
+  getThreshold: (
+    params: GetPluginAddressParameter & GetAccountParameter<TAccount>
+  ) => Promise<bigint>;
+
+  proposeUserOperation: (
+    params: SendUserOperationParameters<TAccount, undefined>
+  ) => Promise<
+    ProposeUserOperationResult<TAccount, GetEntryPointFromAccount<TAccount>>
+  >;
+
+  signMultisigUserOperation: (
+    params: SignMultisigUserOperationParams<TAccount>
+  ) => Promise<SignMultisigUserOperationResult>;
+} & (IsUndefined<TAccount> extends false
+    ? {
+        readOwners: (
+          params?: GetPluginAddressParameter & GetAccountParameter<TAccount>
+        ) => Promise<ReadonlyArray<Address>>;
+      }
+    : {});
+
+export const multisigPluginActions: <
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined
+>(
+  client: Client<TTransport, TChain, TAccount>
+) => MultisigPluginActions<TAccount> = <
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined
+>(
+  client: Client<TTransport, TChain, TAccount>
+) => ({
+  ...multisigPluginActions_(client),
+  readOwners: (
+    args: GetPluginAddressParameter & GetAccountParameter<TAccount>
+  ) => readOwners(client, args),
+
+  isOwnerOf: (
+    args: { address: Address } & GetPluginAddressParameter &
+      GetAccountParameter<TAccount>
+  ) => isOwnerOf(client, args),
+
+  getThreshold: (
+    args: GetPluginAddressParameter & GetAccountParameter<TAccount>
+  ) => getThreshold(client, args),
+
+  proposeUserOperation: (
+    args: SendUserOperationParameters<TAccount, undefined>
+  ) => proposeUserOperation(client, args),
+
+  signMultisigUserOperation: (
+    params: SignMultisigUserOperationParams<TAccount>
+  ): Promise<SignMultisigUserOperationResult> =>
+    signMultisigUserOperation(client, params),
+});

package/src/msca/plugins/multisig/index.ts

@@ -0,0 +1,21 @@
+export { getThreshold } from "./actions/getThreshold.js";
+export { isOwnerOf } from "./actions/isOwnerOf.js";
+export { proposeUserOperation } from "./actions/proposeUserOperation.js";
+export { readOwners } from "./actions/readOwners.js";
+export { signMultisigUserOperation } from "./actions/signMultisigUserOperation.js";
+export type * from "./extension.js";
+export { multisigPluginActions } from "./extension.js";
+export { multisigSignatureMiddleware } from "./middleware.js";
+export {
+  MultisigPlugin,
+  MultisigPluginAbi,
+  MultisigPluginExecutionFunctionAbi,
+} from "./plugin.js";
+export type * from "./types.js";
+export { type SignerType } from "./types.js";
+export {
+  combineSignatures,
+  formatSignatures,
+  getSignerType,
+  splitAggregatedSignature,
+} from "./utils/index.js";

package/src/msca/plugins/multisig/middleware.ts

@@ -0,0 +1,167 @@
+import {
+  InvalidUserOperationError,
+  SmartAccountWithSignerRequiredError,
+  deepHexlify,
+  isSmartAccountWithSigner,
+  isValidRequest,
+  resolveProperties,
+  type ClientMiddlewareFn,
+  type UserOperationRequest_v6,
+  type UserOperationRequest_v7,
+} from "@aa-sdk/core";
+import { type Hex } from "viem";
+import { isMultisigModularAccount } from "../../account/multisigAccount.js";
+import {
+  InvalidContextSignatureError,
+  MultisigAccountExpectedError,
+} from "../../errors.js";
+import {
+  combineSignatures,
+  getSignerType,
+  splitAggregatedSignature,
+  type MultisigUserOperationContext,
+} from "./index.js";
+
+/**
+ * A signer middleware to be used with Multisig Account Clients.
+ * This middleware handles correctly aggregating signatures passed through
+ * as context when sending UserOperations, proposing UserOperations, or adding signatures to a UserOperation.
+ *
+ * @param struct the user operation struct to be signed
+ * @param param the parameters to be passed to the middleware
+ * @param param.account the account to be used for signing
+ * @param param.client the smart account client that will be used for RPC requests
+ * @param param.context the context object containing the signatures to be aggregated {@link MultisigUserOperationContext}
+ * @returns a Promise containing a UserOperation with an aggregated signature in the `signature` field
+ */
+export const multisigSignatureMiddleware: ClientMiddlewareFn<
+  MultisigUserOperationContext
+> = async (struct, { account, client, context }) => {
+  // if the signature is not present, this has to be UPPERLIMIT because it's likely a propose operation
+  if (
+    !context ||
+    (context.userOpSignatureType === "ACTUAL" &&
+      !context.signatures &&
+      !context.aggregatedSignature)
+  ) {
+    throw new InvalidContextSignatureError();
+  }
+
+  if (!isSmartAccountWithSigner(account)) {
+    throw new SmartAccountWithSignerRequiredError();
+  }
+
+  if (!isMultisigModularAccount(account)) {
+    throw new MultisigAccountExpectedError();
+  }
+
+  const resolvedStruct = await resolveProperties(struct);
+
+  const request = deepHexlify(resolvedStruct);
+  if (!isValidRequest(request)) {
+    throw new InvalidUserOperationError(resolvedStruct);
+  }
+
+  const signature = await account.signUserOperationHash(
+    account.getEntryPoint().getUserOperationHash(request)
+  );
+
+  const signerType = await getSignerType({
+    client,
+    signature: signature,
+    signer: account.getSigner(),
+  });
+
+  // then this is a propose operation
+  if (
+    context.userOpSignatureType === "UPPERLIMIT" &&
+    context?.signatures?.length == null &&
+    context?.aggregatedSignature == null
+  ) {
+    return {
+      ...resolvedStruct,
+      signature: combineSignatures({
+        signatures: [
+          {
+            signature,
+            signer: await account.getSigner().getAddress(),
+            signerType,
+            userOpSigType: context.userOpSignatureType,
+          },
+        ],
+        upperLimitMaxFeePerGas: request.maxFeePerGas,
+        upperLimitMaxPriorityFeePerGas: request.maxPriorityFeePerGas,
+        upperLimitPvg: request.preVerificationGas,
+        usingMaxValues: false,
+      }),
+    };
+  }
+
+  if (context.aggregatedSignature == null || context.signatures == null) {
+    throw new InvalidContextSignatureError();
+  }
+
+  // otherwise this is a sign operation
+  const {
+    upperLimitPvg,
+    upperLimitMaxFeePerGas,
+    upperLimitMaxPriorityFeePerGas,
+  } = await splitAggregatedSignature({
+    aggregatedSignature: context.aggregatedSignature,
+    threshold: context.signatures.length + 1,
+    account,
+    request,
+  });
+
+  const finalSignature = combineSignatures({
+    signatures: context.signatures.concat({
+      userOpSigType: context.userOpSignatureType,
+      signerType,
+      signature,
+      signer: await account.getSigner().getAddress(),
+    }),
+    upperLimitPvg,
+    upperLimitMaxFeePerGas,
+    upperLimitMaxPriorityFeePerGas,
+    usingMaxValues: isUsingMaxValues(request, {
+      upperLimitPvg,
+      upperLimitMaxFeePerGas,
+      upperLimitMaxPriorityFeePerGas,
+    }),
+  });
+
+  return {
+    ...resolvedStruct,
+    signature: finalSignature,
+  };
+};
+
+const isUsingMaxValues = (
+  request: UserOperationRequest_v6 | UserOperationRequest_v7,
+  upperLimits: {
+    upperLimitPvg: Hex;
+    upperLimitMaxFeePerGas: Hex;
+    upperLimitMaxPriorityFeePerGas: Hex;
+  }
+): boolean => {
+  if (
+    BigInt(request.preVerificationGas) !== BigInt(upperLimits.upperLimitPvg)
+  ) {
+    return false;
+  }
+
+  if (
+    BigInt(request.maxFeePerGas) !== BigInt(upperLimits.upperLimitMaxFeePerGas)
+  ) {
+    return false;
+  }
+
+  if (
+    BigInt(request.maxPriorityFeePerGas) !==
+    BigInt(upperLimits.upperLimitMaxPriorityFeePerGas)
+  ) {
+    return false;
+  }
+
+  return true;
+};