@zerodev/sdk 4.0.31 → 4.0.33

package/src/kernel-zerodev/owner/getCustodialOwner.ts

@@ -1,9 +1,30 @@
-import type { SmartAccountSigner } from "@alchemy/aa-core";
+import type { SignTypedDataParams, SmartAccountSigner } from "@alchemy/aa-core";
 import { API_URL } from "../constants.js";
 import axios from "axios";
-import type { Hex } from "viem";
-import type { SignTypedDataParams } from "@alchemy/aa-core";
+import { TurnkeyClient } from "@turnkey/http";
 
+/**
+ * Params to get a custodial owner
+ * Priv / pub key combo or custodial file path should be in different types
+ */
+type GetCustodialOwnerParams = {
+  // ZeroDev api url
+  apiUrl?: string;
+  // Turnkey client (if the client want to reuse it
+  turnKeyClient?: TurnkeyClient;
+
+  // Direct access to priv / pub key
+  privateKey?: string;
+  publicKey?: string;
+  keyId?: string;
+
+  // Or read them from the custodial file path
+  custodialFilePath?: string;
+};
+
+/**
+ * Returns a signer for a custodial wallet via TurnKey
+ */
 export async function getCustodialOwner(
   identifier: string,
   {
@@ -12,14 +33,10 @@ export async function getCustodialOwner(
     publicKey,
     keyId,
     apiUrl = API_URL,
-  }: {
-    privateKey?: string;
-    publicKey?: string;
-    keyId?: string;
-    custodialFilePath?: string;
-    apiUrl?: string;
-  }
+    turnKeyClient,
+  }: GetCustodialOwnerParams
 ): Promise<SmartAccountSigner | undefined> {
+  // Extract data from the custodial file path if provided
   if (custodialFilePath) {
     let fsModule;
     try {
@@ -30,45 +47,86 @@ export async function getCustodialOwner(
     }
     const data = fsModule.readFileSync(custodialFilePath, "utf8");
     const values = data.split("\n");
+    // Override the values, if they are provided, to the one from the custodial file
     [privateKey, publicKey, keyId] = values;
   }
-  let TurnkeySigner;
-  try {
-    TurnkeySigner =
-      require.resolve("@turnkey/ethers") &&
-      require("@turnkey/ethers").TurnkeySigner;
-  } catch (error) {
-    console.log(
-      "@turnkey/ethers module not available. Skipping FS operation..."
-    );
-    return;
-  }
+
+  // Ensure we have the required values
   if (!privateKey || !publicKey || !keyId) {
     throw new Error(
       "Must provide custodialFilePath or privateKey, publicKey, and keyId."
     );
   }
 
-  const response = await axios.post(`${apiUrl}/wallets/${identifier}`, {
-    keyId,
-  });
+  // Get our turnkey client (build it if needed)
+  if (!turnKeyClient) {
+    // Try to fetch turnkey client & api key stamper
+    let TurnkeyClient;
+    let ApiKeyStamper;
+    // TODO: Would be cleaner with something like radash and a tryit function?
+    try {
+      TurnkeyClient =
+        require.resolve("@turnkey/http") &&
+        require("@turnkey/http").TurnkeyClient;
+      ApiKeyStamper =
+        require.resolve("@turnkey/api-key-stamper") &&
+        require("@turnkey/api-key-stamper").ApiKeyStamper;
+    } catch (error) {
+      console.log(
+        "@turnkey/http or @turnkey/api-key-stamper module not available. Skipping FS operation..."
+      );
+      return;
+    }
 
-  const turnkeySigner = new TurnkeySigner({
-    apiPublicKey: publicKey,
-    apiPrivateKey: privateKey,
-    baseUrl: "https://api.turnkey.com",
+    // Build the turnkey client
+    turnKeyClient = new TurnkeyClient(
+      {
+        baseUrl: "https://api.turnkey.com",
+      },
+      new ApiKeyStamper({
+        apiPublicKey: publicKey,
+        apiPrivateKey: privateKey,
+      })
+    );
+  }
+
+  // Get the wallet identifier from the API
+  const response = await axios.post<any, { data: { walletId: string } }>(
+    `${apiUrl}/wallets/${identifier}`,
+    {
+      keyId,
+    }
+  );
+
+  // Build the turnkey viem account
+  let createAccount;
+  try {
+    createAccount =
+      require.resolve("@turnkey/viem") &&
+      require("@turnkey/viem").createAccount;
+  } catch (error) {
+    console.log("@turnkey/viem module not available. Skipping FS operation...");
+    return;
+  }
+  const turnkeySigner = await createAccount({
+    client: turnKeyClient,
     organizationId: keyId,
     privateKeyId: response.data.walletId,
   });
+
+  // Return an alchemy AA signer from the turnkey signer
   return {
-    getAddress: async () => (await turnkeySigner.getAddress()) as `0x${string}`,
-    signMessage: async (msg: Uint8Array | string) =>
-      (await turnkeySigner.signMessage(msg)) as `0x${string}`,
+    getAddress: async () => turnkeySigner.address,
+    signMessage: async (msg: Uint8Array | string) => {
+      if (typeof msg === "string") {
+        // If the msg is a string, sign it directly
+        return turnkeySigner.signMessage({ message: msg });
+      } else {
+        // Otherwise, sign the raw data
+        return turnkeySigner.signMessage({ message: { raw: msg } });
+      }
+    },
     signTypedData: async (params: SignTypedDataParams) =>
-      (await turnkeySigner.signTypedData(
-        params.domain,
-        params.types,
-        params.message
-      )) as Hex,
+      turnkeySigner.signTypedData(params),
   };
 }

package/src/kernel-zerodev/owner/passkey/createPasskeyOwner.ts

@@ -27,7 +27,6 @@ export async function createPasskeyOwner({
   fallback?: () => Promise<SmartAccountSigner | undefined>;
   apiUrl?: string;
 }): Promise<SmartAccountSigner | undefined> {
-  //@ts-expect-error
   if (typeof window !== "undefined") {
     const challenge = generateRandomBuffer();
     let credentials = undefined;
@@ -43,9 +42,7 @@ export async function createPasskeyOwner({
       const attestation = await getWebAuthnAttestation({
         publicKey: {
           rp: {
-            //@ts-expect-error
             id: window.location.hostname,
-            //@ts-expect-error
             name: window.location.hostname,
           },
           authenticatorSelection: {
@@ -100,7 +97,6 @@ export async function createPasskeyOwner({
       };
       return owner;
     } catch (e) {
-      //@ts-expect-error
       if (e instanceof DOMException && e.name === "InvalidStateError") {
         if (fallback) return await fallback();
       }

package/src/kernel-zerodev/owner/passkey/getAutocompletePasskeyOwner.ts

@@ -28,7 +28,6 @@ export async function getAutocompletePasskeyOwner({
     return;
   }
 
-  //@ts-expect-error
   if (typeof window !== "undefined") {
     const challenge = generateRandomBuffer();
     try {
@@ -37,7 +36,6 @@ export async function getAutocompletePasskeyOwner({
         await getWebAuthnAssertion(base64UrlEncode(challenge), {
           mediation: "conditional",
           publicKey: {
-            //@ts-expect-error
             rpId: window.location.hostname,
             userVerification: "required",
           },

package/src/kernel-zerodev/owner/passkey/getPasskeyOwner.ts

@@ -22,7 +22,6 @@ export async function getPasskeyOwner({
   apiUrl?: string;
   withCredentials?: boolean;
 }): Promise<SmartAccountSigner | undefined> {
-  //@ts-expect-error
   if (typeof window !== "undefined") {
     const challenge = generateRandomBuffer();
     try {
@@ -30,7 +29,6 @@ export async function getPasskeyOwner({
       const assertion = JSON.parse(
         await getWebAuthnAssertion(base64UrlEncode(challenge), {
           publicKey: {
-            //@ts-expect-error
             rpId: window.location.hostname,
             userVerification: "required",
             allowCredentials: withCredentials

package/src/kernel-zerodev/owner/passkey/utils.ts

@@ -23,7 +23,6 @@ export const es256 = -7;
 
 export const generateRandomBuffer = (): ArrayBuffer => {
   const arr = new Uint8Array(32);
-  //@ts-expect-error
   crypto.getRandomValues(arr);
   return arr.buffer;
 };

package/src/kernel-zerodev/paymaster/base.ts

@@ -36,45 +36,51 @@ export abstract class Paymaster {
     paymasterProvider?: PaymasterAndBundlerProviders;
     shouldOverrideFee?: boolean;
   }): Promise<any> {
-    try {
-      const hexifiedUserOp = deepHexlify(await resolveProperties(userOp));
-      let resolvedERC20UserOp;
-      let hexifiedERC20UserOp: any;
-      if (erc20UserOp) {
-        resolvedERC20UserOp = await resolveProperties(erc20UserOp);
+    const hexifiedUserOp = deepHexlify(await resolveProperties(userOp));
+    let resolvedERC20UserOp;
+    let hexifiedERC20UserOp: any;
+    if (erc20UserOp) {
+      resolvedERC20UserOp = await resolveProperties(erc20UserOp);
 
-        hexifiedERC20UserOp = hexifyUserOp(resolvedERC20UserOp);
-      }
-      const chainId = await getChainId(this.provider.getProjectId());
-      if (!chainId) throw new Error("ChainId not found");
-      let requestBodyParams = Object.fromEntries(
-        Object.entries({
-          projectId: this.provider.getProjectId(),
-          chainId,
-          userOp: hexifiedUserOp,
-          entryPointAddress: ENTRYPOINT_ADDRESS,
-          callData: callData instanceof Promise ? await callData : callData,
-          tokenAddress: gasTokenAddress,
-          erc20UserOp: hexifiedERC20UserOp,
-          erc20CallData:
-            erc20CallData instanceof Promise
-              ? await erc20CallData
-              : erc20CallData,
-          paymasterProvider,
-          shouldOverrideFee,
-        }).filter(([_, value]) => value !== undefined)
-      );
-      const { data: paymasterResp } = await axios.post(
-        `${PAYMASTER_URL}/sign`,
-        {
-          ...requestBodyParams,
-        },
-        { headers: { "Content-Type": "application/json" } }
-      );
-      return paymasterResp;
-    } catch (error) {
-      console.log(error);
-      return undefined;
+      hexifiedERC20UserOp = hexifyUserOp(resolvedERC20UserOp);
     }
+    const chainId = await getChainId(this.provider.getProjectId());
+    if (!chainId) throw new Error("ChainId not found");
+    let requestBodyParams = Object.fromEntries(
+      Object.entries({
+        projectId: this.provider.getProjectId(),
+        chainId,
+        userOp: hexifiedUserOp,
+        entryPointAddress: ENTRYPOINT_ADDRESS,
+        callData: callData instanceof Promise ? await callData : callData,
+        gasTokenData:
+          gasTokenAddress && hexifiedERC20UserOp && erc20CallData
+            ? {
+                tokenAddress: gasTokenAddress,
+                erc20UserOp: hexifiedERC20UserOp,
+                erc20CallData:
+                  erc20CallData instanceof Promise
+                    ? await erc20CallData
+                    : erc20CallData,
+              }
+            : undefined,
+        tokenAddress: gasTokenAddress,
+        erc20UserOp: hexifiedERC20UserOp,
+        erc20CallData:
+          erc20CallData instanceof Promise
+            ? await erc20CallData
+            : erc20CallData,
+        paymasterProvider,
+        shouldOverrideFee,
+      }).filter(([_, value]) => value !== undefined)
+    );
+    const { data: paymasterResp } = await axios.post(
+      `${PAYMASTER_URL}/getPaymasterAndData`,
+      {
+        ...requestBodyParams,
+      },
+      { headers: { "Content-Type": "application/json" } }
+    );
+    return paymasterResp;
   }
 }

package/src/kernel-zerodev/paymaster/token-paymaster.ts

@@ -3,6 +3,7 @@ import {
   type BytesLike,
   type UserOperationCallData,
   type UserOperationStruct,
+  type BatchUserOperationCallData,
 } from "@alchemy/aa-core";
 import axios from "axios";
 import {
@@ -14,12 +15,11 @@ import {
 } from "viem";
 import { ERC20Abi } from "../abis/ERC20Abi.js";
 import { KernelAccountAbi } from "../abis/KernelAccountAbi.js";
-import { MultiSendAbi } from "../abis/MultiSendAbi.js";
 import {
   PAYMASTER_URL,
   ENTRYPOINT_ADDRESS,
-  MULTISEND_ADDR,
   ERC20_APPROVAL_AMOUNT,
+  MULTISEND_ADDR,
 } from "../constants.js";
 import {
   AccountNotConnected,
@@ -36,7 +36,13 @@ import {
   type PaymasterConfig,
 } from "./types.js";
 import { getChainId } from "../api/index.js";
+import { MultiSendAbi } from "../abis/MultiSendAbi.js";
 
+export function isBatchUserOperationCallData(
+  data: any
+): data is BatchUserOperationCallData {
+  return data && Array.isArray(data);
+}
 export class TokenPaymaster extends Paymaster {
   constructor(
     provider: ZeroDevProvider,
@@ -68,7 +74,12 @@ export class TokenPaymaster extends Paymaster {
   async decodeMainCallFromCallData(
     kernelAddress: PromiseOrValue<string>,
     callData: PromiseOrValue<BytesLike>
-  ): Promise<UserOperationCallDataWithDelegate | undefined> {
+  ): Promise<
+    | UserOperationCallData
+    | BatchUserOperationCallData
+    | UserOperationCallDataWithDelegate
+    | undefined
+  > {
     let data: Hex = "0x";
     if (callData instanceof Promise) {
       const _data = await callData;
@@ -113,6 +124,13 @@ export class TokenPaymaster extends Paymaster {
           };
         }
         return mainCall;
+      } else if (functionName === "executeBatch") {
+        const [txs] = args;
+        return txs.map((tx) => ({
+          target: tx.to,
+          value: tx.value ?? 0n,
+          data: tx.data,
+        }));
       }
     } catch (error) {
       return {
@@ -127,9 +145,11 @@ export class TokenPaymaster extends Paymaster {
     return;
   }
 
-  async getERC20UserOp(
+  async getERC20UserOp<
+    T extends UserOperationCallData | BatchUserOperationCallData
+  >(
     struct: UserOperationStruct,
-    mainCall: UserOperationCallDataWithDelegate,
+    mainCall: T,
     gasTokenAddress: Hex,
     paymasterAddress: Hex
   ): Promise<UserOperationStruct | undefined> {
@@ -146,10 +166,17 @@ export class TokenPaymaster extends Paymaster {
       if (!this.provider.account) {
         throw AccountNotConnected;
       }
-      const erc20CallData = await this.provider.account.encodeBatchExecute([
-        approveData,
-        mainCall,
-      ]);
+
+      let calls: BatchUserOperationCallData;
+
+      if (isBatchUserOperationCallData(mainCall)) {
+        calls = [approveData, ...mainCall];
+      } else {
+        calls = [approveData, mainCall];
+      }
+      const erc20CallData = await this.provider.account.encodeBatchExecute(
+        calls
+      );
       return {
         ...struct,
         callData: erc20CallData,
@@ -176,52 +203,46 @@ export class TokenPaymaster extends Paymaster {
     paymasterProvider?: PaymasterAndBundlerProviders,
     shouldOverrideFee?: boolean
   ): Promise<UserOperationStruct | undefined> {
-    try {
-      const mainCall = await this.decodeMainCallFromCallData(
-        struct.sender,
-        struct.callData
-      );
-      if (!mainCall) {
-        throw IncorrectCallDataForTokenPaymaster;
-      }
-      const chainId = await getChainId(this.provider.getProjectId());
-      if (!chainId) {
-        throw new Error("ChainId not found");
-      }
-      const gasTokenAddress = getGasTokenAddress(
-        this.paymasterConfig.gasToken,
-        chainId
+    const mainCall = await this.decodeMainCallFromCallData(
+      struct.sender,
+      struct.callData
+    );
+    if (!mainCall) {
+      throw IncorrectCallDataForTokenPaymaster;
+    }
+    const chainId = await getChainId(this.provider.getProjectId());
+    if (!chainId) {
+      throw new Error("ChainId not found");
+    }
+    const gasTokenAddress = getGasTokenAddress(
+      this.paymasterConfig.gasToken,
+      chainId
+    );
+    let paymasterAddress = await this.getPaymasterAddress(paymasterProvider);
+    if (
+      gasTokenAddress !== undefined &&
+      paymasterAddress !== undefined &&
+      isAddress(paymasterAddress)
+    ) {
+      const erc20UserOp = await this.getERC20UserOp(
+        struct,
+        mainCall,
+        gasTokenAddress,
+        paymasterAddress
       );
-      let paymasterAddress = await this.getPaymasterAddress(paymasterProvider);
-      if (
-        gasTokenAddress !== undefined &&
-        paymasterAddress !== undefined &&
-        isAddress(paymasterAddress)
-      ) {
-        const erc20UserOp = await this.getERC20UserOp(
-          struct,
-          mainCall,
-          gasTokenAddress,
-          paymasterAddress
-        );
-        if (!erc20UserOp) {
-          return;
-        }
-        const paymasterResp = await this.signUserOp({
-          userOp: struct,
-          callData: struct.callData,
-          gasTokenAddress,
-          erc20UserOp,
-          erc20CallData: erc20UserOp.callData,
-          paymasterProvider,
-          shouldOverrideFee,
-        });
-        if (paymasterResp) {
-          return paymasterResp;
-        }
+      if (!erc20UserOp) {
+        return;
       }
-    } catch (error) {
-      console.log(error);
+      const paymasterResp = await this.signUserOp({
+        userOp: struct,
+        callData: struct.callData,
+        gasTokenAddress,
+        erc20UserOp,
+        erc20CallData: erc20UserOp.callData,
+        paymasterProvider,
+        shouldOverrideFee,
+      });
+      return paymasterResp;
     }
     return;
   }

package/src/kernel-zerodev/paymaster/verifying-paymaster.ts

@@ -19,19 +19,12 @@ export class VerifyingPaymaster extends Paymaster {
     paymasterProvider?: PaymasterAndBundlerProviders,
     shouldOverrideFee?: boolean
   ): Promise<UserOperationStruct | undefined> {
-    try {
-      const hexifiedUserOp = deepHexlify(await resolveProperties(struct));
-      const paymasterResp = await this.signUserOp({
-        userOp: hexifiedUserOp,
-        paymasterProvider,
-        shouldOverrideFee,
-      });
-      if (paymasterResp) {
-        return paymasterResp;
-      }
-    } catch (error) {
-      console.log(error);
-    }
-    return;
+    const hexifiedUserOp = deepHexlify(await resolveProperties(struct));
+    const paymasterResp = await this.signUserOp({
+      userOp: hexifiedUserOp,
+      paymasterProvider,
+      shouldOverrideFee,
+    });
+    return paymasterResp;
   }
 }

package/src/kernel-zerodev/provider.ts

@@ -298,8 +298,7 @@ export class ZeroDevProvider extends SmartAccountProvider<HttpTransport> {
   dummyPaymasterDataMiddleware: AccountMiddlewareFn = async (
     struct: UserOperationStruct
   ): Promise<UserOperationStruct> => {
-    struct.paymasterAndData =
-      "0xfe7dbcab8aaee4eb67943c1e6be95b1d065985c6000000000000000000000000000000000000000000000000000001869aa31cf400000000000000000000000000000000000000000000000000000000000000007dfe2190f34af27b265bae608717cdc9368b471fc0c097ab7b4088f255b4961e57b039e7e571b15221081c5dce7bcb93459b27a3ab65d2f8a889f4a40b4022801b";
+    struct.paymasterAndData = "0x";
     return struct;
   };