permissionless 0.0.15 → 0.0.17

package/accounts/biconomy/signerToBiconomySmartAccount.ts

@@ -0,0 +1,364 @@
+import {
+    type Address,
+    type Chain,
+    type Client,
+    type Hex,
+    type LocalAccount,
+    type Transport,
+    concatHex,
+    encodeAbiParameters,
+    encodeFunctionData,
+    encodePacked,
+    getContractAddress,
+    hexToBigInt,
+    keccak256,
+    parseAbiParameters
+} from "viem"
+import { toAccount } from "viem/accounts"
+import {
+    getBytecode,
+    getChainId,
+    signMessage,
+    signTypedData
+} from "viem/actions"
+import { getAccountNonce } from "../../actions/public/getAccountNonce.js"
+import { getUserOperationHash } from "../../utils/getUserOperationHash.js"
+import {
+    SignTransactionNotSupportedBySmartAccount,
+    type SmartAccount,
+    type SmartAccountSigner
+} from "../types.js"
+import {
+    BiconomyExecuteAbi,
+    BiconomyInitAbi
+} from "./abi/BiconomySmartAccountAbi.js"
+// import Abis
+
+export type BiconomySmartAccount<
+    transport extends Transport = Transport,
+    chain extends Chain | undefined = Chain | undefined
+> = SmartAccount<"biconomySmartAccount", transport, chain>
+
+/**
+ * The account creation ABI for Biconomy Smart Account (from the biconomy SmartAccountFactory)
+ */
+
+const createAccountAbi = [
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "moduleSetupContract",
+                type: "address"
+            },
+            {
+                internalType: "bytes",
+                name: "moduleSetupData",
+                type: "bytes"
+            },
+            {
+                internalType: "uint256",
+                name: "index",
+                type: "uint256"
+            }
+        ],
+        name: "deployCounterFactualAccount",
+        outputs: [
+            {
+                internalType: "address",
+                name: "proxy",
+                type: "address"
+            }
+        ],
+        stateMutability: "nonpayable",
+        type: "function"
+    }
+] as const
+
+/**
+ * Default addresses for Biconomy Smart Account
+ */
+const BICONOMY_ADDRESSES: {
+    ECDSA_OWNERSHIP_REGISTRY_MODULE: Address
+    ACCOUNT_V2_0_LOGIC: Address
+    FACTORY_ADDRESS: Address
+    DEFAULT_FALLBACK_HANDLER_ADDRESS: Address
+} = {
+    ECDSA_OWNERSHIP_REGISTRY_MODULE:
+        "0x0000001c5b32F37F5beA87BDD5374eB2aC54eA8e",
+    ACCOUNT_V2_0_LOGIC: "0x0000002512019Dafb59528B82CB92D3c5D2423aC",
+    FACTORY_ADDRESS: "0x000000a56Aaca3e9a4C479ea6b6CD0DbcB6634F5",
+    DEFAULT_FALLBACK_HANDLER_ADDRESS:
+        "0x0bBa6d96BD616BedC6BFaa341742FD43c60b83C1"
+}
+
+const BICONOMY_PROXY_CREATION_CODE =
+    "0x6080346100aa57601f61012038819003918201601f19168301916001600160401b038311848410176100af578084926020946040528339810103126100aa57516001600160a01b0381168082036100aa5715610065573055604051605a90816100c68239f35b60405162461bcd60e51b815260206004820152601e60248201527f496e76616c696420696d706c656d656e746174696f6e206164647265737300006044820152606490fd5b600080fd5b634e487b7160e01b600052604160045260246000fdfe608060405230546000808092368280378136915af43d82803e156020573d90f35b3d90fdfea2646970667358221220a03b18dce0be0b4c9afe58a9eb85c35205e2cf087da098bbf1d23945bf89496064736f6c63430008110033"
+
+/**
+ * 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,
+    factoryAddress,
+    ecdsaModuleAddress
+}: {
+    owner: Address
+    index: bigint
+    factoryAddress: Address
+    ecdsaModuleAddress: Address
+}): Promise<Hex> => {
+    if (!owner) throw new Error("Owner account not found")
+
+    // Build the module setup data
+    const ecdsaOwnershipInitData = encodeFunctionData({
+        abi: BiconomyInitAbi,
+        functionName: "initForSmartAccount",
+        args: [owner]
+    })
+
+    // Build the account init code
+    return concatHex([
+        factoryAddress,
+        encodeFunctionData({
+            abi: createAccountAbi,
+            functionName: "deployCounterFactualAccount",
+            args: [ecdsaModuleAddress, ecdsaOwnershipInitData, index]
+        }) as Hex
+    ])
+}
+
+const getAccountAddress = async ({
+    factoryAddress,
+    accountLogicAddress,
+    fallbackHandlerAddress,
+    ecdsaModuleAddress,
+    owner,
+    index = 0n
+}: {
+    factoryAddress: Address
+    accountLogicAddress: Address
+    fallbackHandlerAddress: Address
+    ecdsaModuleAddress: Address
+    owner: Address
+    index?: bigint
+}): Promise<Address> => {
+    // Build the module setup data
+    const ecdsaOwnershipInitData = encodeFunctionData({
+        abi: BiconomyInitAbi,
+        functionName: "initForSmartAccount",
+        args: [owner]
+    })
+
+    // Build account init code
+    const initialisationData = encodeFunctionData({
+        abi: BiconomyInitAbi,
+        functionName: "init",
+        args: [
+            fallbackHandlerAddress,
+            ecdsaModuleAddress,
+            ecdsaOwnershipInitData
+        ]
+    })
+
+    const deploymentCode = encodePacked(
+        ["bytes", "uint256"],
+        [BICONOMY_PROXY_CREATION_CODE, hexToBigInt(accountLogicAddress)]
+    )
+
+    const salt = keccak256(
+        encodePacked(
+            ["bytes32", "uint256"],
+            [keccak256(encodePacked(["bytes"], [initialisationData])), index]
+        )
+    )
+
+    return getContractAddress({
+        from: factoryAddress,
+        salt,
+        bytecode: deploymentCode,
+        opcode: "CREATE2"
+    })
+}
+
+/**
+ * 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 accountLogicAddress
+ * @param ecdsaModuleAddress
+ */
+export async function signerToBiconomySmartAccount<
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined,
+    TSource extends string = "custom",
+    TAddress extends Address = Address
+>(
+    client: Client<TTransport, TChain>,
+    {
+        signer,
+        entryPoint,
+        index = 0n,
+        factoryAddress = BICONOMY_ADDRESSES.FACTORY_ADDRESS,
+        accountLogicAddress = BICONOMY_ADDRESSES.ACCOUNT_V2_0_LOGIC,
+        fallbackHandlerAddress = BICONOMY_ADDRESSES.DEFAULT_FALLBACK_HANDLER_ADDRESS,
+        ecdsaModuleAddress = BICONOMY_ADDRESSES.ECDSA_OWNERSHIP_REGISTRY_MODULE
+    }: {
+        signer: SmartAccountSigner<TSource, TAddress>
+        entryPoint: Address
+        index?: bigint
+        factoryAddress?: Address
+        accountLogicAddress?: Address
+        fallbackHandlerAddress?: Address
+        ecdsaModuleAddress?: Address
+    }
+): Promise<BiconomySmartAccount<TTransport, TChain>> {
+    // Get the private key related account
+    const viemSigner: LocalAccount = {
+        ...signer,
+        signTransaction: (_, __) => {
+            throw new SignTransactionNotSupportedBySmartAccount()
+        }
+    } as LocalAccount
+
+    // Helper to generate the init code for the smart account
+    const generateInitCode = () =>
+        getAccountInitCode({
+            owner: viemSigner.address,
+            index,
+            factoryAddress,
+            ecdsaModuleAddress
+        })
+
+    // Fetch account address and chain id
+    const [accountAddress, chainId] = await Promise.all([
+        getAccountAddress({
+            owner: viemSigner.address,
+            ecdsaModuleAddress,
+            factoryAddress,
+            accountLogicAddress,
+            fallbackHandlerAddress,
+            index
+        }),
+        getChainId(client)
+    ])
+
+    if (!accountAddress) throw new Error("Account address not found")
+
+    // Build the EOA Signer
+    const account = toAccount({
+        address: accountAddress,
+        async signMessage({ message }) {
+            return signMessage(client, { account: viemSigner, message })
+        },
+        async signTransaction(_, __) {
+            throw new SignTransactionNotSupportedBySmartAccount()
+        },
+        async signTypedData(typedData) {
+            return signTypedData(client, { account: viemSigner, ...typedData })
+        }
+    })
+
+    return {
+        ...account,
+        client: client,
+        publicKey: accountAddress,
+        entryPoint: entryPoint,
+        source: "biconomySmartAccount",
+
+        // Get the nonce of the smart account
+        async getNonce() {
+            return getAccountNonce(client, {
+                sender: accountAddress,
+                entryPoint: entryPoint
+            })
+        },
+
+        // Sign a user operation
+        async signUserOperation(userOperation) {
+            const hash = getUserOperationHash({
+                userOperation: {
+                    ...userOperation,
+                    signature: "0x"
+                },
+                entryPoint: entryPoint,
+                chainId: chainId
+            })
+            const signature = await signMessage(client, {
+                account: viemSigner,
+                message: { raw: hash }
+            })
+            // userOp signature is encoded module signature + module address
+            const signatureWithModuleAddress = encodeAbiParameters(
+                parseAbiParameters("bytes, address"),
+                [signature, ecdsaModuleAddress]
+            )
+            return signatureWithModuleAddress
+        },
+
+        // Encode the init code
+        async getInitCode() {
+            const contractCode = await getBytecode(client, {
+                address: accountAddress
+            })
+
+            if ((contractCode?.length ?? 0) > 2) return "0x"
+
+            return generateInitCode()
+        },
+
+        // Encode the deploy call data
+        async encodeDeployCallData(_) {
+            throw new Error("Doesn't support account deployment")
+        },
+
+        // Encode a call
+        async encodeCallData(args) {
+            if (Array.isArray(args)) {
+                // Encode a batched call
+                const argsArray = args as {
+                    to: Address
+                    value: bigint
+                    data: Hex
+                }[]
+
+                return encodeFunctionData({
+                    abi: BiconomyExecuteAbi,
+                    functionName: "executeBatch_y6U",
+                    args: [
+                        argsArray.map((a) => a.to),
+                        argsArray.map((a) => a.value),
+                        argsArray.map((a) => a.data)
+                    ]
+                })
+            }
+            const { to, value, data } = args as {
+                to: Address
+                value: bigint
+                data: Hex
+            }
+            // Encode a simple call
+            return encodeFunctionData({
+                abi: BiconomyExecuteAbi,
+                functionName: "execute_ncC",
+                args: [to, value, data]
+            })
+        },
+
+        // Get simple dummy signature for ECDSA module authorization
+        async getDummySignature() {
+            const moduleAddress =
+                BICONOMY_ADDRESSES.ECDSA_OWNERSHIP_REGISTRY_MODULE
+            const dynamicPart = moduleAddress.substring(2).padEnd(40, "0")
+            return `0x0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000${dynamicPart}000000000000000000000000000000000000000000000000000000000000004181d4b4981670cb18f99f0b4a66446df1bf5b204d24cfcb659bf38ba27a4359b5711649ec2423c5e1247245eba2964679b6a1dbb85c992ae40b9b00c6935b02ff1b00000000000000000000000000000000000000000000000000000000000000`
+        }
+    }
+}

package/accounts/index.ts

@@ -18,6 +18,11 @@ import {
     signerToEcdsaKernelSmartAccount
 } from "./kernel/signerToEcdsaKernelSmartAccount.js"
 
+import {
+    type BiconomySmartAccount,
+    signerToBiconomySmartAccount
+} from "./biconomy/signerToBiconomySmartAccount.js"
+
 import {
     SignTransactionNotSupportedBySmartAccount,
     type SmartAccount,
@@ -36,5 +41,7 @@ export {
     type SmartAccount,
     privateKeyToSafeSmartAccount,
     type KernelEcdsaSmartAccount,
-    signerToEcdsaKernelSmartAccount
+    signerToEcdsaKernelSmartAccount,
+    type BiconomySmartAccount,
+    signerToBiconomySmartAccount
 }

package/accounts/kernel/signerToEcdsaKernelSmartAccount.ts

@@ -1,9 +1,9 @@
 import {
-    type Account,
     type Address,
     type Chain,
     type Client,
     type Hex,
+    type LocalAccount,
     type Transport,
     concatHex,
     encodeFunctionData,
@@ -210,7 +210,9 @@ const getAccountAddress = async <
  */
 export async function signerToEcdsaKernelSmartAccount<
     TTransport extends Transport = Transport,
-    TChain extends Chain | undefined = Chain | undefined
+    TChain extends Chain | undefined = Chain | undefined,
+    TSource extends string = "custom",
+    TAddress extends Address = Address
 >(
     client: Client<TTransport, TChain>,
     {
@@ -222,7 +224,7 @@ export async function signerToEcdsaKernelSmartAccount<
         ecdsaValidatorAddress = KERNEL_ADDRESSES.ECDSA_VALIDATOR,
         deployedAccountAddress
     }: {
-        signer: SmartAccountSigner
+        signer: SmartAccountSigner<TSource, TAddress>
         entryPoint: Address
         index?: bigint
         factoryAddress?: Address
@@ -232,15 +234,12 @@ export async function signerToEcdsaKernelSmartAccount<
     }
 ): Promise<KernelEcdsaSmartAccount<TTransport, TChain>> {
     // Get the private key related account
-    const viemSigner: Account =
-        signer.type === "local"
-            ? ({
-                  ...signer,
-                  signTransaction: (_, __) => {
-                      throw new SignTransactionNotSupportedBySmartAccount()
-                  }
-              } as Account)
-            : (signer as Account)
+    const viemSigner: LocalAccount = {
+        ...signer,
+        signTransaction: (_, __) => {
+            throw new SignTransactionNotSupportedBySmartAccount()
+        }
+    } as LocalAccount
 
     // Helper to generate the init code for the smart account
     const generateInitCode = () =>
@@ -345,14 +344,13 @@ export async function signerToEcdsaKernelSmartAccount<
                         }))
                     ]
                 })
-            } else {
-                // Encode a simple call
-                return encodeFunctionData({
-                    abi: KernelExecuteAbi,
-                    functionName: "execute",
-                    args: [_tx.to, _tx.value, _tx.data, 0]
-                })
             }
+            // Encode a simple call
+            return encodeFunctionData({
+                abi: KernelExecuteAbi,
+                functionName: "execute",
+                args: [_tx.to, _tx.value, _tx.data, 0]
+            })
         },
 
         // Get simple dummy signature

package/accounts/signerToSafeSmartAccount.ts

@@ -1,13 +1,14 @@
 import {
-    type Account,
     type Address,
     type Chain,
     type Client,
     type Hex,
+    type LocalAccount,
     type SignableMessage,
     type Transport,
     type TypedData,
     type TypedDataDefinition,
+    concat,
     concatHex,
     encodeFunctionData,
     encodePacked,
@@ -39,13 +40,17 @@ export type SafeVersion = "1.4.1"
 const EIP712_SAFE_OPERATION_TYPE = {
     SafeOp: [
         { type: "address", name: "safe" },
-        { type: "bytes", name: "callData" },
         { type: "uint256", name: "nonce" },
-        { type: "uint256", name: "preVerificationGas" },
-        { type: "uint256", name: "verificationGasLimit" },
+        { type: "bytes", name: "initCode" },
+        { type: "bytes", name: "callData" },
         { type: "uint256", name: "callGasLimit" },
+        { type: "uint256", name: "verificationGasLimit" },
+        { type: "uint256", name: "preVerificationGas" },
         { type: "uint256", name: "maxFeePerGas" },
         { type: "uint256", name: "maxPriorityFeePerGas" },
+        { type: "bytes", name: "paymasterAndData" },
+        { type: "uint48", name: "validAfter" },
+        { type: "uint48", name: "validUntil" },
         { type: "address", name: "entryPoint" }
     ]
 }
@@ -490,7 +495,9 @@ const getDefaultAddresses = (
  */
 export async function signerToSafeSmartAccount<
     TTransport extends Transport = Transport,
-    TChain extends Chain | undefined = Chain | undefined
+    TChain extends Chain | undefined = Chain | undefined,
+    TSource extends string = "custom",
+    TAddress extends Address = Address
 >(
     client: Client<TTransport, TChain>,
     {
@@ -504,11 +511,13 @@ export async function signerToSafeSmartAccount<
         multiSendAddress: _multiSendAddress,
         multiSendCallOnlyAddress: _multiSendCallOnlyAddress,
         saltNonce = 0n,
+        validUntil = 0,
+        validAfter = 0,
         safeModules = [],
         setupTransactions = []
     }: {
         safeVersion: SafeVersion
-        signer: SmartAccountSigner
+        signer: SmartAccountSigner<TSource, TAddress>
         entryPoint: Address
         addModuleLibAddress?: Address
         safe4337ModuleAddress?: Address
@@ -517,6 +526,8 @@ export async function signerToSafeSmartAccount<
         multiSendAddress?: Address
         multiSendCallOnlyAddress?: Address
         saltNonce?: bigint
+        validUntil?: number
+        validAfter?: number
         setupTransactions?: {
             to: Address
             data: Address
@@ -527,15 +538,12 @@ export async function signerToSafeSmartAccount<
 ): Promise<SafeSmartAccount<TTransport, TChain>> {
     const chainId = await getChainId(client)
 
-    const viemSigner: Account =
-        signer.type === "local"
-            ? ({
-                  ...signer,
-                  signTransaction: (_, __) => {
-                      throw new SignTransactionNotSupportedBySmartAccount()
-                  }
-              } as Account)
-            : (signer as Account)
+    const viemSigner: LocalAccount = {
+        ...signer,
+        signTransaction: (_, __) => {
+            throw new SignTransactionNotSupportedBySmartAccount()
+        }
+    } as LocalAccount
 
     const {
         addModuleLibAddress,
@@ -632,8 +640,6 @@ export async function signerToSafeSmartAccount<
             })
         },
         async signUserOperation(userOperation) {
-            // const timestamps = 0n
-
             const signatures = [
                 {
                     signer: viemSigner.address,
@@ -648,17 +654,20 @@ export async function signerToSafeSmartAccount<
                         message: {
                             safe: accountAddress,
                             callData: userOperation.callData,
+                            entryPoint: entryPoint,
                             nonce: userOperation.nonce,
+                            initCode: userOperation.initCode,
+                            maxFeePerGas: userOperation.maxFeePerGas,
+                            maxPriorityFeePerGas:
+                                userOperation.maxPriorityFeePerGas,
                             preVerificationGas:
                                 userOperation.preVerificationGas,
                             verificationGasLimit:
                                 userOperation.verificationGasLimit,
                             callGasLimit: userOperation.callGasLimit,
-                            maxFeePerGas: userOperation.maxFeePerGas,
-                            maxPriorityFeePerGas:
-                                userOperation.maxPriorityFeePerGas,
-                            // signatureTimestamps: timestamps,
-                            entryPoint: entryPoint
+                            paymasterAndData: userOperation.paymasterAndData,
+                            validAfter: validAfter,
+                            validUntil: validUntil
                         }
                     })
                 }
@@ -670,17 +679,12 @@ export async function signerToSafeSmartAccount<
                     .localeCompare(right.signer.toLowerCase())
             )
 
-            let signatureBytes: Address = "0x"
-            for (const sig of signatures) {
-                signatureBytes += sig.data.slice(2)
-            }
-
-            // const signatureWithTimestamps = encodePacked(
-            //     ["uint96", "bytes"],
-            //     [timestamps, signatureBytes]
-            // )
+            const signatureBytes = concat(signatures.map((sig) => sig.data))
 
-            return signatureBytes
+            return encodePacked(
+                ["uint48", "uint48", "bytes"],
+                [validAfter, validUntil, signatureBytes]
+            )
         },
         async getInitCode() {
             const contractCode = await getBytecode(client, {
@@ -769,7 +773,7 @@ export async function signerToSafeSmartAccount<
             })
         },
         async getDummySignature() {
-            return "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c"
+            return "0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
         }
     }
 }

package/accounts/signerToSimpleSmartAccount.ts

@@ -1,9 +1,9 @@
 import {
-    type Account,
     type Address,
     type Chain,
     type Client,
     type Hex,
+    type LocalAccount,
     type Transport,
     concatHex,
     encodeFunctionData
@@ -102,7 +102,9 @@ const getAccountAddress = async <
  */
 export async function signerToSimpleSmartAccount<
     TTransport extends Transport = Transport,
-    TChain extends Chain | undefined = Chain | undefined
+    TChain extends Chain | undefined = Chain | undefined,
+    TSource extends string = "custom",
+    TAddress extends Address = Address
 >(
     client: Client<TTransport, TChain>,
     {
@@ -111,21 +113,18 @@ export async function signerToSimpleSmartAccount<
         entryPoint,
         index = 0n
     }: {
-        signer: SmartAccountSigner
+        signer: SmartAccountSigner<TSource, TAddress>
         factoryAddress: Address
         entryPoint: Address
         index?: bigint
     }
 ): Promise<SimpleSmartAccount<TTransport, TChain>> {
-    const viemSigner: Account =
-        signer.type === "local"
-            ? ({
-                  ...signer,
-                  signTransaction: (_, __) => {
-                      throw new SignTransactionNotSupportedBySmartAccount()
-                  }
-              } as Account)
-            : (signer as Account)
+    const viemSigner: LocalAccount = {
+        ...signer,
+        signTransaction: (_, __) => {
+            throw new SignTransactionNotSupportedBySmartAccount()
+        }
+    } as LocalAccount
 
     const [accountAddress, chainId] = await Promise.all([
         getAccountAddress<TTransport, TChain>({

package/accounts/types.ts

@@ -1,6 +1,5 @@
 import {
     type Abi,
-    type Account,
     type Address,
     BaseError,
     type Client,
@@ -58,7 +57,7 @@ export type SmartAccount<
     signUserOperation: (UserOperation: UserOperation) => Promise<Hex>
 }
 
-export type SmartAccountSigner<TAddress extends Address = Address> = Omit<
-    Account<TAddress>,
-    "signTransaction"
->
+export type SmartAccountSigner<
+    TSource extends string,
+    TAddress extends Address = Address
+> = Omit<LocalAccount<TSource, TAddress>, "signTransaction">

package/actions/smartAccount/prepareUserOperationRequest.ts

@@ -26,7 +26,7 @@ export type SponsorUserOperationMiddleware = {
 }
 
 export type PrepareUserOperationRequestParameters<
-    TAccount extends SmartAccount | undefined = SmartAccount | undefined,
+    TAccount extends SmartAccount | undefined = SmartAccount | undefined
 > = {
     userOperation: PartialBy<
         UserOperation,