feat(safe): support dynamic owners

- Add dynamic owner types and export them for safe accounts

- Encode contract owners as dynamic Safe signatures in signing flows

- Add integration coverage for v0.7 dynamic owner user operations

Author: mouseless0x

.changeset/safe-dynamic-owners.md

@@ -0,0 +1,5 @@
+---
+"permissionless": minor
+---
+
+Added support for dynamic (ERC-1271 contract) owners in toSafeSmartAccount. Owners can now be passed as `{ owner, dynamic: true }`, in which case their signatures are encoded as dynamic parts of the Safe signature bytes (contract signature format, signature type 0x00) and verified through EIP-1271 on the owner address.

packages/permissionless/accounts/index.ts

@@ -35,6 +35,9 @@ export {
 } from "./etherspot/toEtherspotSmartAccount.js"
 
 export {
+    type DynamicOwner,
+    type RegularOwner,
+    type SafeOwner,
     type SafeSmartAccountImplementation,
     type SafeVersion,
     type ToSafeSmartAccountParameters,

packages/permissionless/accounts/safe/index.ts

@@ -7,6 +7,9 @@ export const SafeSmartAccount = {
 }
 
 export type {
+    DynamicOwner,
+    RegularOwner,
+    SafeOwner,
     SafeSmartAccountImplementation,
     SafeVersion,
     ToSafeSmartAccountParameters,

packages/permissionless/accounts/safe/signUserOperation.test.ts

@@ -1,3 +1,4 @@
+import { http, createTestClient, size, slice } from "viem"
 import {
     entryPoint06Address,
     entryPoint07Address
@@ -12,9 +13,11 @@ import { describe, expect } from "vitest"
 import { testWithRpc } from "../../../permissionless-test/src/testWithRpc"
 import {
     getBundlerClient,
+    getPublicClient,
     getSafeClient
 } from "../../../permissionless-test/src/utils"
 import { signUserOperation } from "./signUserOperation"
+import { toSafeSmartAccount } from "./toSafeSmartAccount"
 
 describe("signUserOperation", () => {
     testWithRpc("signUserOperation_V06", async ({ rpc }) => {
@@ -185,6 +188,85 @@ describe("signUserOperation", () => {
         expect(receipt.success).toBeTruthy()
     })
 
+    testWithRpc("signUserOperation_V07 with dynamic owner", async ({ rpc }) => {
+        const eoaOwner = privateKeyToAccount(generatePrivateKey())
+        const dynamicSignerKey = privateKeyToAccount(generatePrivateKey())
+
+        // Contract owner validated through EIP-1271. The runtime code echoes
+        // the called selector back, so isValidSignature always returns the
+        // expected magic value (both the bytes32 and legacy bytes variants).
+        const erc1271OwnerAddress = privateKeyToAccount(
+            generatePrivateKey()
+        ).address
+
+        const testClient = createTestClient({
+            mode: "anvil",
+            transport: http(rpc.anvilRpc),
+            chain: foundry
+        })
+
+        await testClient.setCode({
+            address: erc1271OwnerAddress,
+            bytecode: "0x60003560e01c60e01b60005260206000f3"
+        })
+
+        // A KMS-style owner: signs with a local key but lives at the
+        // ERC-1271 contract address.
+        const dynamicOwner = toAccount({
+            address: erc1271OwnerAddress,
+            async signMessage({ message }) {
+                return dynamicSignerKey.signMessage({ message })
+            },
+            async signTypedData(typedData) {
+                // biome-ignore lint/suspicious/noExplicitAny: test helper
+                return dynamicSignerKey.signTypedData(typedData as any)
+            },
+            async signTransaction() {
+                throw new Error("Not supported")
+            }
+        })
+
+        const account = await toSafeSmartAccount({
+            client: getPublicClient(rpc.anvilRpc),
+            entryPoint: {
+                address: entryPoint07Address,
+                version: "0.7"
+            },
+            owners: [eoaOwner, { owner: dynamicOwner, dynamic: true }],
+            version: "1.4.1",
+            saltNonce: 420n
+        })
+
+        const safeAccountClient = getBundlerClient({
+            account,
+            entryPoint: {
+                version: "0.7"
+            },
+            ...rpc
+        })
+
+        const stubSignature = await account.getStubSignature()
+        // 6 bytes validAfter + 6 bytes validUntil + 2 * 65 bytes static parts
+        // + 32 bytes dynamic length + 65 bytes dynamic signature data
+        expect(size(slice(stubSignature, 12))).toBe(130 + 32 + 65)
+
+        const userOpHash = await safeAccountClient.sendUserOperation({
+            calls: [
+                {
+                    to: account.address,
+                    data: "0x"
+                }
+            ]
+        })
+
+        const receipt = await safeAccountClient.waitForUserOperationReceipt({
+            hash: userOpHash
+        })
+
+        expect(receipt).toBeTruthy()
+        expect(receipt.success).toBeTruthy()
+    })
+
     testWithRpc("signUserOperation_V07 7579", async ({ rpc }) => {
         const owners = [
             privateKeyToAccount(generatePrivateKey()),

packages/permissionless/accounts/safe/signUserOperation.ts

@@ -122,13 +122,34 @@ export async function signUserOperation(
             address: Address
             version: "0.6" | "0.7"
         }
-        owners: (Account | WebAuthnAccount)[]
-        account: OneOf<
-            | EthereumProvider
-            | WalletClient<Transport, Chain | undefined, Account>
-            | LocalAccount
+        owners: (
+            | Account
             | WebAuthnAccount
-        >
+            | { owner: Account; dynamic?: boolean }
+        )[]
+        account:
+            | OneOf<
+                  | EthereumProvider
+                  | WalletClient<Transport, Chain | undefined, Account>
+                  | LocalAccount
+                  | WebAuthnAccount
+              >
+            | {
+                  owner: OneOf<
+                      | EthereumProvider
+                      | WalletClient<Transport, Chain | undefined, Account>
+                      | LocalAccount
+                      | WebAuthnAccount
+                  >
+                  /**
+                   * When true, the signature is encoded as a dynamic part of
+                   * the Safe signature bytes (contract signature format,
+                   * signature type 0x00), verified through EIP-1271 on the
+                   * owner address.
+                   * @default false
+                   */
+                  dynamic?: boolean
+              }
         chainId: number
         signatures?: Hex
         validAfter?: number
@@ -146,10 +167,14 @@ export async function signUserOperation(
         version,
         owners,
         signatures: existingSignatures,
-        account,
+        account: _account,
         ...userOperation
     } = parameters
 
+    const account = "owner" in _account ? _account.owner : _account
+    const isDynamicOwner =
+        "owner" in _account ? (_account.dynamic ?? false) : false
+
     const { safe4337ModuleAddress } = getDefaultAddresses(
         version,
         entryPoint.version,
@@ -258,7 +283,7 @@ export async function signUserOperation(
         ...unPackedSignatures,
         {
             signer,
-            dynamic: isWebAuthnAccount(localOwner),
+            dynamic: isWebAuthnAccount(localOwner) || isDynamicOwner,
             data: await (async () => {
                 if (isWebAuthnAccount(localOwner)) {
                     const safeHash = hashTypedData({