feat: permissions translation layer

aa-sdk/core/src/errors/client.ts

@@ -117,3 +117,31 @@ export class InvalidModularAccountV2Mode extends BaseError {
     super(`The provided account mode is invalid for ModularAccount V2`);
   }
 }
+
+/**
+ * Error class denoting that the deferred action mode used is invalid.
+ */
+export class InvalidDeferredActionMode extends BaseError {
+  override name = "InvalidDeferredActionMode";
+
+  /**
+   * Initializes a new instance of the error message with a default message indicating that the provided deferred action mode is invalid.
+   */
+  constructor() {
+    super(`The provided deferred action mode is invalid`);
+  }
+}
+
+/**
+ * Error class denoting that the deferred action nonce used is invalid.
+ */
+export class InvalidDeferredActionNonce extends BaseError {
+  override name = "InvalidDeferredActionNonce";
+
+  /**
+   * Initializes a new instance of the error message with a default message indicating that the provided deferred action nonce is invalid.
+   */
+  constructor() {
+    super(`The provided deferred action nonce is invalid`);
+  }
+}

aa-sdk/core/src/index.ts

@@ -77,6 +77,8 @@ export {
   InvalidNonceKeyError,
   EntityIdOverrideError,
   InvalidModularAccountV2Mode,
+  InvalidDeferredActionMode,
+  InvalidDeferredActionNonce,
 } from "./errors/client.js";
 export {
   EntryPointNotFoundError,

account-kit/smart-contracts/src/ma-v2/account/common/modularAccountV2Base.ts

@@ -3,6 +3,8 @@ import {
   getEntryPoint,
   InvalidEntityIdError,
   InvalidNonceKeyError,
+  InvalidDeferredActionNonce,
+  InvalidDeferredActionMode,
   toSmartContractAccount,
   type AccountOp,
   type SmartAccountSigner,
@@ -85,6 +87,7 @@ export type CreateMAV2BaseParams<
   signer: TSigner;
   signerEntity?: SignerEntity;
   accountAddress: Address;
+  deferredAction?: Hex;
 };
 
 export type CreateMAV2BaseReturnType<
@@ -108,6 +111,7 @@ export async function createMAv2Base<
       entityId = DEFAULT_OWNER_ENTITY_ID,
     } = {},
     accountAddress,
+    deferredAction,
     ...remainingToSmartContractAccountParams
   } = config;
 
@@ -120,6 +124,39 @@ export async function createMAv2Base<
     chain,
   });
 
+  const entryPointContract = getContract({
+    address: entryPoint.address,
+    abi: entryPoint.abi,
+    client,
+  });
+
+  let useDeferredAction: boolean = false;
+  let nonce: bigint = 0n;
+  let deferredActionData: Hex = "0x";
+  let hasAssociatedExecHooks: boolean = false;
+
+  if (deferredAction) {
+    if (deferredAction.slice(2, 4) !== "00") {
+      throw new InvalidDeferredActionMode();
+    }
+    // Set these values if the deferred action has not been consumed. We check this with the EP
+    const nextNonceForDeferredAction: bigint =
+      (await entryPointContract.read.getNonce([
+        accountAddress,
+        nonce >> 64n,
+      ])) as bigint;
+
+    // we only add the deferred action in if the nonce has not been consumed
+    if (nonce === nextNonceForDeferredAction) {
+      nonce = BigInt(`0x${deferredAction.slice(6, 70)}`);
+      useDeferredAction = true;
+      deferredActionData = `0x${deferredAction.slice(70)}`;
+      hasAssociatedExecHooks = deferredAction[5] === "1";
+    } else if (nonce > nextNonceForDeferredAction) {
+      throw new InvalidDeferredActionNonce();
+    }
+  }
+
   const encodeExecute: (tx: AccountOp) => Promise<Hex> = async ({
     target,
     data,
@@ -150,18 +187,16 @@ export async function createMAv2Base<
 
   const isAccountDeployed: () => Promise<boolean> = async () =>
     !!(await client.getCode({ address: accountAddress }));
-  // TODO: add deferred action flag
+
   const getNonce = async (nonceKey: bigint = 0n): Promise<bigint> => {
+    if (useDeferredAction) {
+      return nonce;
+    }
+
     if (nonceKey > maxUint152) {
       throw new InvalidNonceKeyError(nonceKey);
     }
 
-    const entryPointContract = getContract({
-      address: entryPoint.address,
-      abi: entryPoint.abi,
-      client,
-    });
-
     const fullNonceKey: bigint =
       (nonceKey << 40n) +
       (BigInt(entityId) << 8n) +
@@ -216,7 +251,8 @@ export async function createMAv2Base<
       entityId: Number(entityId),
     });
 
-    return validationData.executionHooks.length
+    return (useDeferredAction && hasAssociatedExecHooks) ||
+      validationData.executionHooks.length
       ? concatHex([executeUserOpSelector, callData])
       : callData;
   };
@@ -231,8 +267,14 @@ export async function createMAv2Base<
     encodeBatchExecute,
     getNonce,
     ...(entityId === DEFAULT_OWNER_ENTITY_ID
-      ? nativeSMASigner(signer, chain, accountAddress)
-      : singleSignerMessageSigner(signer, chain, accountAddress, entityId)),
+      ? nativeSMASigner(signer, chain, accountAddress, deferredActionData)
+      : singleSignerMessageSigner(
+          signer,
+          chain,
+          accountAddress,
+          entityId,
+          deferredActionData
+        )),
   });
 
   return {

account-kit/smart-contracts/src/ma-v2/account/modularAccountV2.ts

@@ -36,6 +36,7 @@ export type CreateModularAccountV2Params<
 > & {
   signer: TSigner;
   entryPoint?: EntryPointDef<"0.7.0", Chain>;
+  deferredAction?: Hex;
   signerEntity?: SignerEntity;
 }) &
   (
@@ -103,6 +104,7 @@ export async function createModularAccountV2(
       entityId: DEFAULT_OWNER_ENTITY_ID,
     },
     signerEntity: { entityId = DEFAULT_OWNER_ENTITY_ID } = {},
+    deferredAction,
   } = config;
 
   const client = createBundlerClient({
@@ -183,6 +185,7 @@ export async function createModularAccountV2(
     signer,
     entryPoint,
     signerEntity,
+    deferredAction,
     ...accountFunctions,
   });
 }

account-kit/smart-contracts/src/ma-v2/account/nativeSMASigner.ts

@@ -9,6 +9,7 @@ import {
   type Chain,
   type Address,
   concat,
+  concatHex,
 } from "viem";
 
 import {
@@ -23,7 +24,6 @@ import { SignatureType } from "../modules/utils.js";
  * @example
  * ```ts
  * import { nativeSMASigner } from "@account-kit/smart-contracts";
-
  * import { LocalAccountSigner } from "@aa-sdk/core";
  *
  * const MNEMONIC = "...":
@@ -38,31 +38,37 @@ import { SignatureType } from "../modules/utils.js";
  * @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 {Hex} deferredActionData optional deferred action data to prepend to the uo signatures
  * @returns {object} an object with methods for signing operations and managing signatures
  */
 export const nativeSMASigner = (
   signer: SmartAccountSigner,
   chain: Chain,
-  accountAddress: Address
+  accountAddress: Address,
+  deferredActionData?: Hex
 ) => {
   return {
     getDummySignature: (): Hex => {
-      const dummyEcdsaSignature =
-        "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
-
-      return packUOSignature({
+      const sig = packUOSignature({
         // orderedHookData: [],
-        validationSignature: dummyEcdsaSignature,
+        validationSignature:
+          "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c",
       });
+
+      return deferredActionData ? concatHex([deferredActionData, sig]) : sig;
     },
 
-    signUserOperationHash: (uoHash: Hex): Promise<Hex> => {
-      return signer.signMessage({ raw: uoHash }).then((signature: Hex) =>
-        packUOSignature({
-          // orderedHookData: [],
-          validationSignature: signature,
-        })
-      );
+    signUserOperationHash: async (uoHash: Hex): Promise<Hex> => {
+      const sig = await signer
+        .signMessage({ raw: uoHash })
+        .then((signature: Hex) =>
+          packUOSignature({
+            // orderedHookData: [],
+            validationSignature: signature,
+          })
+        );
+
+      return deferredActionData ? concatHex([deferredActionData, sig]) : sig;
     },
 
     // we apply the expected 1271 packing here since the account contract will expect it