@account-kit/smart-contracts 4.7.0 → 4.8.0

package/src/ma-v2/modules/single-signer-validation/signer.ts

@@ -0,0 +1,127 @@
+import type { SmartAccountSigner } from "@aa-sdk/core";
+import {
+  hashMessage,
+  hashTypedData,
+  concatHex,
+  type Hex,
+  type SignableMessage,
+  type TypedData,
+  type TypedDataDefinition,
+  type Chain,
+  type Address,
+} from "viem";
+import { getDefaultSingleSignerValidationModuleAddress } from "../utils.js";
+
+import { packUOSignature, pack1271Signature } 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 { singleSignerMessageSigner } from "@account-kit/smart-contracts";
+ * import { LocalAccountSigner } from "@aa-sdk/core";
+ *
+ * const MNEMONIC = "...":
+ * 
+ * const account = createSMAV2Account({ config });
+ *
+ * const signer = LocalAccountSigner.mnemonicToAccountSigner(MNEMONIC);
+ *
+ * const messageSigner = singleSignerMessageSigner(signer, chain, account.address, account.signerEntity.entityId);
+ * ```
+ *
+ * @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
+ * @param {number} entityId the entity id of the signing validation
+ * @returns {object} an object with methods for signing operations and managing signatures
+ */
+export const singleSignerMessageSigner = (
+  signer: SmartAccountSigner,
+  chain: Chain,
+  accountAddress: Address,
+  entityId: number
+) => {
+  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 = await hashMessage(message);
+
+      return pack1271Signature({
+        validationSignature: await signer.signTypedData({
+          domain: {
+            chainId: Number(chain.id),
+            verifyingContract:
+              getDefaultSingleSignerValidationModuleAddress(chain),
+            salt: concatHex([`0x${"00".repeat(12)}`, accountAddress]),
+          },
+          types: {
+            ReplaySafeHash: [{ name: "hash", type: "bytes32" }],
+          },
+          message: {
+            hash,
+          },
+          primaryType: "ReplaySafeHash",
+        }),
+        entityId,
+      });
+    },
+
+    // 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;
+
+      const validationSignature = await signer.signTypedData({
+        domain: {
+          chainId: Number(chain.id),
+          verifyingContract:
+            getDefaultSingleSignerValidationModuleAddress(chain),
+          salt: concatHex([`0x${"00".repeat(12)}`, accountAddress]),
+        },
+        types: {
+          ReplaySafeHash: [{ name: "hash", type: "bytes32" }],
+        },
+        message: {
+          hash: await hashTypedData(typedDataDefinition),
+        },
+        primaryType: "ReplaySafeHash",
+      });
+
+      return isDeferredAction
+        ? validationSignature
+        : pack1271Signature({
+            validationSignature,
+            entityId,
+          });
+    },
+  };
+};

package/src/ma-v2/modules/time-range-module/abis/timeRangeModuleAbi.ts

@@ -0,0 +1,295 @@
+export const timeRangeModuleAbi = [
+  {
+    type: "function",
+    name: "moduleId",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "string",
+        internalType: "string",
+      },
+    ],
+    stateMutability: "pure",
+  },
+  {
+    type: "function",
+    name: "onInstall",
+    inputs: [
+      {
+        name: "data",
+        type: "bytes",
+        internalType: "bytes",
+      },
+    ],
+    outputs: [],
+    stateMutability: "nonpayable",
+  },
+  {
+    type: "function",
+    name: "onUninstall",
+    inputs: [
+      {
+        name: "data",
+        type: "bytes",
+        internalType: "bytes",
+      },
+    ],
+    outputs: [],
+    stateMutability: "nonpayable",
+  },
+  {
+    type: "function",
+    name: "preRuntimeValidationHook",
+    inputs: [
+      {
+        name: "entityId",
+        type: "uint32",
+        internalType: "uint32",
+      },
+      {
+        name: "",
+        type: "address",
+        internalType: "address",
+      },
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256",
+      },
+      {
+        name: "",
+        type: "bytes",
+        internalType: "bytes",
+      },
+      {
+        name: "",
+        type: "bytes",
+        internalType: "bytes",
+      },
+    ],
+    outputs: [],
+    stateMutability: "view",
+  },
+  {
+    type: "function",
+    name: "preSignatureValidationHook",
+    inputs: [
+      {
+        name: "",
+        type: "uint32",
+        internalType: "uint32",
+      },
+      {
+        name: "",
+        type: "address",
+        internalType: "address",
+      },
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32",
+      },
+      {
+        name: "",
+        type: "bytes",
+        internalType: "bytes",
+      },
+    ],
+    outputs: [],
+    stateMutability: "pure",
+  },
+  {
+    type: "function",
+    name: "preUserOpValidationHook",
+    inputs: [
+      {
+        name: "entityId",
+        type: "uint32",
+        internalType: "uint32",
+      },
+      {
+        name: "userOp",
+        type: "tuple",
+        internalType: "struct PackedUserOperation",
+        components: [
+          {
+            name: "sender",
+            type: "address",
+            internalType: "address",
+          },
+          {
+            name: "nonce",
+            type: "uint256",
+            internalType: "uint256",
+          },
+          {
+            name: "initCode",
+            type: "bytes",
+            internalType: "bytes",
+          },
+          {
+            name: "callData",
+            type: "bytes",
+            internalType: "bytes",
+          },
+          {
+            name: "accountGasLimits",
+            type: "bytes32",
+            internalType: "bytes32",
+          },
+          {
+            name: "preVerificationGas",
+            type: "uint256",
+            internalType: "uint256",
+          },
+          {
+            name: "gasFees",
+            type: "bytes32",
+            internalType: "bytes32",
+          },
+          {
+            name: "paymasterAndData",
+            type: "bytes",
+            internalType: "bytes",
+          },
+          {
+            name: "signature",
+            type: "bytes",
+            internalType: "bytes",
+          },
+        ],
+      },
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32",
+      },
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256",
+      },
+    ],
+    stateMutability: "view",
+  },
+  {
+    type: "function",
+    name: "setTimeRange",
+    inputs: [
+      {
+        name: "entityId",
+        type: "uint32",
+        internalType: "uint32",
+      },
+      {
+        name: "validUntil",
+        type: "uint48",
+        internalType: "uint48",
+      },
+      {
+        name: "validAfter",
+        type: "uint48",
+        internalType: "uint48",
+      },
+    ],
+    outputs: [],
+    stateMutability: "nonpayable",
+  },
+  {
+    type: "function",
+    name: "supportsInterface",
+    inputs: [
+      {
+        name: "interfaceId",
+        type: "bytes4",
+        internalType: "bytes4",
+      },
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool",
+      },
+    ],
+    stateMutability: "view",
+  },
+  {
+    type: "function",
+    name: "timeRanges",
+    inputs: [
+      {
+        name: "entityId",
+        type: "uint32",
+        internalType: "uint32",
+      },
+      {
+        name: "account",
+        type: "address",
+        internalType: "address",
+      },
+    ],
+    outputs: [
+      {
+        name: "validUntil",
+        type: "uint48",
+        internalType: "uint48",
+      },
+      {
+        name: "validAfter",
+        type: "uint48",
+        internalType: "uint48",
+      },
+    ],
+    stateMutability: "view",
+  },
+  {
+    type: "event",
+    name: "TimeRangeSet",
+    inputs: [
+      {
+        name: "entityId",
+        type: "uint32",
+        indexed: true,
+        internalType: "uint32",
+      },
+      {
+        name: "account",
+        type: "address",
+        indexed: true,
+        internalType: "address",
+      },
+      {
+        name: "validUntil",
+        type: "uint48",
+        indexed: false,
+        internalType: "uint48",
+      },
+      {
+        name: "validAfter",
+        type: "uint48",
+        indexed: false,
+        internalType: "uint48",
+      },
+    ],
+    anonymous: false,
+  },
+  {
+    type: "error",
+    name: "NotImplemented",
+    inputs: [],
+  },
+  {
+    type: "error",
+    name: "TimeRangeNotValid",
+    inputs: [],
+  },
+  {
+    type: "error",
+    name: "UnexpectedDataPassed",
+    inputs: [],
+  },
+] as const;

package/src/ma-v2/modules/time-range-module/module.ts

@@ -0,0 +1,63 @@
+import { encodeAbiParameters, type Hex } from "viem";
+
+import { timeRangeModuleAbi } from "./abis/timeRangeModuleAbi.js";
+
+export const TimeRangeModule = {
+  abi: timeRangeModuleAbi,
+  encodeOnInstallData: (args: {
+    entityId: number;
+    validUntil: number;
+    validAfter: number;
+  }): Hex => {
+    const { entityId, validUntil, validAfter } = args;
+
+    return encodeAbiParameters(
+      [
+        {
+          type: "uint32",
+        },
+        {
+          type: "uint48",
+        },
+        {
+          type: "uint48",
+        },
+      ],
+      [entityId, validUntil, validAfter]
+    );
+  },
+  encodeOnUninstallData: (args: { entityId: number }): Hex => {
+    const { entityId } = args;
+
+    return encodeAbiParameters(
+      [
+        {
+          type: "uint32",
+        },
+      ],
+      [entityId]
+    );
+  },
+  encodeSetTimeRange: (args: {
+    entityId: number;
+    validUntil: number;
+    validAfter: number;
+  }): Hex => {
+    const { entityId, validUntil, validAfter } = args;
+
+    return encodeAbiParameters(
+      [
+        {
+          type: "uint32",
+        },
+        {
+          type: "uint48",
+        },
+        {
+          type: "uint48",
+        },
+      ],
+      [entityId, validUntil, validAfter]
+    );
+  },
+};

package/src/ma-v2/modules/utils.ts

@@ -0,0 +1,213 @@
+import type { Chain, Address } from "viem";
+import {
+  arbitrum,
+  arbitrumSepolia,
+  base,
+  baseSepolia,
+  mainnet,
+  optimism,
+  optimismSepolia,
+  polygon,
+  polygonAmoy,
+  sepolia,
+} from "@account-kit/infra";
+
+/**
+ * Maps a given chain to a specific address of the webauthn validation module by its chain ID. If no direct mapping exists, it defaults to returning a specific address.
+ *
+ * @example
+ * ```ts
+ * import { getDefaultWebauthnValidationModuleAddress } from "@account-kit/smart-contracts";
+ * import { Chain, Address } from "viem";
+ *
+ * const chain: Chain = ...
+ * const webauthnValidationAddress: Address = getDefaultWebauthnValidationModuleAddress(chain);
+ * ```
+ * @param {Chain} chain The chain object containing the chain ID to map
+ * @returns {Address} The webauthn validation module address associated with the specified chain ID or a default address if no specific mapping exists
+ */
+export const getDefaultWebauthnValidationModuleAddress = (
+  chain: Chain
+): Address => {
+  switch (chain.id) {
+    // TODO: case mekong.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 "0x0000000000001D9d34E07D9834274dF9ae575217";
+  }
+};
+
+/**
+ * Maps a given chain to a specific address of the time range module by its chain ID. If no direct mapping exists, it defaults to returning a specific address.
+ *
+ * @example
+ * ```ts
+ * import { getDefaultTimeRangeModuleAddress } from "@account-kit/smart-contracts";
+ * import { Chain, Address } from "viem";
+ *
+ * const chain: Chain = ...
+ * const timeRangeModuleAddress: Address = getDefaultTimeRangeModuleAddress(chain);
+ * ```
+ * @param {Chain} chain The chain object containing the chain ID to map
+ * @returns {Address} The time range module address associated with the specified chain ID or a default address if no specific mapping exists
+ */
+export const getDefaultTimeRangeModuleAddress = (chain: Chain): Address => {
+  switch (chain.id) {
+    // TODO: case mekong.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 "0x00000000000082B8e2012be914dFA4f62A0573eA";
+  }
+};
+
+/**
+ * Maps a given chain to a specific address of the single signer validation module by its chain ID. If no direct mapping exists, it defaults to returning a specific address.
+ *
+ * @example
+ * ```ts
+ * import { getDefaultSingleSignerValidationModuleAddress } from "@account-kit/smart-contracts";
+ * import { Chain, Address } from "viem";
+ *
+ * const chain: Chain = ...
+ * const singleSignerValidationAddress: Address = getDefaultSingleSignerValidationModuleAddress(chain);
+ * ```
+ * @param {Chain} chain The chain object containing the chain ID to map
+ * @returns {Address} The single signer validation module address associated with the specified chain ID or a default address if no specific mapping exists
+ */
+export const getDefaultSingleSignerValidationModuleAddress = (
+  chain: Chain
+): Address => {
+  switch (chain.id) {
+    // TODO: case mekong.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 "0x00000000000099DE0BF6fA90dEB851E2A2df7d83";
+  }
+};
+
+/**
+ * Maps a given chain to a specific address of the paymaster guard module by its chain ID. If no direct mapping exists, it defaults to returning a specific address.
+ *
+ * @example
+ * ```ts
+ * import { getDefaultPaymasterGuardModuleAddress } from "@account-kit/smart-contracts";
+ * import { Chain, Address } from "viem";
+ *
+ * const chain: Chain = ...
+ * const paymasterGuardAddress: Address = getDefaultPaymasterGuardModuleAddress(chain);
+ * ```
+ * @param {Chain} chain The chain object containing the chain ID to map
+ * @returns {Address} The paymaster guard module address associated with the specified chain ID or a default address if no specific mapping exists
+ */
+export const getDefaultPaymasterGuardModuleAddress = (
+  chain: Chain
+): Address => {
+  switch (chain.id) {
+    // TODO: case mekong.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 "0x0000000000001aA7A7F7E29abe0be06c72FD42A1";
+  }
+};
+
+/**
+ * Maps a given chain to a specific address of the native token limit module by its chain ID. If no direct mapping exists, it defaults to returning a specific address.
+ *
+ * @example
+ * ```ts
+ * import { getDefaultNativeTokenLimitModuleAddress } from "@account-kit/smart-contracts";
+ * import { Chain, Address } from "viem";
+ *
+ * const chain: Chain = ...
+ * const nativeTokenLimitAddress: Address = getDefaultNativeTokenLimitModuleAddress(chain);
+ * ```
+ * @param {Chain} chain The chain object containing the chain ID to map
+ * @returns {Address} The native token limit module address associated with the specified chain ID or a default address if no specific mapping exists
+ */
+export const getDefaultNativeTokenLimitModuleAddress = (
+  chain: Chain
+): Address => {
+  switch (chain.id) {
+    // TODO: case mekong.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 "0x00000000000001e541f0D090868FBe24b59Fbe06";
+  }
+};
+
+/**
+ * Maps a given chain to a specific address of the allowlist module by its chain ID. If no direct mapping exists, it defaults to returning a specific address.
+ *
+ * @example
+ * ```ts
+ * import { getDefaultAllowlistModuleAddress } from "@account-kit/smart-contracts";
+ * import { Chain, Address } from "viem";
+ *
+ * const chain: Chain = ...
+ * const allowlistModule: Address = getDefaultAllowlistModuleAddress(chain);
+ * ```
+ * @param {Chain} chain The chain object containing the chain ID to map
+ * @returns {Address} The allowlist module address associated with the specified chain ID or a default address if no specific mapping exists
+ */
+export const getDefaultAllowlistModuleAddress = (chain: Chain): Address => {
+  switch (chain.id) {
+    // TODO: case mekong.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 "0x0000000000002311EEE9A2B887af1F144dbb4F6e";
+  }
+};