@zerodev/sdk 4.0.0

package/src/kernel-zerodev/middleware/gas-estimator.ts

@@ -0,0 +1,183 @@
+import type { ZeroDevProvider } from "../provider.js";
+import {
+  deepHexlify,
+  type Hex,
+  type UserOperationStruct,
+  resolveProperties,
+  type BigNumberish,
+  type UserOperationEstimateGasResponse,
+} from "@alchemy/aa-core";
+import { ENTRYPOINT_ADDRESS } from "../constants.js";
+import { calcPreVerificationGas } from "../utils/calc-pre-verification-gas.js";
+
+export const withZeroDevGasEstimator = (
+  provider: ZeroDevProvider
+): ZeroDevProvider => {
+  provider.withFeeDataGetter(async (struct) => {
+    let overrides = await resolveProperties({
+      maxFeePerGas: struct.maxFeePerGas ?? 0n,
+      maxPriorityFeePerGas: struct.maxPriorityFeePerGas ?? 0n,
+    });
+
+    let maxFeePerGas, maxPriorityFeePerGas;
+
+    try {
+      ({ maxFeePerGas, maxPriorityFeePerGas } = await eip1559GasPrice(
+        provider
+      ));
+    } catch (error: any) {
+      console.warn(
+        "getGas: eth_maxPriorityFeePerGas failed, falling back to legacy gas price."
+      );
+    }
+
+    if (maxFeePerGas === undefined || maxPriorityFeePerGas === undefined) {
+      const feeData = await getFeeData(provider);
+      maxFeePerGas = feeData?.maxFeePerGas ? BigInt(feeData?.maxFeePerGas) : 0n;
+      maxPriorityFeePerGas = feeData.maxPriorityFeePerGas
+        ? BigInt(feeData.maxPriorityFeePerGas)
+        : 0n;
+    }
+
+    if (
+      maxFeePerGas < BigInt(overrides.maxFeePerGas) ||
+      maxPriorityFeePerGas < BigInt(overrides.maxPriorityFeePerGas)
+    ) {
+      return overrides;
+    }
+    return { maxFeePerGas, maxPriorityFeePerGas };
+  });
+
+  provider.withGasEstimator(async (struct) => {
+    if (
+      struct.callGasLimit !== undefined &&
+      struct.verificationGasLimit !== undefined &&
+      struct.preVerificationGas !== undefined
+    ) {
+      return struct;
+    }
+    const initCode = await provider.account?.getInitCode();
+    const initGas = await estimateCreationGas(provider, initCode);
+    const partialStruct: UserOperationStruct = {
+      ...struct,
+      callGasLimit:
+        initCode !== undefined && initCode.length > 2
+          ? BigInt("1000000")
+          : BigInt(55000),
+      verificationGasLimit: BigInt(110000) + initGas,
+      preVerificationGas: BigInt(100000),
+    };
+
+    partialStruct.preVerificationGas = await getPreVerificationGas(
+      partialStruct
+    );
+
+    const request = deepHexlify(await resolveProperties(partialStruct));
+    let userOpGasEstimates: UserOperationEstimateGasResponse | undefined;
+    userOpGasEstimates = await provider.rpcClient.estimateUserOperationGas(
+      request,
+      ENTRYPOINT_ADDRESS
+    );
+    const { preVerificationGas, verificationGasLimit, callGasLimit } =
+      userOpGasEstimates;
+    request.preVerificationGas =
+      (BigInt(preVerificationGas) * 12n) / 10n ?? request.preVerificationGas;
+    request.verificationGasLimit =
+      (BigInt(verificationGasLimit) * 12n) / 10n ??
+      request.verificationGasLimit;
+    request.callGasLimit =
+      (BigInt(callGasLimit) * 12n) / 10n ?? request.callGasLimit;
+
+    return {
+      ...struct,
+      ...request,
+    };
+  });
+
+  return provider;
+};
+
+export const estimateCreationGas = async (
+  provider: ZeroDevProvider,
+  initCode?: string
+): Promise<bigint> => {
+  if (initCode == null || initCode === "0x") return BigInt(0);
+  const deployerAddress = initCode.substring(0, 42) as Hex;
+  const deployerCallData = ("0x" + initCode.substring(42)) as Hex;
+  return await provider.rpcClient.estimateGas({
+    account: ENTRYPOINT_ADDRESS,
+    to: deployerAddress,
+    data: deployerCallData,
+  });
+};
+
+/**
+ * should cover cost of putting calldata on-chain, and some overhead.
+ * actual overhead depends on the expected bundle size
+ */
+export const getPreVerificationGas = async (
+  userOp: Partial<UserOperationStruct>
+): Promise<number> => {
+  const p = await resolveProperties(userOp);
+  return calcPreVerificationGas(p);
+};
+
+export const eip1559GasPrice = async (provider: ZeroDevProvider) => {
+  const [fee, block] = await Promise.all([
+    provider.rpcClient.getMaxPriorityFeePerGas(),
+    provider.rpcClient.getBlock({ blockTag: "latest" }),
+  ]);
+
+  const tip = BigInt(fee);
+  const buffer = (tip / 100n) * 13n;
+  let maxPriorityFeePerGas = tip + buffer;
+  maxPriorityFeePerGas =
+    maxPriorityFeePerGas < provider.minPriorityFeePerBid
+      ? provider.minPriorityFeePerBid
+      : maxPriorityFeePerGas;
+  const maxFeePerGas = block.baseFeePerGas
+    ? BigInt(block.baseFeePerGas) * 2n + maxPriorityFeePerGas
+    : maxPriorityFeePerGas;
+
+  return { maxFeePerGas, maxPriorityFeePerGas };
+};
+interface FeeData {
+  maxFeePerGas: BigNumberish | null;
+  maxPriorityFeePerGas: BigNumberish | null;
+}
+
+export const getFeeData = async (
+  provider: ZeroDevProvider
+): Promise<FeeData> => {
+  const { block, gasPrice } = await resolveProperties({
+    block: provider.rpcClient.getBlock({ blockTag: "latest" }),
+    gasPrice: provider.rpcClient.getGasPrice().catch((error) => {
+      console.warn("Legacy: Failed to get gas price", error);
+      return null;
+    }),
+  });
+
+  let maxFeePerGas = null;
+  let maxPriorityFeePerGas = null;
+
+  if (block && block.baseFeePerGas != null) {
+    // Set the tip to the min of the tip for the last block and 1.5 gwei
+    const minimumTip = BigInt("1500000000");
+    maxPriorityFeePerGas = gasPrice ? gasPrice - block.baseFeePerGas : null;
+    if (
+      maxPriorityFeePerGas == null ||
+      maxPriorityFeePerGas - BigInt(0) ||
+      maxPriorityFeePerGas > minimumTip
+    ) {
+      maxPriorityFeePerGas = minimumTip;
+    }
+    maxPriorityFeePerGas =
+      maxPriorityFeePerGas < provider.minPriorityFeePerBid
+        ? provider.minPriorityFeePerBid
+        : maxPriorityFeePerGas;
+    maxFeePerGas =
+      block.baseFeePerGas * BigInt(2) + (maxPriorityFeePerGas ?? 0);
+  }
+
+  return { maxFeePerGas, maxPriorityFeePerGas };
+};

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

@@ -0,0 +1,66 @@
+import { type ConnectedSmartAccountProvider } from "@alchemy/aa-core";
+import type { ZeroDevProvider } from "../provider.js";
+import { Paymasters } from "../paymaster/index.js";
+import type { PaymasterConfig, PaymasterPolicy } from "../paymaster/types.js";
+
+export const withZeroDevPaymasterAndData = <Provider extends ZeroDevProvider>(
+  provider: Provider,
+  paymasterConfig: PaymasterConfig<PaymasterPolicy>
+): Provider => {
+  provider.withPaymasterMiddleware(
+    zeroDevPaymasterAndDataMiddleware(provider, paymasterConfig)
+  );
+
+  return provider;
+};
+
+export const zeroDevPaymasterAndDataMiddleware = <
+  Provider extends ZeroDevProvider,
+  P extends PaymasterPolicy
+>(
+  provider: Provider,
+  paymasterConfig: PaymasterConfig<P>
+): Parameters<
+  ConnectedSmartAccountProvider["withPaymasterMiddleware"]
+>["0"] => {
+  return {
+    dummyPaymasterDataMiddleware: async (struct) => {
+      struct.paymasterAndData = "0x";
+      return struct;
+    },
+    paymasterDataMiddleware: async (struct) => {
+      const preVerificationGas = BigInt("100000");
+      const verificationGasLimit = BigInt("1000000");
+      const callGasLimit = BigInt("55000");
+      const paymaster = new Paymasters[paymasterConfig.policy](
+        provider,
+        paymasterConfig
+      );
+      const paymasterResp = await paymaster.getPaymasterResponse(
+        {
+          ...struct,
+          preVerificationGas,
+          verificationGasLimit,
+          callGasLimit,
+        },
+        paymasterConfig.paymasterProvider
+      );
+      if (
+        paymasterConfig.onlySendSponsoredTransaction &&
+        (!paymasterResp || paymasterResp.paymasterAndData === "0x")
+      ) {
+        throw new Error("Transaction is not sponsored");
+      }
+      if (
+        paymasterResp === undefined ||
+        paymasterResp.paymasterAndData === "0x"
+      ) {
+        return struct;
+      }
+      return {
+        ...struct,
+        ...paymasterResp,
+      };
+    },
+  };
+};

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

@@ -0,0 +1,74 @@
+import type { 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";
+
+export async function getCustodialOwner(
+  identifier: string,
+  {
+    custodialFilePath,
+    privateKey,
+    publicKey,
+    keyId,
+    apiUrl = API_URL,
+  }: {
+    privateKey?: string;
+    publicKey?: string;
+    keyId?: string;
+    custodialFilePath?: string;
+    apiUrl?: string;
+  }
+): Promise<SmartAccountSigner | undefined> {
+  if (custodialFilePath) {
+    let fsModule;
+    try {
+      fsModule = require.resolve("fs") && require("fs");
+    } catch (error) {
+      console.log("FS module not available. Skipping FS operation...");
+      return;
+    }
+    const data = fsModule.readFileSync(custodialFilePath, "utf8");
+    const values = data.split("\n");
+    [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;
+  }
+  if (!privateKey || !publicKey || !keyId) {
+    throw new Error(
+      "Must provide custodialFilePath or privateKey, publicKey, and keyId."
+    );
+  }
+
+  const response = await axios.post(`${apiUrl}/wallets/${identifier}`, {
+    keyId,
+  });
+
+  const turnkeySigner = new TurnkeySigner({
+    apiPublicKey: publicKey,
+    apiPrivateKey: privateKey,
+    baseUrl: "https://coordinator-beta.turnkey.io",
+    organizationId: keyId,
+    privateKeyId: response.data.walletId,
+  });
+  return {
+    getAddress: async () => (await turnkeySigner.getAddress()) as `0x${string}`,
+    signMessage: async (msg: Uint8Array | string) =>
+      (await turnkeySigner.signMessage(msg)) as `0x${string}`,
+    signTypedData: async (params: SignTypedDataParams) =>
+      (await turnkeySigner.signTypedData(
+        params.domain,
+        params.types,
+        params.message
+      )) as Hex,
+  };
+}

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

@@ -0,0 +1,22 @@
+import type { SignTypedDataParams, SmartAccountSigner } from "@alchemy/aa-core";
+import { Web3Provider, type ExternalProvider } from "@ethersproject/providers";
+import { type TypedDataField } from "@ethersproject/abstract-signer";
+import type { Hex } from "viem";
+
+export function getRPCProviderOwner(web3Provider: any): SmartAccountSigner {
+  const provider = new Web3Provider(web3Provider as ExternalProvider);
+  const signer = provider.getSigner();
+
+  return {
+    getAddress: async () =>
+      Promise.resolve((await signer.getAddress()) as `0x${string}`),
+    signMessage: async (msg: Uint8Array | string) =>
+      (await signer.signMessage(msg)) as `0x${string}`,
+    signTypedData: async (params: SignTypedDataParams) =>
+      (await signer._signTypedData(
+        params.domain!,
+        params.types as unknown as Record<string, TypedDataField[]>,
+        params.message
+      )) as Hex,
+  };
+}

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

@@ -0,0 +1,2 @@
+export { getCustodialOwner } from "./getCustodialOwner.js";
+export { getRPCProviderOwner } from "./getRPCProviderOwner.js";

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

@@ -0,0 +1,98 @@
+import { getWebAuthnAttestation } from "@turnkey/http";
+import axios from "axios";
+import type { SignTypedDataParams, SmartAccountSigner } from "@alchemy/aa-core";
+import {
+  base64UrlEncode,
+  es256,
+  generateRandomBuffer,
+  getCredentials,
+  publicKey,
+  signMessage,
+  signTypedData,
+} from "./utils.js";
+import { API_URL } from "../../constants.js";
+
+export async function createPasskeyOwner({
+  name,
+  projectId,
+  fallback,
+  apiUrl = API_URL,
+}: {
+  name: string;
+  projectId: string;
+  fallback?: () => Promise<SmartAccountSigner | undefined>;
+  apiUrl?: string;
+}): Promise<SmartAccountSigner | undefined> {
+  //@ts-expect-error
+  if (typeof window !== "undefined") {
+    const challenge = generateRandomBuffer();
+    try {
+      const attestation = await getWebAuthnAttestation({
+        publicKey: {
+          rp: {
+            //@ts-expect-error
+            id: window.location.hostname,
+            //@ts-expect-error
+            name: window.location.hostname,
+          },
+          authenticatorSelection: {
+            residentKey: "required", // or 'preferred', 'discouraged'
+            userVerification: "required",
+          },
+          excludeCredentials: await getCredentials(projectId),
+          extensions: { credProps: true },
+          challenge,
+          pubKeyCredParams: [
+            {
+              type: publicKey,
+              alg: es256,
+            },
+          ],
+          user: {
+            id: Uint8Array.from(name, (c) => c.charCodeAt(0)),
+            name,
+            displayName: name,
+          },
+        },
+      });
+      const response = await axios.post(
+        `${apiUrl}/projects/${projectId}/wallets`,
+        {
+          challenge: base64UrlEncode(challenge),
+          name,
+          attestation,
+        }
+      );
+      const { id, walletId, address } = await response.data;
+      const owner: SmartAccountSigner = {
+        getAddress: async () => address,
+        signMessage: (msg) =>
+          signMessage(
+            msg,
+            id,
+            walletId,
+            projectId,
+            attestation.credentialId,
+            apiUrl
+          ),
+        signTypedData: (params: SignTypedDataParams) =>
+          signTypedData(
+            params,
+            id,
+            walletId,
+            projectId,
+            attestation.credentialId,
+            apiUrl
+          ),
+      };
+      return owner;
+    } catch (e) {
+      //@ts-expect-error
+      if (e instanceof DOMException && e.name === "InvalidStateError") {
+        if (fallback) return await fallback();
+      }
+      console.log(e);
+    }
+  }
+  return;
+}

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

@@ -0,0 +1,22 @@
+import type { SmartAccountSigner } from "@alchemy/aa-core";
+import { API_URL } from "../../constants.js";
+// import { getPasskeyOwner } from "./getPasskeyOwner.js";
+import { createPasskeyOwner } from "./createPasskeyOwner.js";
+import { getPasskeyOwner } from "./getPasskeyOwner.js";
+
+export async function getOrCreatePasskeyOwner({
+  name,
+  projectId,
+  apiUrl = API_URL,
+}: {
+  name: string;
+  projectId: string;
+  apiUrl?: string;
+}): Promise<SmartAccountSigner | undefined> {
+  return await createPasskeyOwner({
+    name,
+    projectId,
+    apiUrl,
+    fallback: () => getPasskeyOwner({ projectId, apiUrl }),
+  });
+}

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

@@ -0,0 +1,69 @@
+import { getWebAuthnAssertion } from "@turnkey/http/dist/webauthn";
+import axios from "axios";
+import type { SignTypedDataParams, SmartAccountSigner } from "@alchemy/aa-core";
+import {
+  base64UrlEncode,
+  generateRandomBuffer,
+  getCredentials,
+  signMessage,
+  signTypedData,
+} from "./utils.js";
+import { API_URL } from "../../constants.js";
+
+export async function getPasskeyOwner({
+  projectId,
+  apiUrl = API_URL,
+}: {
+  projectId: string;
+  apiUrl?: string;
+}): Promise<SmartAccountSigner | undefined> {
+  //@ts-expect-error
+  if (typeof window !== "undefined") {
+    const challenge = generateRandomBuffer();
+    try {
+      const assertion = JSON.parse(
+        await getWebAuthnAssertion(base64UrlEncode(challenge), {
+          publicKey: {
+            //@ts-expect-error
+            rpId: window.location.hostname,
+            userVerification: "required",
+            allowCredentials: await getCredentials(projectId),
+          },
+        })
+      );
+      const response = await axios.post(
+        `${apiUrl}/projects/${projectId}/wallets/${assertion.credentialId}`,
+        {
+          challenge: base64UrlEncode(challenge),
+          assertion,
+        }
+      );
+      const { id, walletId, address } = await response.data;
+      const owner: SmartAccountSigner = {
+        getAddress: async () => address,
+        signMessage: (msg) =>
+          signMessage(
+            msg,
+            id,
+            walletId,
+            projectId,
+            assertion.credentialId,
+            apiUrl
+          ),
+        signTypedData: (params: SignTypedDataParams) =>
+          signTypedData(
+            params,
+            id,
+            walletId,
+            projectId,
+            assertion.credentialId,
+            apiUrl
+          ),
+      };
+      return owner;
+    } catch (e) {
+      console.log(e);
+    }
+  }
+  return;
+}

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

@@ -0,0 +1,3 @@
+export { getPasskeyOwner } from "./getPasskeyOwner.js";
+export { createPasskeyOwner } from "./createPasskeyOwner.js";
+export { getOrCreatePasskeyOwner } from "./getOrCreatePasskeyOwner.js";

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

@@ -0,0 +1,18 @@
+export type ByteArray = Uint8Array;
+export type Hex = `0x${string}`;
+export type Hash = `0x${string}`;
+export type LogTopic = Hex | Hex[] | null;
+export type SignableMessage =
+  | string
+  | {
+      /** Raw data representation of the message. */
+      raw: Hex | ByteArray;
+    };
+export type Signature = {
+  // TODO(v2): Make `bigint`
+  r: Hex;
+  // TODO(v2): Make `bigint`
+  s: Hex;
+  // TODO(v2): `v` to `recovery`
+  v: bigint;
+};