permissionless 0.1.4 → 0.1.6

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,
@@ -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"
         }
-    }
+    })
 }

package/accounts/toSmartAccount.ts

@@ -0,0 +1,167 @@
+import {
+    type Abi,
+    type Address,
+    type Chain,
+    type Client,
+    type CustomSource,
+    type EncodeDeployDataParameters,
+    type Hex,
+    type SignableMessage,
+    type Transport,
+    type TypedDataDefinition,
+    concat,
+    encodeAbiParameters
+} from "viem"
+import { toAccount } from "viem/accounts"
+import type { UserOperation } from "../types"
+import type { EntryPoint, GetEntryPointVersion } from "../types/entrypoint"
+import { isSmartAccountDeployed } from "../utils"
+import {
+    SignTransactionNotSupportedBySmartAccount,
+    type SmartAccount
+} from "./types"
+
+const MAGIC_BYTES =
+    "0x6492649264926492649264926492649264926492649264926492649264926492"
+
+export function toSmartAccount<
+    TAccountSource extends CustomSource,
+    TEntryPoint extends EntryPoint,
+    TSource extends string = string,
+    transport extends Transport = Transport,
+    chain extends Chain | undefined = Chain | undefined,
+    TAbi extends Abi | readonly unknown[] = Abi
+>({
+    address,
+    client,
+    source,
+    entryPoint,
+    getNonce,
+    getInitCode,
+    getFactory,
+    getFactoryData,
+    encodeCallData,
+    getDummySignature,
+    encodeDeployCallData,
+    signUserOperation,
+    signMessage,
+    signTypedData
+}: TAccountSource & {
+    source: TSource
+    client: Client<transport, chain>
+    entryPoint: TEntryPoint
+    getNonce: () => Promise<bigint>
+    getInitCode: () => Promise<Hex>
+    getFactory: () => Promise<Address | undefined>
+    getFactoryData: () => Promise<Hex | undefined>
+    encodeCallData: (
+        args:
+            | {
+                  to: Address
+                  value: bigint
+                  data: Hex
+              }
+            | {
+                  to: Address
+                  value: bigint
+                  data: Hex
+              }[]
+    ) => Promise<Hex>
+    getDummySignature(
+        userOperation: UserOperation<GetEntryPointVersion<TEntryPoint>>
+    ): Promise<Hex>
+    encodeDeployCallData: ({
+        abi,
+        args,
+        bytecode
+    }: EncodeDeployDataParameters<TAbi>) => Promise<Hex>
+    signUserOperation: (
+        userOperation: UserOperation<GetEntryPointVersion<TEntryPoint>>
+    ) => Promise<Hex>
+}): SmartAccount<TEntryPoint, TSource, transport, chain, TAbi> {
+    const account = toAccount({
+        address: address,
+        signMessage: async ({ message }: { message: SignableMessage }) => {
+            const isDeployed = await isSmartAccountDeployed(client, address)
+            const signature = await signMessage({ message })
+
+            if (isDeployed) return signature
+
+            const abiEncodedMessage = encodeAbiParameters(
+                [
+                    {
+                        type: "address",
+                        name: "create2Factory"
+                    },
+                    {
+                        type: "bytes",
+                        name: "factoryCalldata"
+                    },
+                    {
+                        type: "bytes",
+                        name: "originalERC1271Signature"
+                    }
+                ],
+                [
+                    (await getFactory()) ?? "0x", // "0x should never happen if it's deployed"
+                    (await getFactoryData()) ?? "0x", // "0x should never happen if it's deployed"
+                    signature
+                ]
+            )
+
+            return concat([abiEncodedMessage, MAGIC_BYTES])
+        },
+        signTypedData: async (typedData) => {
+            const isDeployed = await isSmartAccountDeployed(client, address)
+            const signature = await signTypedData(
+                typedData as TypedDataDefinition
+            )
+
+            if (isDeployed) return signature
+
+            const abiEncodedMessage = encodeAbiParameters(
+                [
+                    {
+                        type: "address",
+                        name: "create2Factory"
+                    },
+                    {
+                        type: "bytes",
+                        name: "factoryCalldata"
+                    },
+                    {
+                        type: "bytes",
+                        name: "originalERC1271Signature"
+                    }
+                ],
+                [
+                    (await getFactory()) ?? "0x", // "0x should never happen if it's deployed"
+                    (await getFactoryData()) ?? "0x", // "0x should never happen if it's deployed"
+                    signature
+                ]
+            )
+
+            return concat([abiEncodedMessage, MAGIC_BYTES])
+        },
+        async signTransaction(_, __) {
+            throw new SignTransactionNotSupportedBySmartAccount()
+        }
+    })
+
+    return {
+        ...account,
+        source,
+        client,
+        type: "local",
+        entryPoint,
+        publicKey: address,
+        getNonce,
+        getInitCode,
+        getFactory,
+        getFactoryData,
+        encodeCallData,
+        getDummySignature,
+        encodeDeployCallData,
+        signUserOperation
+    } as SmartAccount<TEntryPoint, TSource, transport, chain, TAbi>
+}

package/accounts/types.ts

@@ -28,11 +28,11 @@ export class SignTransactionNotSupportedBySmartAccount extends BaseError {
 
 export type SmartAccount<
     entryPoint extends EntryPoint,
-    Name extends string = string,
+    TSource extends string = string,
     transport extends Transport = Transport,
     chain extends Chain | undefined = Chain | undefined,
     TAbi extends Abi | readonly unknown[] = Abi
-> = LocalAccount<Name> & {
+> = LocalAccount<TSource> & {
     client: Client<transport, chain>
     entryPoint: entryPoint
     getNonce: () => Promise<bigint>

package/clients/createSmartAccountClient.ts

@@ -49,11 +49,12 @@ export type SmartAccountClientConfig<
     Pick<
         ClientConfig<transport, chain, account>,
         "cacheTime" | "chain" | "key" | "name" | "pollingInterval"
-    > & {
-        account?: account
-        bundlerTransport: Transport
-    } & Middleware<entryPoint> & {
-            entryPoint: entryPoint
+    > &
+        Middleware<entryPoint> & {
+            account: account
+            bundlerTransport: Transport
+        } & {
+            entryPoint?: entryPoint
         }
 >
 
@@ -78,20 +79,20 @@ export type SmartAccountClientConfig<
  */
 
 export function createSmartAccountClient<
-    entryPoint extends EntryPoint,
-    TSmartAccount extends SmartAccount<entryPoint> | undefined =
-        | SmartAccount<entryPoint>
-        | undefined,
+    TSmartAccount extends SmartAccount<TEntryPoint> | undefined,
     TTransport extends Transport = Transport,
-    TChain extends Chain | undefined = undefined
+    TChain extends Chain | undefined = undefined,
+    TEntryPoint extends EntryPoint = TSmartAccount extends SmartAccount<infer U>
+        ? U
+        : never
 >(
     parameters: SmartAccountClientConfig<
-        entryPoint,
+        TEntryPoint,
         TTransport,
         TChain,
         TSmartAccount
     >
-): SmartAccountClient<entryPoint, TTransport, TChain, TSmartAccount> {
+): SmartAccountClient<TEntryPoint, TTransport, TChain, TSmartAccount> {
     const {
         key = "Account",
         name = "Smart Account Client",
@@ -109,5 +110,5 @@ export function createSmartAccountClient<
         smartAccountActions({
             middleware: parameters.middleware
         })
-    ) as SmartAccountClient<entryPoint, TTransport, TChain, TSmartAccount>
+    ) as SmartAccountClient<TEntryPoint, TTransport, TChain, TSmartAccount>
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "permissionless",
-    "version": "0.1.4",
+    "version": "0.1.6",
     "author": "Pimlico",
     "homepage": "https://docs.pimlico.io/permissionless",
     "repository": "github:pimlicolabs/permissionless.js",