@zerodev/sdk 4.0.0

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

@@ -0,0 +1,157 @@
+import { browserInit, TurnkeyApi } from "@turnkey/http";
+import axios from "axios";
+import { API_URL } from "../../constants.js";
+import type { Hex, Signature } from "./types.js";
+import { ethers } from "ethers";
+import type { SignTypedDataParams } from "@alchemy/aa-core";
+import { hashTypedData } from "viem";
+
+browserInit({
+  baseUrl: "https://coordinator-beta.turnkey.io",
+});
+
+export const publicKey = "public-key";
+
+export const es256 = -7;
+
+export const generateRandomBuffer = (): ArrayBuffer => {
+  const arr = new Uint8Array(32);
+  //@ts-expect-error
+  crypto.getRandomValues(arr);
+  return arr.buffer;
+};
+
+export const base64UrlEncode = (challenge: ArrayBuffer): string => {
+  return Buffer.from(challenge)
+    .toString("base64")
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=/g, "");
+};
+
+// VIEM
+// export function signatureToHex({ r, s, v }: Signature): Hex {
+//     return `0x${new secp256k1.Signature(
+//       hexToBigInt(r),
+//       hexToBigInt(s),
+//     ).toCompactHex()}${toHex(v).slice(2)}`
+// }
+
+//ETHERS
+export function signatureToHex({ r, s, v }: Signature): Hex {
+  return ethers.utils.joinSignature({
+    r: `0x${r}`,
+    s: `0x${s}`,
+    //@ts-expect-error
+    v: parseInt(v) + 27,
+  }) as Hex;
+}
+
+export const signMessage = async (
+  msg: string | Uint8Array,
+  id: string,
+  walletId: string,
+  projectId: string,
+  credentialId: string,
+  apiUrl = API_URL
+) => {
+  const signedRequest = await TurnkeyApi.signSignRawPayload(
+    {
+      body: {
+        type: "ACTIVITY_TYPE_SIGN_RAW_PAYLOAD",
+        organizationId: id,
+        parameters: {
+          privateKeyId: walletId,
+          payload: ethers.utils.hashMessage(msg),
+          encoding: "PAYLOAD_ENCODING_HEXADECIMAL",
+          hashFunction: "HASH_FUNCTION_NO_OP",
+        },
+        timestampMs: String(Date.now()),
+      },
+    },
+    {
+      publicKey: {
+        allowCredentials: [
+          {
+            id: base64URLStringToBuffer(credentialId),
+            type: publicKey,
+          },
+        ],
+      },
+    }
+  );
+  const proxyResponse = await axios.post(
+    `${apiUrl}/projects/${projectId}/wallets/proxy`,
+    {
+      signedRequest,
+    }
+  );
+  const { activity } = await proxyResponse.data;
+  if (activity.status === "ACTIVITY_STATUS_COMPLETED") {
+    let result = activity?.result?.signRawPayloadResult;
+
+    if (result) {
+      const assembled = signatureToHex(result);
+      if (assembled) {
+        return assembled;
+      }
+    }
+  }
+  return "0x";
+};
+
+export const signTypedData = async (
+  params: SignTypedDataParams,
+  id: string,
+  walletId: string,
+  projectId: string,
+  credentialId: string,
+  apiUrl = API_URL
+) => {
+  const hashToSign = hashTypedData(params);
+  return await signMessage(
+    hashToSign,
+    id,
+    walletId,
+    projectId,
+    credentialId,
+    apiUrl
+  );
+};
+
+export const getCredentials = async (projectId: string, apiUrl = API_URL) => {
+  const response = await axios.get(`${apiUrl}/projects/${projectId}/wallets`);
+  const credentials = response.data;
+  return credentials.map((credential: string) => ({
+    id: base64URLStringToBuffer(credential),
+    type: "public-key",
+  }));
+};
+
+// https://github.com/MasterKale/SimpleWebAuthn/blob/master/packages/browser/src/helpers/base64URLStringToBuffer.ts#L8
+export function base64URLStringToBuffer(base64URLString: string): ArrayBuffer {
+  // Convert from Base64URL to Base64
+  const base64 = base64URLString.replace(/-/g, "+").replace(/_/g, "/");
+  /**
+   * Pad with '=' until it's a multiple of four
+   * (4 - (85 % 4 = 1) = 3) % 4 = 3 padding
+   * (4 - (86 % 4 = 2) = 2) % 4 = 2 padding
+   * (4 - (87 % 4 = 3) = 1) % 4 = 1 padding
+   * (4 - (88 % 4 = 0) = 4) % 4 = 0 padding
+   */
+  const padLength = (4 - (base64.length % 4)) % 4;
+  const padded = base64.padEnd(base64.length + padLength, "=");
+
+  // Convert to a binary string
+  const binary = atob(padded);
+
+  // Convert binary string to buffer
+  const buffer = new ArrayBuffer(binary.length);
+  const bytes = new Uint8Array(buffer);
+
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+
+  return buffer;
+}

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

@@ -0,0 +1,76 @@
+import {
+  deepHexlify,
+  type BytesLike,
+  type PromiseOrValue,
+  type UserOperationStruct,
+  resolveProperties,
+} from "@alchemy/aa-core";
+import axios from "axios";
+import { ENTRYPOINT_ADDRESS, PAYMASTER_URL } from "../constants.js";
+import type { ZeroDevProvider } from "../provider.js";
+import { hexifyUserOp } from "../utils/ERC4337-utils.js";
+import type { PaymasterAndBundlerProviders } from "./types.js";
+import { getChainId } from "../api/index.js";
+
+export abstract class Paymaster {
+  constructor(protected provider: ZeroDevProvider) {}
+  abstract getPaymasterResponse(
+    struct: UserOperationStruct,
+    paymasterProvider?: PaymasterAndBundlerProviders
+  ): Promise<UserOperationStruct>;
+  protected async signUserOp({
+    userOp,
+    callData,
+    gasTokenAddress,
+    erc20UserOp,
+    erc20CallData,
+    paymasterProvider,
+  }: {
+    userOp: UserOperationStruct;
+    callData?: PromiseOrValue<BytesLike>;
+    gasTokenAddress?: string;
+    erc20UserOp?: Partial<UserOperationStruct>;
+    erc20CallData?: PromiseOrValue<BytesLike>;
+    paymasterProvider?: PaymasterAndBundlerProviders;
+  }): Promise<any> {
+    try {
+      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,
+        }).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;
+    }
+  }
+}

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

@@ -0,0 +1,9 @@
+import { TokenPaymaster } from "./token-paymaster.js";
+import type { PaymasterMap } from "./types.js";
+import { VerifyingPaymaster } from "./verifying-paymaster.js";
+import type { ZeroDevProvider } from "../provider.js";
+
+export const Paymasters: PaymasterMap<ZeroDevProvider> = {
+  VERIFYING_PAYMASTER: VerifyingPaymaster,
+  TOKEN_PAYMASTER: TokenPaymaster,
+};

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

@@ -0,0 +1,209 @@
+import {
+  type PromiseOrValue,
+  type BytesLike,
+  type UserOperationCallData,
+  type UserOperationStruct,
+} from "@alchemy/aa-core";
+import axios from "axios";
+import { type Hex, toHex, decodeFunctionData, encodeFunctionData } 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,
+} from "../constants.js";
+import {
+  AccountNotConnected,
+  IncorrectCallDataForTokenPaymaster,
+} from "../errors.js";
+import type { ZeroDevProvider } from "../provider.js";
+import {
+  getGasTokenAddress,
+  type UserOperationCallDataWithDelegate,
+} from "../utils.js";
+import { Paymaster } from "./base.js";
+import {
+  type PaymasterAndBundlerProviders,
+  type PaymasterConfig,
+} from "./types.js";
+import { getChainId } from "../api/index.js";
+
+export class TokenPaymaster extends Paymaster {
+  constructor(
+    provider: ZeroDevProvider,
+    protected paymasterConfig: PaymasterConfig<"TOKEN_PAYMASTER">
+  ) {
+    super(provider);
+  }
+  async getPaymasterAddress(): Promise<Hex | undefined> {
+    const chainId = await getChainId(this.provider.getProjectId());
+
+    try {
+      const { data: paymasterResp } = await axios.post(
+        `${PAYMASTER_URL}/getPaymasterAddress`,
+        {
+          chainId,
+          entryPointAddress: ENTRYPOINT_ADDRESS,
+        },
+        { headers: { "Content-Type": "application/json" } }
+      );
+      return paymasterResp as Hex;
+    } catch (e) {
+      console.log(e);
+      return undefined;
+    }
+  }
+  async decodeMainCallFromCallData(
+    kernelAddress: PromiseOrValue<string>,
+    callData: PromiseOrValue<BytesLike>
+  ): Promise<UserOperationCallDataWithDelegate | undefined> {
+    let data: Hex = "0x";
+    if (callData instanceof Promise) {
+      const _data = await callData;
+      if (_data instanceof Uint8Array) {
+        data = toHex(_data);
+      } else {
+        data = _data as Hex;
+      }
+    } else if (callData instanceof Uint8Array) {
+      data = toHex(callData);
+    } else {
+      data = callData as Hex;
+    }
+
+    try {
+      const { functionName, args } = decodeFunctionData({
+        abi: KernelAccountAbi,
+        data: data,
+      });
+      if (functionName === "execute") {
+        const [target, value, data] = args;
+        let msFuntionName;
+        try {
+          ({ functionName: msFuntionName } = decodeFunctionData({
+            abi: MultiSendAbi,
+            data,
+          }));
+        } catch (error) {}
+        let mainCall:
+          | UserOperationCallData
+          | UserOperationCallDataWithDelegate = {
+          target,
+          value: value ?? 0n,
+          data,
+        };
+        if (msFuntionName === "multiSend") {
+          mainCall = {
+            ...mainCall,
+            target: MULTISEND_ADDR,
+            delegateCall: true,
+            data,
+          };
+        }
+        return mainCall;
+      }
+    } catch (error) {
+      return {
+        target: (kernelAddress instanceof Promise
+          ? await kernelAddress
+          : kernelAddress) as Hex,
+        data,
+        value: 0n,
+        delegateCall: true,
+      };
+    }
+    return;
+  }
+
+  async getERC20UserOp(
+    struct: UserOperationStruct,
+    mainCall: UserOperationCallDataWithDelegate,
+    gasTokenAddress: Hex,
+    paymasterAddress: Hex
+  ): Promise<UserOperationStruct | undefined> {
+    try {
+      const approveData: UserOperationCallData = {
+        target: gasTokenAddress,
+        value: BigInt(0),
+        data: encodeFunctionData({
+          abi: ERC20Abi,
+          functionName: "approve",
+          args: [paymasterAddress, ERC20_APPROVAL_AMOUNT[gasTokenAddress]],
+        }),
+      };
+      if (!this.provider.account) {
+        throw AccountNotConnected;
+      }
+      const erc20CallData = await this.provider.account.encodeBatchExecute([
+        approveData,
+        mainCall,
+      ]);
+      return {
+        ...struct,
+        callData: erc20CallData,
+        callGasLimit: await this.provider.rpcClient.estimateGas({
+          account: ENTRYPOINT_ADDRESS,
+          to: await this.provider.getAddress(),
+          data: erc20CallData,
+        }),
+      };
+    } catch (error) {
+      return;
+    }
+  }
+
+  async getPaymasterResponse(
+    struct: UserOperationStruct,
+    paymasterProvider?: PaymasterAndBundlerProviders
+  ): Promise<UserOperationStruct> {
+    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
+      );
+      let paymasterAddress = await this.getPaymasterAddress();
+      if (gasTokenAddress !== undefined && paymasterAddress !== undefined) {
+        const erc20UserOp = await this.getERC20UserOp(
+          struct,
+          mainCall,
+          gasTokenAddress,
+          paymasterAddress
+        );
+        if (!erc20UserOp) {
+          return struct;
+        }
+        const paymasterResp = await this.signUserOp({
+          userOp: struct,
+          callData: struct.callData,
+          gasTokenAddress,
+          erc20UserOp,
+          erc20CallData: erc20UserOp.callData,
+          paymasterProvider,
+        });
+        if (paymasterResp) {
+          return {
+            ...struct,
+            ...paymasterResp,
+          };
+        }
+      }
+    } catch (error) {
+      return struct;
+    }
+    return struct;
+  }
+}

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

@@ -0,0 +1,36 @@
+import type { Hex } from "viem";
+import type { Paymaster } from "./base.js";
+import type { ZeroDevProvider } from "../provider.js";
+
+export type PaymasterAndBundlerProviders = "ALCHEMY" | "STACKUP" | "PIMLICO";
+
+export type SupportedGasToken = "USDC" | "PEPE" | "TEST_ERC20";
+
+export type PaymasterPolicy = "VERIFYING_PAYMASTER" | "TOKEN_PAYMASTER";
+
+interface PaymasterConfigOptions {
+  VERIFYING_PAYMASTER: {};
+  TOKEN_PAYMASTER: { gasToken: SupportedGasToken };
+}
+
+export type PaymasterConfig<T extends PaymasterPolicy> = {
+  policy: T;
+  paymasterProvider?: PaymasterAndBundlerProviders;
+  onlySendSponsoredTransaction?: boolean;
+} & PaymasterConfigOptions[T];
+export interface IGasTokenAddresses {
+  [key: string]: {
+    [chainId: number]: Hex;
+  };
+}
+
+export interface IPaymaster<
+  Provider extends ZeroDevProvider,
+  P extends PaymasterPolicy
+> {
+  new (provider: Provider, paymasterConfig: PaymasterConfig<P>): Paymaster;
+}
+
+export type PaymasterMap<Provider extends ZeroDevProvider> = {
+  [P in PaymasterPolicy]: IPaymaster<Provider, P>;
+};

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

@@ -0,0 +1,38 @@
+import {
+  type UserOperationStruct,
+  deepHexlify,
+  resolveProperties,
+} from "@alchemy/aa-core";
+import { Paymaster } from "./base.js";
+import type { ZeroDevProvider } from "../provider.js";
+import type { PaymasterAndBundlerProviders, PaymasterConfig } from "./types.js";
+
+export class VerifyingPaymaster extends Paymaster {
+  constructor(
+    provider: ZeroDevProvider,
+    _: PaymasterConfig<"VERIFYING_PAYMASTER">
+  ) {
+    super(provider);
+  }
+  async getPaymasterResponse(
+    struct: UserOperationStruct,
+    paymasterProvider?: PaymasterAndBundlerProviders
+  ): Promise<UserOperationStruct> {
+    try {
+      const hexifiedUserOp = deepHexlify(await resolveProperties(struct));
+      const paymasterResp = await this.signUserOp({
+        userOp: hexifiedUserOp,
+        paymasterProvider,
+      });
+      if (paymasterResp) {
+        return {
+          ...struct,
+          ...paymasterResp,
+        };
+      }
+    } catch (error) {
+      return struct;
+    }
+    return struct;
+  }
+}