permissionless 0.1.3 → 0.1.5

package/accounts/safe/signerToSafeSmartAccount.ts

@@ -20,7 +20,6 @@ import {
     toBytes,
     zeroAddress
 } from "viem"
-import { toAccount } from "viem/accounts"
 import {
     getChainId,
     readContract,
@@ -32,6 +31,7 @@ import type { ENTRYPOINT_ADDRESS_V06_TYPE, Prettify } from "../../types"
 import type { EntryPoint } from "../../types/entrypoint"
 import { getEntryPointVersion } from "../../utils"
 import { isSmartAccountDeployed } from "../../utils/isSmartAccountDeployed"
+import { toSmartAccount } from "../toSmartAccount"
 import {
     SignTransactionNotSupportedBySmartAccount,
     type SmartAccount,
@@ -493,7 +493,7 @@ const getDefaultAddresses = (
 
 export type SignerToSafeSmartAccountParameters<
     entryPoint extends EntryPoint,
-    TSource extends string = "custom",
+    TSource extends string = string,
     TAddress extends Address = Address
 > = Prettify<{
     signer: SmartAccountSigner<TSource, TAddress>
@@ -526,7 +526,7 @@ export async function signerToSafeSmartAccount<
     entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined,
-    TSource extends string = "custom",
+    TSource extends string = string,
     TAddress extends Address = Address
 >(
     client: Client<TTransport, TChain>,
@@ -598,46 +598,11 @@ export async function signerToSafeSmartAccount<
 
     let safeDeployed = await isSmartAccountDeployed(client, accountAddress)
 
-    const account = toAccount({
-        address: accountAddress,
-        async signMessage({ message }) {
-            const messageHash = hashTypedData({
-                domain: {
-                    chainId: chainId,
-                    verifyingContract: accountAddress
-                },
-                types: {
-                    SafeMessage: [{ name: "message", type: "bytes" }]
-                },
-                primaryType: "SafeMessage",
-                message: {
-                    message: generateSafeMessageMessage(message)
-                }
-            })
-
-            return adjustVInSignature(
-                "eth_sign",
-                await signMessage(client, {
-                    account: viemSigner,
-                    message: {
-                        raw: toBytes(messageHash)
-                    }
-                })
-            )
-        },
-        async signTransaction(_, __) {
-            throw new SignTransactionNotSupportedBySmartAccount()
-        },
-        async signTypedData<
-            const TTypedData extends TypedData | Record<string, unknown>,
-            TPrimaryType extends
-                | keyof TTypedData
-                | "EIP712Domain" = keyof TTypedData
-        >(typedData: TypedDataDefinition<TTypedData, TPrimaryType>) {
-            return adjustVInSignature(
-                "eth_signTypedData",
-                await signTypedData(client, {
-                    account: viemSigner,
+    const safeSmartAccount: SafeSmartAccount<entryPoint, TTransport, TChain> =
+        toSmartAccount({
+            address: accountAddress,
+            async signMessage({ message }) {
+                const messageHash = hashTypedData({
                     domain: {
                         chainId: chainId,
                         verifyingContract: accountAddress
@@ -647,195 +612,239 @@ export async function signerToSafeSmartAccount<
                     },
                     primaryType: "SafeMessage",
                     message: {
-                        message: generateSafeMessageMessage<
-                            TTypedData,
-                            TPrimaryType
-                        >(typedData)
+                        message: generateSafeMessageMessage(message)
                     }
                 })
-            )
-        }
-    })
 
-    const safeSmartAccount: SafeSmartAccount<entryPoint, TTransport, TChain> = {
-        ...account,
-        client: client,
-        publicKey: accountAddress,
-        entryPoint: entryPointAddress,
-        source: "SafeSmartAccount",
-        async getNonce() {
-            return getAccountNonce(client, {
-                sender: accountAddress,
-                entryPoint: entryPointAddress
-            })
-        },
-        async signUserOperation(userOperation) {
-            const signatures = [
-                {
-                    signer: viemSigner.address,
-                    data: await signTypedData(client, {
+                return adjustVInSignature(
+                    "eth_sign",
+                    await signMessage(client, {
+                        account: viemSigner,
+                        message: {
+                            raw: toBytes(messageHash)
+                        }
+                    })
+                )
+            },
+            async signTransaction(_, __) {
+                throw new SignTransactionNotSupportedBySmartAccount()
+            },
+            async signTypedData<
+                const TTypedData extends TypedData | Record<string, unknown>,
+                TPrimaryType extends
+                    | keyof TTypedData
+                    | "EIP712Domain" = keyof TTypedData
+            >(typedData: TypedDataDefinition<TTypedData, TPrimaryType>) {
+                return adjustVInSignature(
+                    "eth_signTypedData",
+                    await signTypedData(client, {
                         account: viemSigner,
                         domain: {
                             chainId: chainId,
-                            verifyingContract: safe4337ModuleAddress
+                            verifyingContract: accountAddress
+                        },
+                        types: {
+                            SafeMessage: [{ name: "message", type: "bytes" }]
                         },
-                        types: EIP712_SAFE_OPERATION_TYPE,
-                        primaryType: "SafeOp",
+                        primaryType: "SafeMessage",
                         message: {
-                            safe: accountAddress,
-                            callData: userOperation.callData,
-                            entryPoint: entryPointAddress,
-                            nonce: userOperation.nonce,
-                            initCode: userOperation.initCode,
-                            maxFeePerGas: userOperation.maxFeePerGas,
-                            maxPriorityFeePerGas:
-                                userOperation.maxPriorityFeePerGas,
-                            preVerificationGas:
-                                userOperation.preVerificationGas,
-                            verificationGasLimit:
-                                userOperation.verificationGasLimit,
-                            callGasLimit: userOperation.callGasLimit,
-                            paymasterAndData: userOperation.paymasterAndData,
-                            validAfter: validAfter,
-                            validUntil: validUntil
+                            message: generateSafeMessageMessage<
+                                TTypedData,
+                                TPrimaryType
+                            >(typedData)
                         }
                     })
-                }
-            ]
+                )
+            },
+            client: client,
+            publicKey: accountAddress,
+            entryPoint: entryPointAddress,
+            source: "SafeSmartAccount",
+            async getNonce() {
+                return getAccountNonce(client, {
+                    sender: accountAddress,
+                    entryPoint: entryPointAddress
+                })
+            },
+            async signUserOperation(userOperation) {
+                const signatures = [
+                    {
+                        signer: viemSigner.address,
+                        data: await signTypedData(client, {
+                            account: viemSigner,
+                            domain: {
+                                chainId: chainId,
+                                verifyingContract: safe4337ModuleAddress
+                            },
+                            types: EIP712_SAFE_OPERATION_TYPE,
+                            primaryType: "SafeOp",
+                            message: {
+                                safe: accountAddress,
+                                callData: userOperation.callData,
+                                entryPoint: entryPointAddress,
+                                nonce: userOperation.nonce,
+                                initCode: userOperation.initCode,
+                                maxFeePerGas: userOperation.maxFeePerGas,
+                                maxPriorityFeePerGas:
+                                    userOperation.maxPriorityFeePerGas,
+                                preVerificationGas:
+                                    userOperation.preVerificationGas,
+                                verificationGasLimit:
+                                    userOperation.verificationGasLimit,
+                                callGasLimit: userOperation.callGasLimit,
+                                paymasterAndData:
+                                    userOperation.paymasterAndData,
+                                validAfter: validAfter,
+                                validUntil: validUntil
+                            }
+                        })
+                    }
+                ]
 
-            signatures.sort((left, right) =>
-                left.signer
-                    .toLowerCase()
-                    .localeCompare(right.signer.toLowerCase())
-            )
+                signatures.sort((left, right) =>
+                    left.signer
+                        .toLowerCase()
+                        .localeCompare(right.signer.toLowerCase())
+                )
 
-            const signatureBytes = concat(signatures.map((sig) => sig.data))
+                const signatureBytes = concat(signatures.map((sig) => sig.data))
 
-            return encodePacked(
-                ["uint48", "uint48", "bytes"],
-                [validAfter, validUntil, signatureBytes]
-            )
-        },
-        async getInitCode() {
-            if (safeDeployed) return "0x"
+                return encodePacked(
+                    ["uint48", "uint48", "bytes"],
+                    [validAfter, validUntil, signatureBytes]
+                )
+            },
+            async getInitCode() {
+                if (safeDeployed) return "0x"
 
-            safeDeployed = await isSmartAccountDeployed(client, accountAddress)
+                safeDeployed = await isSmartAccountDeployed(
+                    client,
+                    accountAddress
+                )
 
-            if (safeDeployed) return "0x"
+                if (safeDeployed) return "0x"
+
+                const initCodeCallData = await getAccountInitCode({
+                    owner: viemSigner.address,
+                    addModuleLibAddress,
+                    safe4337ModuleAddress,
+                    safeSingletonAddress,
+                    multiSendAddress,
+                    saltNonce,
+                    setupTransactions,
+                    safeModules
+                })
 
-            const initCodeCallData = await getAccountInitCode({
-                owner: viemSigner.address,
-                addModuleLibAddress,
-                safe4337ModuleAddress,
-                safeSingletonAddress,
-                multiSendAddress,
-                saltNonce,
-                setupTransactions,
-                safeModules
-            })
+                return concatHex([safeProxyFactoryAddress, initCodeCallData])
+            },
+            async getFactory() {
+                if (safeDeployed) return undefined
 
-            return concatHex([safeProxyFactoryAddress, initCodeCallData])
-        },
-        async getFactory() {
-            if (safeDeployed) return undefined
+                safeDeployed = await isSmartAccountDeployed(
+                    client,
+                    accountAddress
+                )
 
-            safeDeployed = await isSmartAccountDeployed(client, accountAddress)
+                if (safeDeployed) return undefined
 
-            if (safeDeployed) return undefined
+                return safeProxyFactoryAddress
+            },
+            async getFactoryData() {
+                if (safeDeployed) return undefined
 
-            return safeProxyFactoryAddress
-        },
-        async getFactoryData() {
-            if (safeDeployed) return undefined
-
-            safeDeployed = await isSmartAccountDeployed(client, accountAddress)
-
-            if (safeDeployed) return undefined
-
-            return await getAccountInitCode({
-                owner: viemSigner.address,
-                addModuleLibAddress,
-                safe4337ModuleAddress,
-                safeSingletonAddress,
-                multiSendAddress,
-                saltNonce,
-                setupTransactions,
-                safeModules
-            })
-        },
-        async encodeDeployCallData(_) {
-            throw new Error("Safe account doesn't support account deployment")
-        },
-        async encodeCallData(args) {
-            let to: Address
-            let value: bigint
-            let data: Hex
-            let operationType = 0
-
-            if (Array.isArray(args)) {
-                const argsArray = args as {
-                    to: Address
-                    value: bigint
-                    data: Hex
-                }[]
-
-                to = multiSendCallOnlyAddress
-                value = 0n
-
-                data = encodeMultiSend(
-                    argsArray.map((tx) => ({ ...tx, operation: 0 }))
+                safeDeployed = await isSmartAccountDeployed(
+                    client,
+                    accountAddress
                 )
-                operationType = 1
-            } else {
-                const singleTransaction = args as {
-                    to: Address
-                    value: bigint
-                    data: Hex
-                }
-                to = singleTransaction.to
-                data = singleTransaction.data
-                value = singleTransaction.value
-            }
 
-            return encodeFunctionData({
-                abi: [
-                    {
-                        inputs: [
-                            {
-                                internalType: "address",
-                                name: "to",
-                                type: "address"
-                            },
-                            {
-                                internalType: "uint256",
-                                name: "value",
-                                type: "uint256"
-                            },
-                            {
-                                internalType: "bytes",
-                                name: "data",
-                                type: "bytes"
-                            },
-                            {
-                                internalType: "uint8",
-                                name: "operation",
-                                type: "uint8"
-                            }
-                        ],
-                        name: "executeUserOpWithErrorString",
-                        outputs: [],
-                        stateMutability: "nonpayable",
-                        type: "function"
+                if (safeDeployed) return undefined
+
+                return await getAccountInitCode({
+                    owner: viemSigner.address,
+                    addModuleLibAddress,
+                    safe4337ModuleAddress,
+                    safeSingletonAddress,
+                    multiSendAddress,
+                    saltNonce,
+                    setupTransactions,
+                    safeModules
+                })
+            },
+            async encodeDeployCallData(_) {
+                throw new Error(
+                    "Safe account doesn't support account deployment"
+                )
+            },
+            async encodeCallData(args) {
+                let to: Address
+                let value: bigint
+                let data: Hex
+                let operationType = 0
+
+                if (Array.isArray(args)) {
+                    const argsArray = args as {
+                        to: Address
+                        value: bigint
+                        data: Hex
+                    }[]
+
+                    to = multiSendCallOnlyAddress
+                    value = 0n
+
+                    data = encodeMultiSend(
+                        argsArray.map((tx) => ({ ...tx, operation: 0 }))
+                    )
+                    operationType = 1
+                } else {
+                    const singleTransaction = args as {
+                        to: Address
+                        value: bigint
+                        data: Hex
                     }
-                ],
-                functionName: "executeUserOpWithErrorString",
-                args: [to, value, data, operationType]
-            })
-        },
-        async getDummySignature(_userOperation) {
-            return "0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
-        }
-    }
+                    to = singleTransaction.to
+                    data = singleTransaction.data
+                    value = singleTransaction.value
+                }
+
+                return encodeFunctionData({
+                    abi: [
+                        {
+                            inputs: [
+                                {
+                                    internalType: "address",
+                                    name: "to",
+                                    type: "address"
+                                },
+                                {
+                                    internalType: "uint256",
+                                    name: "value",
+                                    type: "uint256"
+                                },
+                                {
+                                    internalType: "bytes",
+                                    name: "data",
+                                    type: "bytes"
+                                },
+                                {
+                                    internalType: "uint8",
+                                    name: "operation",
+                                    type: "uint8"
+                                }
+                            ],
+                            name: "executeUserOpWithErrorString",
+                            outputs: [],
+                            stateMutability: "nonpayable",
+                            type: "function"
+                        }
+                    ],
+                    functionName: "executeUserOpWithErrorString",
+                    args: [to, value, data, operationType]
+                })
+            },
+            async getDummySignature(_userOperation) {
+                return "0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+            }
+        })
 
     return safeSmartAccount
 }

package/accounts/simple/signerToSimpleSmartAccount.ts

@@ -1,4 +1,3 @@
-import type { TypedData } from "viem"
 import {
     type Address,
     type Chain,
@@ -6,12 +5,10 @@ import {
     type Hex,
     type LocalAccount,
     type Transport,
-    type TypedDataDefinition,
     concatHex,
     encodeFunctionData
 } from "viem"
-import { toAccount } from "viem/accounts"
-import { getChainId, signMessage, signTypedData } from "viem/actions"
+import { getChainId, signMessage } from "viem/actions"
 import { getAccountNonce } from "../../actions/public/getAccountNonce"
 import { getSenderAddress } from "../../actions/public/getSenderAddress"
 import type {
@@ -23,6 +20,7 @@ import type { EntryPoint } from "../../types/entrypoint"
 import { getEntryPointVersion } from "../../utils"
 import { getUserOperationHash } from "../../utils/getUserOperationHash"
 import { isSmartAccountDeployed } from "../../utils/isSmartAccountDeployed"
+import { toSmartAccount } from "../toSmartAccount"
 import {
     SignTransactionNotSupportedBySmartAccount,
     type SmartAccount,
@@ -108,7 +106,7 @@ const getAccountAddress = async <
 
 export type SignerToSimpleSmartAccountParameters<
     entryPoint extends EntryPoint,
-    TSource extends string = "custom",
+    TSource extends string = string,
     TAddress extends Address = Address
 > = Prettify<{
     signer: SmartAccountSigner<TSource, TAddress>
@@ -127,7 +125,7 @@ export async function signerToSimpleSmartAccount<
     entryPoint extends EntryPoint,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined,
-    TSource extends string = "custom",
+    TSource extends string = string,
     TAddress extends Address = Address
 >(
     client: Client<TTransport, TChain, undefined>,
@@ -165,32 +163,17 @@ export async function signerToSimpleSmartAccount<
         accountAddress
     )
 
-    const account = toAccount({
+    return toSmartAccount({
         address: accountAddress,
-        async signMessage({ message }) {
-            return signMessage(client, { account: viemSigner, message })
+        signMessage: async (_) => {
+            throw new Error("Simple account isn't 1271 compliant")
         },
-        async signTransaction(_, __) {
+        signTransaction: (_, __) => {
             throw new SignTransactionNotSupportedBySmartAccount()
         },
-        async signTypedData<
-            const TTypedData extends TypedData | Record<string, unknown>,
-            TPrimaryType extends
-                | keyof TTypedData
-                | "EIP712Domain" = keyof TTypedData
-        >(typedData: TypedDataDefinition<TTypedData, TPrimaryType>) {
-            return signTypedData<TTypedData, TPrimaryType, TChain, undefined>(
-                client,
-                {
-                    account: viemSigner,
-                    ...typedData
-                }
-            )
-        }
-    })
-
-    return {
-        ...account,
+        signTypedData: async (_) => {
+            throw new Error("Simple account isn't 1271 compliant")
+        },
         client: client,
         publicKey: accountAddress,
         entryPoint: entryPointAddress,
@@ -202,7 +185,8 @@ export async function signerToSimpleSmartAccount<
             })
         },
         async signUserOperation(userOperation) {
-            return account.signMessage({
+            return signMessage(client, {
+                account: viemSigner,
                 message: {
                     raw: getUserOperationHash({
                         userOperation,
@@ -359,5 +343,5 @@ export async function signerToSimpleSmartAccount<
         async getDummySignature(_userOperation) {
             return "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c"
         }
-    }
+    })
 }