@account-kit/smart-contracts 4.7.0 → 4.8.0

package/src/ma-v2/account/nativeSMASigner.ts

@@ -0,0 +1,121 @@
+import type { SmartAccountSigner } from "@aa-sdk/core";
+import {
+  hashMessage,
+  hashTypedData,
+  type Hex,
+  type SignableMessage,
+  type TypedData,
+  type TypedDataDefinition,
+  type Chain,
+  type Address,
+} from "viem";
+
+import {
+  packUOSignature,
+  pack1271Signature,
+  DEFAULT_OWNER_ENTITY_ID,
+} from "../utils.js";
+/**
+ * Creates an object with methods for generating a dummy signature, signing user operation hashes, signing messages, and signing typed data.
+ *
+ * @example
+ * ```ts
+ * import { nativeSMASigner } from "@account-kit/smart-contracts";
+ 
+ * import { LocalAccountSigner } from "@aa-sdk/core";
+ *
+ * const MNEMONIC = "...":
+ *
+ * const account = createSMAV2Account({ config });
+ *
+ * const signer = LocalAccountSigner.mnemonicToAccountSigner(MNEMONIC);
+ *
+ * const messageSigner = nativeSMASigner(signer, chain, account.address);
+ * ```
+ *
+ * @param {SmartAccountSigner} signer Signer to use for signing operations
+ * @param {Chain} chain Chain object for the signer
+ * @param {Address} accountAddress address of the smart account using this signer
+ * @returns {object} an object with methods for signing operations and managing signatures
+ */
+export const nativeSMASigner = (
+  signer: SmartAccountSigner,
+  chain: Chain,
+  accountAddress: Address
+) => {
+  return {
+    getDummySignature: (): Hex => {
+      const dummyEcdsaSignature =
+        "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
+
+      return packUOSignature({
+        // orderedHookData: [],
+        validationSignature: dummyEcdsaSignature,
+      });
+    },
+
+    signUserOperationHash: (uoHash: Hex): Promise<Hex> => {
+      return signer.signMessage({ raw: uoHash }).then((signature: Hex) =>
+        packUOSignature({
+          // orderedHookData: [],
+          validationSignature: signature,
+        })
+      );
+    },
+
+    // we apply the expected 1271 packing here since the account contract will expect it
+    async signMessage({ message }: { message: SignableMessage }): Promise<Hex> {
+      const hash = hashMessage(message);
+
+      return pack1271Signature({
+        validationSignature: await signer.signTypedData({
+          domain: {
+            chainId: Number(chain.id),
+            verifyingContract: accountAddress,
+          },
+          types: {
+            ReplaySafeHash: [{ name: "hash", type: "bytes32" }],
+          },
+          message: {
+            hash,
+          },
+          primaryType: "ReplaySafeHash",
+        }),
+        entityId: DEFAULT_OWNER_ENTITY_ID,
+      });
+    },
+
+    // TODO: maybe move "sign deferred actions" to a separate function?
+    // we don't apply the expected 1271 packing since deferred sigs use typed data sigs and don't expect the 1271 packing
+    signTypedData: async <
+      const typedData extends TypedData | Record<string, unknown>,
+      primaryType extends keyof typedData | "EIP712Domain" = keyof typedData
+    >(
+      typedDataDefinition: TypedDataDefinition<typedData, primaryType>
+    ): Promise<Hex> => {
+      // the accounts domain already gives replay protection across accounts for deferred actions, so we don't need to apply another wrapping
+      const isDeferredAction =
+        typedDataDefinition?.primaryType === "DeferredAction" &&
+        typedDataDefinition?.domain?.verifyingContract === accountAddress;
+
+      return isDeferredAction
+        ? signer.signTypedData(typedDataDefinition)
+        : pack1271Signature({
+            validationSignature: await signer.signTypedData({
+              domain: {
+                chainId: Number(chain.id),
+                verifyingContract: accountAddress,
+              },
+              types: {
+                ReplaySafeHash: [{ name: "hash", type: "bytes32" }],
+              },
+              message: {
+                hash: await hashTypedData(typedDataDefinition),
+              },
+              primaryType: "ReplaySafeHash",
+            }),
+            entityId: DEFAULT_OWNER_ENTITY_ID,
+          });
+    },
+  };
+};

package/src/ma-v2/account/semiModularAccountV2.ts

@@ -0,0 +1,289 @@
+import type {
+  EntryPointDef,
+  SmartAccountSigner,
+  AccountOp,
+  SmartContractAccountWithSigner,
+  ToSmartContractAccountParams,
+} from "@aa-sdk/core";
+import {
+  createBundlerClient,
+  getEntryPoint,
+  toSmartContractAccount,
+  InvalidEntityIdError,
+  InvalidNonceKeyError,
+  getAccountAddress,
+} from "@aa-sdk/core";
+import {
+  concatHex,
+  encodeFunctionData,
+  getContract,
+  maxUint32,
+  maxUint152,
+  zeroAddress,
+  type Address,
+  type Chain,
+  type Hex,
+  type Transport,
+} from "viem";
+import { accountFactoryAbi } from "../abis/accountFactoryAbi.js";
+import {
+  getDefaultMAV2FactoryAddress,
+  DEFAULT_OWNER_ENTITY_ID,
+} from "../utils.js";
+import { singleSignerMessageSigner } from "../modules/single-signer-validation/signer.js";
+import { nativeSMASigner } from "./nativeSMASigner.js";
+import { modularAccountAbi } from "../abis/modularAccountAbi.js";
+import { serializeModuleEntity } from "../actions/common/utils.js";
+
+const executeUserOpSelector: Hex = "0x8DD7712F";
+
+export type SignerEntity = {
+  isGlobalValidation: boolean;
+  entityId: number;
+};
+
+export type ExecutionDataView = {
+  module: Address;
+  skipRuntimeValidation: boolean;
+  allowGlobalValidation: boolean;
+  executionHooks: readonly Hex[];
+};
+
+export type ValidationDataView = {
+  validationHooks: readonly Hex[];
+  executionHooks: readonly Hex[];
+  selectors: readonly Hex[];
+  validationFlags: number;
+};
+
+export type ValidationDataParams =
+  | {
+      validationModuleAddress: Address;
+      entityId?: never;
+    }
+  | {
+      validationModuleAddress?: never;
+      entityId: number;
+    };
+
+export type MAV2Account<
+  TSigner extends SmartAccountSigner = SmartAccountSigner
+> = SmartContractAccountWithSigner<"MAV2Account", TSigner, "0.7.0"> & {
+  signerEntity: SignerEntity;
+  getExecutionData: (selector: Hex) => Promise<ExecutionDataView>;
+  getValidationData: (
+    args: ValidationDataParams
+  ) => Promise<ValidationDataView>;
+  encodeCallData: (callData: Hex) => Promise<Hex>;
+};
+
+export type CreateSMAV2AccountParams<
+  TTransport extends Transport = Transport,
+  TSigner extends SmartAccountSigner = SmartAccountSigner
+> = Pick<
+  ToSmartContractAccountParams<"MAV2Account", TTransport, Chain, "0.7.0">,
+  "transport" | "chain" | "accountAddress"
+> & {
+  signer: TSigner;
+  salt?: bigint;
+  factoryAddress?: Address;
+  initCode?: Hex;
+  initialOwner?: Address;
+  entryPoint?: EntryPointDef<"0.7.0", Chain>;
+  signerEntity?: SignerEntity;
+};
+
+export async function createSMAV2Account<
+  TTransport extends Transport = Transport,
+  TSigner extends SmartAccountSigner = SmartAccountSigner
+>(
+  config: CreateSMAV2AccountParams<TTransport, TSigner>
+): Promise<MAV2Account<TSigner>>;
+
+/**
+ * Creates an SMAV2 account using defined parameters including chain, signer, salt, factory address, and more.
+ * Handles account initialization code, nonce generation, transaction encoding, and more to construct a modular account with optional validation hooks.
+ *
+ * @param {CreateSMAV2AccountParams} config Configuration parameters for creating an SMAV2 account. Includes chain details, signer, salt, factory address, and more.
+ * @returns {Promise<MAV2Account>} A promise that resolves to an `MAV2Account` providing methods for nonce retrieval, transaction execution, and more.
+ */
+export async function createSMAV2Account(
+  config: CreateSMAV2AccountParams
+): Promise<MAV2Account> {
+  const {
+    transport,
+    chain,
+    signer,
+    salt = 0n,
+    factoryAddress = getDefaultMAV2FactoryAddress(chain),
+    initCode,
+    initialOwner,
+    accountAddress,
+    entryPoint = getEntryPoint(chain, { version: "0.7.0" }),
+    signerEntity = {
+      isGlobalValidation: true,
+      entityId: DEFAULT_OWNER_ENTITY_ID,
+    },
+    signerEntity: {
+      isGlobalValidation = true,
+      entityId = DEFAULT_OWNER_ENTITY_ID,
+    } = {},
+  } = config;
+
+  if (entityId > Number(maxUint32)) {
+    throw new InvalidEntityIdError(entityId);
+  }
+
+  const client = createBundlerClient({
+    transport,
+    chain,
+  });
+
+  const getAccountInitCode = async () => {
+    if (initCode) {
+      return initCode;
+    }
+
+    // If an initial owner is not provided, use the signer's address
+    const ownerAddress = initialOwner ?? (await signer.getAddress());
+
+    return concatHex([
+      factoryAddress,
+      encodeFunctionData({
+        abi: accountFactoryAbi,
+        functionName: "createSemiModularAccount",
+        args: [ownerAddress, salt],
+      }),
+    ]);
+  };
+
+  const encodeExecute: (tx: AccountOp) => Promise<Hex> = async ({
+    target,
+    data,
+    value,
+  }) =>
+    await encodeCallData(
+      encodeFunctionData({
+        abi: modularAccountAbi,
+        functionName: "execute",
+        args: [target, value ?? 0n, data],
+      })
+    );
+
+  const encodeBatchExecute: (txs: AccountOp[]) => Promise<Hex> = async (txs) =>
+    await encodeCallData(
+      encodeFunctionData({
+        abi: modularAccountAbi,
+        functionName: "executeBatch",
+        args: [
+          txs.map((tx) => ({
+            target: tx.target,
+            data: tx.data,
+            value: tx.value ?? 0n,
+          })),
+        ],
+      })
+    );
+
+  const _accountAddress = await getAccountAddress({
+    client,
+    entryPoint,
+    accountAddress,
+    getAccountInitCode,
+  });
+
+  const baseAccount = await toSmartContractAccount({
+    transport,
+    chain,
+    entryPoint,
+    accountAddress: _accountAddress,
+    source: `MAV2Account`,
+    encodeExecute,
+    encodeBatchExecute,
+    getAccountInitCode,
+    ...(entityId === DEFAULT_OWNER_ENTITY_ID
+      ? nativeSMASigner(signer, chain, _accountAddress)
+      : singleSignerMessageSigner(signer, chain, _accountAddress, entityId)),
+  });
+
+  // TODO: add deferred action flag
+  const getAccountNonce = async (nonceKey: bigint = 0n): Promise<bigint> => {
+    if (nonceKey > maxUint152) {
+      throw new InvalidNonceKeyError(nonceKey);
+    }
+
+    const entryPointContract = getContract({
+      address: entryPoint.address,
+      abi: entryPoint.abi,
+      client,
+    });
+
+    const fullNonceKey: bigint =
+      (nonceKey << 40n) +
+      BigInt(entityId << 8) +
+      (isGlobalValidation ? 1n : 0n);
+
+    return entryPointContract.read.getNonce([
+      _accountAddress,
+      fullNonceKey,
+    ]) as Promise<bigint>;
+  };
+
+  const accountContract = getContract({
+    address: _accountAddress,
+    abi: modularAccountAbi,
+    client,
+  });
+
+  const getExecutionData = async (selector: Hex) => {
+    if (!(await baseAccount.isAccountDeployed())) {
+      return {
+        module: zeroAddress,
+        skipRuntimeValidation: false,
+        allowGlobalValidation: false,
+        executionHooks: [],
+      };
+    }
+
+    return await accountContract.read.getExecutionData([selector]);
+  };
+
+  const getValidationData = async (args: ValidationDataParams) => {
+    if (!(await baseAccount.isAccountDeployed())) {
+      return {
+        validationHooks: [],
+        executionHooks: [],
+        selectors: [],
+        validationFlags: 0,
+      };
+    }
+
+    const { validationModuleAddress, entityId } = args;
+    return await accountContract.read.getValidationData([
+      serializeModuleEntity({
+        moduleAddress: validationModuleAddress ?? zeroAddress,
+        entityId: entityId ?? Number(maxUint32),
+      }),
+    ]);
+  };
+
+  const encodeCallData = async (callData: Hex): Promise<Hex> => {
+    const validationData = await getValidationData({
+      entityId: Number(entityId),
+    });
+
+    return validationData.executionHooks.length
+      ? concatHex([executeUserOpSelector, callData])
+      : callData;
+  };
+
+  return {
+    ...baseAccount,
+    getAccountNonce,
+    getSigner: () => signer,
+    signerEntity,
+    getExecutionData,
+    getValidationData,
+    encodeCallData,
+  };
+}

package/src/ma-v2/actions/common/types.ts

@@ -0,0 +1,37 @@
+import type { Address, Hex } from "viem";
+
+export type ModuleEntity = {
+  moduleAddress: Address;
+  entityId: number;
+};
+
+export type ValidationConfig = {
+  moduleAddress: Address;
+  entityId: number; // uint32
+  isGlobal: boolean;
+  isSignatureValidation: boolean;
+  isUserOpValidation: boolean;
+};
+
+export enum HookType {
+  EXECUTION = "0x00",
+  VALIDATION = "0x01",
+}
+
+export type HookConfig = {
+  address: Address;
+  entityId: number; // uint32
+  hookType: HookType;
+  hasPreHooks: boolean;
+  hasPostHooks: boolean;
+};
+
+// maps to type ValidationStorage in MAv2 implementation
+export type ValidationData = {
+  isGlobal: boolean; // validation flag
+  isSignatureValidation: boolean; // validation flag
+  isUserOpValidation: boolean;
+  validationHooks: HookConfig[];
+  executionHooks: Hex[];
+  selectors: Hex[];
+};

package/src/ma-v2/actions/common/utils.ts

@@ -0,0 +1,103 @@
+import { type Hex, toHex, concatHex } from "viem";
+import type { ValidationConfig, HookConfig, ModuleEntity } from "./types";
+import { HookType } from "./types.js";
+
+/**
+ * Serializes a validation configuration into a hexadecimal string representation. This involves converting boolean flags into bitwise representation and combining them with serialized module entity data.
+ *
+ * @example
+ * ```ts
+ * import { serializeValidationConfig } from "@account-kit/smart-contracts";
+ * import { Address } from "viem";
+ *
+ * const moduleAddress: Address = "0x1234";
+ * const entityId: number = 1234;
+ * const isGlobal: boolean = true;
+ * const isSignatureValidation: boolean = false;
+ * const isUserOpValidation: boolean = true;
+ *
+ * const validationConfigHex = serializeValidationConfig({
+ *  moduleAddress,
+ *  entityId
+ *  isGlobal,
+ *  isSignatureValidation,
+ *  isUserOpValidation
+ * });
+ * ```
+ * @param {ValidationConfig} config The validation configuration object containing details to serialize
+ * @returns {Hex} A hexadecimal string representing the serialized configuration
+ */
+export function serializeValidationConfig(config: ValidationConfig): Hex {
+  const isUserOpValidationBit = config.isUserOpValidation ? 1 : 0;
+  const isSignatureValidationBit = config.isSignatureValidation ? 2 : 0;
+  const isGlobalBit = config.isGlobal ? 4 : 0;
+  return concatHex([
+    serializeModuleEntity(config),
+    toHex(isUserOpValidationBit + isSignatureValidationBit + isGlobalBit, {
+      size: 1,
+    }),
+  ]);
+}
+
+/**
+ * Serializes a `HookConfig` object into a `Hex` format by encoding the hook type, presence of post/pre hooks, address, and entity ID.
+ *
+ * @example
+ * ```ts
+ * import { type HookType, serializeHookConfig } from "@account-kit/smart-contracts";
+ * import { Address } from "viem";
+ *
+ * const moduleAddress: Address = "0x1234";
+ * const entityId: number = 1234;
+ * const hookType: HookType = HookType.Validation;
+ * const hasPostHooks: boolean = false;
+ * const hasPreHooks: boolean = true;
+ *
+ * const hookConfigHex = serializeHookConfig({
+ *  moduleAddress,
+ *  entityId
+ *  hookType,
+ *  hasPostHooks,
+ *  hasPreHooks
+ * });
+ * ```
+ *
+ * @param {HookConfig} config The hook configuration containing address, entity ID, hook type, and post/pre hook indicators
+ * @returns {Hex} The serialized hook configuration in hexadecimal format
+ */
+export function serializeHookConfig(config: HookConfig): Hex {
+  const hookTypeBit = config.hookType === HookType.VALIDATION ? 1 : 0;
+  const hasPostHooksBit = config.hasPostHooks ? 2 : 0;
+  const hasPreHooksBit = config.hasPreHooks ? 4 : 0;
+  return concatHex([
+    config.address,
+    toHex(config.entityId, { size: 4 }),
+    toHex(hookTypeBit + hasPostHooksBit + hasPreHooksBit, {
+      size: 1,
+    }),
+  ]);
+}
+
+/**
+ * Serializes a module entity into a hexadecimal format by concatenating the module address and entity ID.
+ *
+ * @example
+ * ```ts
+ * import { serializeModuleEntity } from "@account-kit/smart-contracts";
+ * import { Address } from "viem";
+ *
+ * const moduleAddress: Address = "0x1234";
+ * const entityId: number = 1234;
+ *
+ * const moduleEntityHex = serializeModuleEntity({
+ *  moduleAddress,
+ *  entityId
+ * });
+ * ```
+ *
+ * @param {ModuleEntity} config The module entity configuration containing the module address and entity ID
+ * @returns {Hex} A hexadecimal string representation of the serialized module entity
+ */
+export function serializeModuleEntity(config: ModuleEntity): Hex {
+  return concatHex([config.moduleAddress, toHex(config.entityId, { size: 4 })]);
+}