permissionless 0.1.4 → 0.1.6

package/accounts/biconomy/signerToBiconomySmartAccount.ts

@@ -16,7 +16,6 @@ import {
     keccak256,
     parseAbiParameters
 } from "viem"
-import { toAccount } from "viem/accounts"
 import { getChainId, signMessage, signTypedData } from "viem/actions"
 import { getAccountNonce } from "../../actions/public/getAccountNonce"
 import type { Prettify } from "../../types"
@@ -24,6 +23,7 @@ import type { ENTRYPOINT_ADDRESS_V06_TYPE } 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,
@@ -269,11 +269,22 @@ export async function signerToBiconomySmartAccount<
         accountAddress
     )
 
-    // Build the EOA Signer
-    const account = toAccount({
+    return toSmartAccount({
         address: accountAddress,
         async signMessage({ message }) {
-            return signMessage(client, { account: viemSigner, message })
+            let signature = await signMessage(client, {
+                account: viemSigner,
+                message
+            })
+            const potentiallyIncorrectV = parseInt(signature.slice(-2), 16)
+            if (![27, 28].includes(potentiallyIncorrectV)) {
+                const correctV = potentiallyIncorrectV + 27
+                signature = signature.slice(0, -2) + correctV.toString(16)
+            }
+            return encodeAbiParameters(
+                [{ type: "bytes" }, { type: "address" }],
+                [signature as Hex, ecdsaModuleAddress]
+            )
         },
         async signTransaction(_, __) {
             throw new SignTransactionNotSupportedBySmartAccount()
@@ -284,18 +295,25 @@ export async function signerToBiconomySmartAccount<
                 | keyof TTypedData
                 | "EIP712Domain" = keyof TTypedData
         >(typedData: TypedDataDefinition<TTypedData, TPrimaryType>) {
-            return signTypedData<TTypedData, TPrimaryType, TChain, undefined>(
-                client,
-                {
-                    account: viemSigner,
-                    ...typedData
-                }
+            let signature = await signTypedData<
+                TTypedData,
+                TPrimaryType,
+                TChain,
+                undefined
+            >(client, {
+                account: viemSigner,
+                ...typedData
+            })
+            const potentiallyIncorrectV = parseInt(signature.slice(-2), 16)
+            if (![27, 28].includes(potentiallyIncorrectV)) {
+                const correctV = potentiallyIncorrectV + 27
+                signature = signature.slice(0, -2) + correctV.toString(16)
+            }
+            return encodeAbiParameters(
+                [{ type: "bytes" }, { type: "address" }],
+                [signature as Hex, ecdsaModuleAddress]
             )
-        }
-    })
-
-    return {
-        ...account,
+        },
         client: client,
         publicKey: accountAddress,
         entryPoint: entryPointAddress,
@@ -415,5 +433,5 @@ export async function signerToBiconomySmartAccount<
             const dynamicPart = moduleAddress.substring(2).padEnd(40, "0")
             return `0x0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000${dynamicPart}000000000000000000000000000000000000000000000000000000000000004181d4b4981670cb18f99f0b4a66446df1bf5b204d24cfcb659bf38ba27a4359b5711649ec2423c5e1247245eba2964679b6a1dbb85c992ae40b9b00c6935b02ff1b00000000000000000000000000000000000000000000000000000000000000`
         }
-    }
+    })
 }

package/accounts/index.ts

@@ -44,6 +44,8 @@ import {
     type SmartAccountSigner
 } from "./types"
 
+import { toSmartAccount } from "./toSmartAccount"
+
 export {
     type SafeVersion,
     type SmartAccountSigner,
@@ -60,6 +62,7 @@ export {
     signerToEcdsaKernelSmartAccount,
     type BiconomySmartAccount,
     signerToBiconomySmartAccount,
+    toSmartAccount,
     type SignerToSimpleSmartAccountParameters,
     type SignerToSafeSmartAccountParameters,
     type PrivateKeyToSimpleSmartAccountParameters,

package/accounts/kernel/signerToEcdsaKernelSmartAccount.ts

@@ -11,7 +11,6 @@ import {
     encodeFunctionData,
     isAddressEqual
 } from "viem"
-import { toAccount } from "viem/accounts"
 import {
     getChainId,
     readContract,
@@ -25,6 +24,7 @@ import type { ENTRYPOINT_ADDRESS_V06_TYPE } from "../../types/entrypoint"
 import { getEntryPointVersion } from "../../utils"
 import { getUserOperationHash } from "../../utils/getUserOperationHash"
 import { isSmartAccountDeployed } from "../../utils/isSmartAccountDeployed"
+import { toSmartAccount } from "../toSmartAccount"
 import type { SmartAccount } from "../types"
 import {
     SignTransactionNotSupportedBySmartAccount,
@@ -289,8 +289,7 @@ export async function signerToEcdsaKernelSmartAccount<
         accountAddress
     )
 
-    // Build the EOA Signer
-    const account = toAccount({
+    return toSmartAccount({
         address: accountAddress,
         async signMessage({ message }) {
             return signMessage(client, { account: viemSigner, message })
@@ -311,11 +310,7 @@ export async function signerToEcdsaKernelSmartAccount<
                     ...typedData
                 }
             )
-        }
-    })
-
-    return {
-        ...account,
+        },
         client: client,
         publicKey: accountAddress,
         entryPoint: entryPointAddress,
@@ -420,5 +415,5 @@ export async function signerToEcdsaKernelSmartAccount<
         async getDummySignature(_userOperation) {
             return "0x00000000fffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c"
         }
-    }
+    })
 }

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,
@@ -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
 }