permissionless 0.1.45 → 0.2.0-rc-2

package/accounts/biconomy/abi/BiconomySmartAccountAbi.ts

@@ -1,59 +1,36 @@
-/**
- * The exeuctor abi, used to execute transactions on the Biconomy Modular Smart Account
- */
-export const BiconomyExecuteAbi = [
+export const FactoryAbi = [
     {
         inputs: [
             {
                 internalType: "address",
-                name: "dest",
+                name: "moduleSetupContract",
                 type: "address"
             },
-            {
-                internalType: "uint256",
-                name: "value",
-                type: "uint256"
-            },
             {
                 internalType: "bytes",
-                name: "func",
+                name: "moduleSetupData",
                 type: "bytes"
-            }
-        ],
-        name: "execute_ncC",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function"
-    },
-    {
-        inputs: [
-            {
-                internalType: "address[]",
-                name: "dest",
-                type: "address[]"
             },
             {
-                internalType: "uint256[]",
-                name: "value",
-                type: "uint256[]"
-            },
+                internalType: "uint256",
+                name: "index",
+                type: "uint256"
+            }
+        ],
+        name: "deployCounterFactualAccount",
+        outputs: [
             {
-                internalType: "bytes[]",
-                name: "func",
-                type: "bytes[]"
+                internalType: "address",
+                name: "proxy",
+                type: "address"
             }
         ],
-        name: "executeBatch_y6U",
-        outputs: [],
         stateMutability: "nonpayable",
         type: "function"
     }
 ] as const
 
-/**
- * The init abi, used to initialise Biconomy Modular Smart Account / setup default ECDSA module
- */
-export const BiconomyInitAbi = [
+export const BiconomyAbi = [
     {
         inputs: [
             {
@@ -101,5 +78,51 @@ export const BiconomyInitAbi = [
         ],
         stateMutability: "nonpayable",
         type: "function"
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "dest",
+                type: "address"
+            },
+            {
+                internalType: "uint256",
+                name: "value",
+                type: "uint256"
+            },
+            {
+                internalType: "bytes",
+                name: "func",
+                type: "bytes"
+            }
+        ],
+        name: "execute_ncC",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function"
+    },
+    {
+        inputs: [
+            {
+                internalType: "address[]",
+                name: "dest",
+                type: "address[]"
+            },
+            {
+                internalType: "uint256[]",
+                name: "value",
+                type: "uint256[]"
+            },
+            {
+                internalType: "bytes[]",
+                name: "func",
+                type: "bytes[]"
+            }
+        ],
+        name: "executeBatch_y6U",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function"
     }
-]
+] as const

package/accounts/biconomy/toBiconomySmartAccount.ts

@@ -0,0 +1,256 @@
+import type { Assign, Prettify } from "viem"
+import {
+    type Address,
+    type Client,
+    type Hex,
+    type LocalAccount,
+    encodeAbiParameters,
+    encodeFunctionData,
+    parseAbiParameters
+} from "viem"
+import {
+    type SmartAccount,
+    type SmartAccountImplementation,
+    entryPoint06Abi,
+    entryPoint06Address,
+    getUserOperationHash,
+    toSmartAccount
+} from "viem/account-abstraction"
+import { signMessage } from "viem/actions"
+import { getAccountNonce } from "../../actions/public/getAccountNonce"
+import { getSenderAddress } from "../../actions/public/getSenderAddress"
+import { BiconomyAbi, FactoryAbi } from "./abi/BiconomySmartAccountAbi"
+
+/**
+ * The account creation ABI for Biconomy Smart Account (from the biconomy SmartAccountFactory)
+ */
+
+/**
+ * Default addresses for Biconomy Smart Account
+ */
+const BICONOMY_ADDRESSES: {
+    ECDSA_OWNERSHIP_REGISTRY_MODULE: Address
+    FACTORY_ADDRESS: Address
+} = {
+    ECDSA_OWNERSHIP_REGISTRY_MODULE:
+        "0x0000001c5b32F37F5beA87BDD5374eB2aC54eA8e",
+    FACTORY_ADDRESS: "0x000000a56Aaca3e9a4C479ea6b6CD0DbcB6634F5"
+}
+
+/**
+ * Get the account initialization code for Biconomy smart account with ECDSA as default authorization module
+ * @param owner
+ * @param index
+ * @param factoryAddress
+ * @param ecdsaValidatorAddress
+ */
+const getAccountInitCode = async ({
+    owner,
+    index,
+    ecdsaModuleAddress
+}: {
+    owner: Address
+    index: bigint
+    ecdsaModuleAddress: Address
+}): Promise<Hex> => {
+    if (!owner) throw new Error("Owner account not found")
+
+    // Build the module setup data
+    const ecdsaOwnershipInitData = encodeFunctionData({
+        abi: BiconomyAbi,
+        functionName: "initForSmartAccount",
+        args: [owner]
+    })
+
+    // Build the account init code
+    return encodeFunctionData({
+        abi: FactoryAbi,
+        functionName: "deployCounterFactualAccount",
+        args: [ecdsaModuleAddress, ecdsaOwnershipInitData, index]
+    })
+}
+
+export type ToBiconomySmartAccountParameters = Prettify<{
+    client: Client
+    owner: LocalAccount
+    address?: Address | undefined
+    entryPoint?: {
+        address: Address
+        version: "0.6"
+    }
+    nonceKey?: bigint
+    index?: bigint
+    factoryAddress?: Address
+    ecdsaModuleAddress?: Address
+}>
+
+export type BiconomySmartAccountImplementation = Assign<
+    SmartAccountImplementation<typeof entryPoint06Abi, "0.6">,
+    { sign: NonNullable<SmartAccountImplementation["sign"]> }
+>
+
+export type ToBiconomySmartAccountReturnType = Prettify<
+    SmartAccount<BiconomySmartAccountImplementation>
+>
+
+/**
+ * Build a Biconomy modular smart account from a private key, that use the ECDSA signer behind the scene
+ * @param client
+ * @param privateKey
+ * @param entryPoint
+ * @param index
+ * @param factoryAddress
+ * @param ecdsaModuleAddress
+ */
+
+export async function toBiconomySmartAccount(
+    parameters: ToBiconomySmartAccountParameters
+): Promise<ToBiconomySmartAccountReturnType> {
+    const { owner, client, index = 0n, address } = parameters
+
+    const entryPoint = {
+        address: parameters.entryPoint?.address ?? entryPoint06Address,
+        abi: entryPoint06Abi,
+        version: parameters.entryPoint?.version ?? "0.6"
+    }
+
+    const factoryAddress =
+        parameters.factoryAddress ?? BICONOMY_ADDRESSES.FACTORY_ADDRESS
+
+    let accountAddress: Address | undefined = address
+
+    const ecdsaModuleAddress =
+        parameters.ecdsaModuleAddress ??
+        BICONOMY_ADDRESSES.ECDSA_OWNERSHIP_REGISTRY_MODULE
+
+    const getFactoryArgs = async () => {
+        return {
+            factory: factoryAddress,
+            factoryData: await getAccountInitCode({
+                owner: owner.address,
+                index,
+                ecdsaModuleAddress
+            })
+        }
+    }
+
+    return toSmartAccount({
+        client,
+        entryPoint,
+        getFactoryArgs,
+        async getAddress() {
+            if (accountAddress) return accountAddress
+
+            const { factory, factoryData } = await getFactoryArgs()
+
+            // Get the sender address based on the init code
+            accountAddress = await getSenderAddress(client, {
+                factory,
+                factoryData,
+                entryPointAddress: entryPoint.address
+            })
+
+            return accountAddress
+        },
+        async getNonce(args) {
+            const address = await this.getAddress()
+            return getAccountNonce(client, {
+                address,
+                entryPointAddress: entryPoint.address,
+                key: args?.key ?? parameters?.nonceKey
+            })
+        },
+        encodeCalls: async (calls) => {
+            if (calls.length > 1) {
+                // Encode a batched call
+                return encodeFunctionData({
+                    abi: BiconomyAbi,
+                    functionName: "executeBatch_y6U",
+                    args: [
+                        calls.map((a) => a.to),
+                        calls.map((a) => a.value ?? 0n),
+                        calls.map((a) => a.data ?? "0x")
+                    ]
+                })
+            }
+            const { to, value, data } = calls[0]
+            // Encode a simple call
+            return encodeFunctionData({
+                abi: BiconomyAbi,
+                functionName: "execute_ncC",
+                args: [to, value ?? 0n, data ?? "0x"]
+            })
+        },
+        // Get simple dummy signature for ECDSA module authorization
+        async getStubSignature() {
+            const dynamicPart = ecdsaModuleAddress.substring(2).padEnd(40, "0")
+            return `0x0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000${dynamicPart}000000000000000000000000000000000000000000000000000000000000004181d4b4981670cb18f99f0b4a66446df1bf5b204d24cfcb659bf38ba27a4359b5711649ec2423c5e1247245eba2964679b6a1dbb85c992ae40b9b00c6935b02ff1b00000000000000000000000000000000000000000000000000000000000000`
+        },
+        async sign({ hash }) {
+            return this.signMessage({ message: hash })
+        },
+        async signMessage({ message }) {
+            let signature = await owner.signMessage({
+                message
+            })
+
+            const potentiallyIncorrectV = Number.parseInt(
+                signature.slice(-2),
+                16
+            )
+            if (![27, 28].includes(potentiallyIncorrectV)) {
+                const correctV = potentiallyIncorrectV + 27
+                signature = (signature.slice(0, -2) +
+                    correctV.toString(16)) as Hex
+            }
+            return encodeAbiParameters(
+                [{ type: "bytes" }, { type: "address" }],
+                [signature, ecdsaModuleAddress]
+            )
+        },
+        async signTypedData(typedData) {
+            let signature = await owner.signTypedData(typedData)
+
+            const potentiallyIncorrectV = Number.parseInt(
+                signature.slice(-2),
+                16
+            )
+            if (![27, 28].includes(potentiallyIncorrectV)) {
+                const correctV = potentiallyIncorrectV + 27
+                signature = (signature.slice(0, -2) +
+                    correctV.toString(16)) as Hex
+            }
+            return encodeAbiParameters(
+                [{ type: "bytes" }, { type: "address" }],
+                [signature, ecdsaModuleAddress]
+            )
+        },
+        // Sign a user operation
+        async signUserOperation(parameters) {
+            const { chainId = client.chain?.id, ...userOperation } = parameters
+
+            if (!chainId) throw new Error("Chain id not found")
+
+            const hash = getUserOperationHash({
+                userOperation: {
+                    ...userOperation,
+                    sender: userOperation.sender ?? (await this.getAddress()),
+                    signature: "0x"
+                },
+                entryPointAddress: entryPoint.address,
+                entryPointVersion: entryPoint.version,
+                chainId: chainId
+            })
+            const signature = await signMessage(client, {
+                account: owner,
+                message: { raw: hash }
+            })
+            // userOp signature is encoded module signature + module address
+            const signatureWithModuleAddress = encodeAbiParameters(
+                parseAbiParameters("bytes, address"),
+                [signature, ecdsaModuleAddress]
+            )
+            return signatureWithModuleAddress
+        }
+    })
+}

package/accounts/index.ts

@@ -1,105 +1,74 @@
 import {
-    type PrivateKeyToSimpleSmartAccountParameters,
-    privateKeyToSimpleSmartAccount
-} from "./simple/privateKeyToSimpleSmartAccount"
+    type SimpleSmartAccountImplementation,
+    type ToSimpleSmartAccountParameters,
+    type ToSimpleSmartAccountReturnType,
+    toSimpleSmartAccount
+} from "./simple/toSimpleSmartAccount"
 
 import {
-    type SignerToSimpleSmartAccountParameters,
-    type SimpleSmartAccount,
-    signerToSimpleSmartAccount
-} from "./simple/signerToSimpleSmartAccount"
+    type LightAccountVersion,
+    type LightSmartAccountImplementation,
+    type ToLightSmartAccountParameters,
+    type ToLightSmartAccountReturnType,
+    toLightSmartAccount
+} from "./light/toLightSmartAccount"
 
 import {
-    type PrivateKeyToLightSmartAccountParameters,
-    privateKeyToLightSmartAccount
-} from "./light/privateKeyToLightSmartAccount"
+    type ToTrustSmartAccountParameters,
+    type ToTrustSmartAccountReturnType,
+    type TrustSmartAccountImplementation,
+    toTrustSmartAccount
+} from "./trust/toTrustSmartAccount"
 
 import {
-    type LightSmartAccount,
-    type SignerToLightSmartAccountParameters,
-    signerToLightSmartAccount
-} from "./light/signerToLightSmartAccount"
-
-import {
-    type SignerToTrustSmartAccountParameters,
-    type TrustSmartAccount,
-    signerToTrustSmartAccount
-} from "./trust/signerToTrustSmartAccount"
-
-import {
-    type PrivateKeyToTrustSmartAccountParameters,
-    privateKeyToTrustSmartAccount
-} from "./trust/privateKeyToTrustSmartAccount"
-
-import {
-    type PrivateKeyToSafeSmartAccountParameters,
-    privateKeyToSafeSmartAccount
-} from "./safe/privateKeyToSafeSmartAccount"
-
-import {
-    type SafeSmartAccount,
+    type SafeSmartAccountImplementation,
     type SafeVersion,
-    type SignerToSafeSmartAccountParameters,
-    signerToSafeSmartAccount
-} from "./safe/signerToSafeSmartAccount"
-
-import {
-    type KernelEcdsaSmartAccount,
-    type SignerToEcdsaKernelSmartAccountParameters,
-    signerToEcdsaKernelSmartAccount
-} from "./kernel/signerToEcdsaKernelSmartAccount"
+    type ToSafeSmartAccountParameters,
+    type ToSafeSmartAccountReturnType,
+    toSafeSmartAccount
+} from "./safe/toSafeSmartAccount"
 
 import {
-    type BiconomySmartAccount,
-    type SignerToBiconomySmartAccountParameters,
-    signerToBiconomySmartAccount
-} from "./biconomy/signerToBiconomySmartAccount"
+    type EcdsaKernelSmartAccountImplementation,
+    type KernelVersion,
+    type ToEcdsaKernelSmartAccountParameters,
+    type ToEcdsaKernelSmartAccountReturnType,
+    toEcdsaKernelSmartAccount
+} from "./kernel/toEcdsaKernelSmartAccount"
 
 import {
-    type PrivateKeyToBiconomySmartAccountParameters,
-    privateKeyToBiconomySmartAccount
-} from "./biconomy/privateKeyToBiconomySmartAccount"
-
-import {
-    SignTransactionNotSupportedBySmartAccount,
-    type SmartAccount,
-    type SmartAccountSigner
-} from "./types"
-
-import { toSmartAccount } from "./toSmartAccount"
+    type BiconomySmartAccountImplementation,
+    type ToBiconomySmartAccountParameters,
+    type ToBiconomySmartAccountReturnType,
+    toBiconomySmartAccount
+} from "./biconomy/toBiconomySmartAccount"
 
 export {
+    type ToSimpleSmartAccountParameters,
+    type SimpleSmartAccountImplementation,
+    type ToSimpleSmartAccountReturnType,
+    toSimpleSmartAccount,
+    type LightAccountVersion,
+    type ToLightSmartAccountParameters,
+    type LightSmartAccountImplementation,
+    type ToLightSmartAccountReturnType,
+    toLightSmartAccount,
+    type ToTrustSmartAccountParameters,
+    type TrustSmartAccountImplementation,
+    type ToTrustSmartAccountReturnType,
+    toTrustSmartAccount,
+    type ToSafeSmartAccountParameters,
+    type SafeSmartAccountImplementation,
+    type ToSafeSmartAccountReturnType,
+    toSafeSmartAccount,
+    type ToEcdsaKernelSmartAccountParameters,
+    type EcdsaKernelSmartAccountImplementation,
+    type ToEcdsaKernelSmartAccountReturnType,
     type SafeVersion,
-    type SmartAccountSigner,
-    type SafeSmartAccount,
-    signerToSafeSmartAccount,
-    type SimpleSmartAccount,
-    signerToSimpleSmartAccount,
-    type LightSmartAccount,
-    signerToLightSmartAccount,
-    type TrustSmartAccount,
-    signerToTrustSmartAccount,
-    privateKeyToTrustSmartAccount,
-    SignTransactionNotSupportedBySmartAccount,
-    privateKeyToBiconomySmartAccount,
-    privateKeyToSimpleSmartAccount,
-    privateKeyToLightSmartAccount,
-    type SmartAccount,
-    privateKeyToSafeSmartAccount,
-    type KernelEcdsaSmartAccount,
-    signerToEcdsaKernelSmartAccount,
-    type BiconomySmartAccount,
-    signerToBiconomySmartAccount,
-    toSmartAccount,
-    type SignerToSimpleSmartAccountParameters,
-    type SignerToLightSmartAccountParameters,
-    type SignerToSafeSmartAccountParameters,
-    type PrivateKeyToSimpleSmartAccountParameters,
-    type PrivateKeyToLightSmartAccountParameters,
-    type PrivateKeyToSafeSmartAccountParameters,
-    type SignerToEcdsaKernelSmartAccountParameters,
-    type SignerToBiconomySmartAccountParameters,
-    type PrivateKeyToBiconomySmartAccountParameters,
-    type SignerToTrustSmartAccountParameters,
-    type PrivateKeyToTrustSmartAccountParameters
+    type KernelVersion,
+    toEcdsaKernelSmartAccount,
+    type ToBiconomySmartAccountReturnType,
+    type ToBiconomySmartAccountParameters,
+    type BiconomySmartAccountImplementation,
+    toBiconomySmartAccount
 }