@zerodev/sdk 4.0.4 → 4.0.6

package/src/kernel-zerodev/ethers-provider/account-signer.ts

@@ -0,0 +1,165 @@
+import {
+  BaseSmartContractAccount,
+  resolveProperties,
+  type AccountMiddlewareFn,
+  type FeeDataMiddleware,
+  type GasEstimatorMiddleware,
+  type PaymasterAndDataMiddleware,
+  type PublicErc4337Client,
+  type SignTypedDataParams,
+} from "@alchemy/aa-core";
+import {
+  Signer,
+  type TypedDataSigner,
+  type TypedDataDomain,
+  type TypedDataField,
+} from "@ethersproject/abstract-signer";
+import { hexlify } from "@ethersproject/bytes";
+import { _TypedDataEncoder } from "@ethersproject/hash";
+import type { Deferrable } from "@ethersproject/properties";
+import {
+  type TransactionRequest,
+  type TransactionResponse,
+} from "@ethersproject/providers";
+import { ZeroDevEthersProvider } from "./ethers-provider.js";
+import type { SupportedValidators } from "../validator/types.js";
+
+const hexlifyOptional = (value: any): `0x${string}` | undefined => {
+  if (value == null) {
+    return undefined;
+  }
+
+  return hexlify(value) as `0x${string}`;
+};
+
+export class ZeroDevAccountSigner<V extends SupportedValidators>
+  extends Signer
+  implements TypedDataSigner
+{
+  private account?: BaseSmartContractAccount;
+
+  sendUserOperation;
+  waitForUserOperationTransaction;
+
+  constructor(readonly provider: ZeroDevEthersProvider<V>) {
+    super();
+    this.account = this.provider.accountProvider.account;
+
+    this.sendUserOperation =
+      this.provider.accountProvider.sendUserOperation.bind(
+        this.provider.accountProvider
+      );
+    this.waitForUserOperationTransaction =
+      this.provider.accountProvider.waitForUserOperationTransaction.bind(
+        this.provider.accountProvider
+      );
+  }
+
+  getAddress(): Promise<string> {
+    if (!this.account) {
+      throw new Error(
+        "connect the signer to a provider that has a connected account"
+      );
+    }
+
+    return this.account.getAddress();
+  }
+
+  signMessage(message: string | Uint8Array): Promise<string> {
+    if (!this.account) {
+      throw new Error(
+        "connect the signer to a provider that has a connected account"
+      );
+    }
+
+    return this.account.signMessage(message);
+  }
+
+  signTypedData(params: SignTypedDataParams): Promise<string> {
+    if (!this.account) {
+      throw new Error(
+        "connect the signer to a provider that has a connected account"
+      );
+    }
+    if (params.types) {
+      delete params.types["EIP712Domain"];
+    }
+
+    return this.account.signTypedData(params);
+  }
+
+  _signTypedData(
+    domain: TypedDataDomain,
+    types: Record<string, Array<TypedDataField>>,
+    value: Record<string, any>
+  ): Promise<string> {
+    if (!this.account) {
+      throw new Error(
+        "connect the signer to a provider that has a connected account"
+      );
+    }
+    const params = _TypedDataEncoder.getPayload(
+      domain,
+      types,
+      value
+    ) as SignTypedDataParams;
+    if (params.types) {
+      delete params.types["EIP712Domain"];
+    }
+
+    return this.signTypedData(params);
+  }
+
+  withPaymasterMiddleware = (overrides: {
+    dummyPaymasterDataMiddleware?: PaymasterAndDataMiddleware;
+    paymasterDataMiddleware?: PaymasterAndDataMiddleware;
+  }): this => {
+    this.provider.withPaymasterMiddleware(overrides);
+    return this;
+  };
+
+  withGasEstimator = (override: GasEstimatorMiddleware): this => {
+    this.provider.withGasEstimator(override);
+    return this;
+  };
+
+  withFeeDataGetter = (override: FeeDataMiddleware): this => {
+    this.provider.withFeeDataGetter(override);
+    return this;
+  };
+
+  withCustomMiddleware = (override: AccountMiddlewareFn): this => {
+    this.provider.withCustomMiddleware(override);
+    return this;
+  };
+
+  async sendTransaction(
+    transaction: Deferrable<TransactionRequest>
+  ): Promise<TransactionResponse> {
+    const resolved = await resolveProperties(transaction);
+    const txHash = await this.provider.accountProvider.sendTransaction({
+      // TODO: need to support gas fields as well
+      from: (await this.getAddress()) as `0x${string}`,
+      to: resolved.to as `0x${string}` | undefined,
+      data: hexlifyOptional(resolved.data),
+    });
+
+    return this.provider.getTransaction(txHash);
+  }
+
+  signTransaction(
+    _transaction: Deferrable<TransactionRequest>
+  ): Promise<string> {
+    throw new Error(
+      "Transaction signing is not supported, use sendUserOperation instead"
+    );
+  }
+
+  getPublicErc4337Client(): PublicErc4337Client {
+    return this.provider.getPublicErc4337Client();
+  }
+
+  connect(provider: ZeroDevEthersProvider<V>): ZeroDevAccountSigner<V> {
+    return new ZeroDevAccountSigner(provider);
+  }
+}

package/src/kernel-zerodev/ethers-provider/ethers-provider.ts

@@ -11,7 +11,7 @@ import {
   type PaymasterAndDataMiddleware,
   type PublicErc4337Client,
 } from "@alchemy/aa-core";
-import { AccountSigner } from "@alchemy/aa-ethers";
+import { ZeroDevAccountSigner } from "./account-signer.js";
 import { JsonRpcProvider } from "@ethersproject/providers";
 import type { SupportedValidators } from "../validator/types.js";
 import type { ValidatorProviderParamsMap } from "../validator-provider/types.js";
@@ -73,20 +73,20 @@ export class ZeroDevEthersProvider<
    * Connects the Provider to an Account and returns a Signer
    *
    * @param fn - a function that takes the account provider's rpcClient and returns a BaseSmartContractAccount
-   * @returns an {@link AccountSigner} that can be used to sign and send user operations
+   * @returns an {@link ZeroDevAccountSigner} that can be used to sign and send user operations
    */
   connectToAccount(
     fn: (rpcClient: PublicErc4337Client) => BaseSmartContractAccount
-  ): AccountSigner {
+  ): ZeroDevAccountSigner<V> {
     defineReadOnly(this, "accountProvider", this.accountProvider.connect(fn));
     return this.getAccountSigner();
   }
 
   /**
-   * @returns an {@link AccountSigner} using this as the underlying provider
+   * @returns an {@link ZeroDevAccountSigner} using this as the underlying provider
    */
-  getAccountSigner(): AccountSigner {
-    return new AccountSigner(this);
+  getAccountSigner(): ZeroDevAccountSigner<V> {
+    return new ZeroDevAccountSigner(this);
   }
 
   withPaymasterMiddleware = (overrides: {

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

@@ -1,4 +1,5 @@
 import {
+  type SignTypedDataParams,
   type SmartAccountSigner,
   type UserOperationRequest,
 } from "@alchemy/aa-core";
@@ -91,6 +92,8 @@ export abstract class KernelBaseValidator {
 
   abstract signMessage(message: Uint8Array | string | Hex): Promise<Hex>;
 
+  abstract signTypedData(params: SignTypedDataParams): Promise<Hex>;
+
   abstract signUserOp(userOp: UserOperationRequest): Promise<Hex>;
 
   abstract signer(): Promise<SmartAccountSigner>;
@@ -160,7 +163,7 @@ export abstract class KernelBaseValidator {
     }
     const sender = kernel;
     const signer = await this.signer();
-    const ownerSig = await (signer as any).signTypedData({
+    const ownerSig = await signer.signTypedData({
       domain: {
         name: "Kernel",
         version: "0.2.1",

package/src/kernel-zerodev/validator/ecdsa-validator.ts

@@ -5,6 +5,7 @@ import {
   type Hex,
   type SmartAccountSigner,
   type UserOperationRequest,
+  type SignTypedDataParams,
 } from "@alchemy/aa-core";
 import { KernelBaseValidator, type KernelBaseValidatorParams } from "./base.js";
 import { encodeFunctionData, toBytes } from "viem";
@@ -12,6 +13,7 @@ import { ECDSAValidatorAbi } from "../abis/ESCDAValidatorAbi.js";
 import { getChainId } from "../api/index.js";
 import { DUMMY_ECDSA_SIG } from "../constants.js";
 import { KernelAccountAbi } from "../abis/KernelAccountAbi.js";
+import { fixSignedData } from "../utils.js";
 
 export interface ECDSAValidatorParams extends KernelBaseValidatorParams {
   owner: SmartAccountSigner;
@@ -99,6 +101,10 @@ export class ECDSAValidator extends KernelBaseValidator {
     return await this.owner.signMessage(message);
   }
 
+  async signTypedData(params: SignTypedDataParams): Promise<Hex> {
+    return fixSignedData(await this.owner.signTypedData(params));
+  }
+
   async signUserOp(userOp: UserOperationRequest): Promise<Hex> {
     if (!this.chain) {
       throw new Error("Validator uninitialized");

package/src/kernel-zerodev/validator/erc165-session-key-validator.ts

@@ -4,12 +4,14 @@ import {
   type Hex,
   type SmartAccountSigner,
   type UserOperationRequest,
+  type SignTypedDataParams,
 } from "@alchemy/aa-core";
 import { KernelBaseValidator, type KernelBaseValidatorParams } from "./base.js";
 import { encodeFunctionData, toBytes, concat, pad, toHex } from "viem";
 import { ERC165SessionKeyValidatorAbi } from "../abis/ERC165SessionKeyValidatorAbi.js";
 import { DUMMY_ECDSA_SIG } from "../constants.js";
 import { KernelAccountAbi } from "../abis/KernelAccountAbi.js";
+import { fixSignedData } from "../utils.js";
 
 export interface ERC165SessionKeyValidatorParams
   extends KernelBaseValidatorParams {
@@ -109,6 +111,10 @@ export class ERC165SessionKeyValidator extends KernelBaseValidator {
     return await this.sessionKey.signMessage(message);
   }
 
+  async signTypedData(params: SignTypedDataParams): Promise<Hex> {
+    return fixSignedData(await this.sessionKey.signTypedData(params));
+  }
+
   async signUserOp(userOp: UserOperationRequest): Promise<Hex> {
     if (!this.chain) {
       throw new Error("Validator uninitialized");

package/src/kernel-zerodev/validator/kill-switch-validator.ts

@@ -5,6 +5,7 @@ import {
   type Hex,
   type SmartAccountSigner,
   type UserOperationRequest,
+  type SignTypedDataParams,
 } from "@alchemy/aa-core";
 import { KernelBaseValidator, type KernelBaseValidatorParams } from "./base.js";
 import {
@@ -21,6 +22,7 @@ import { KillSwitchValidatorAbi } from "../abis/KillSwitchValidatorAbi.js";
 import { getChainId } from "../api/index.js";
 import { DUMMY_ECDSA_SIG } from "../constants.js";
 import { KernelAccountAbi } from "../abis/KernelAccountAbi.js";
+import { fixSignedData } from "../utils.js";
 
 export interface KillSwitchValidatorParams extends KernelBaseValidatorParams {
   guardian: SmartAccountSigner;
@@ -116,6 +118,10 @@ export class KillSwitchValidator extends KernelBaseValidator {
     return await this.guardian.signMessage(message);
   }
 
+  async signTypedData(params: SignTypedDataParams): Promise<Hex> {
+    return fixSignedData(await this.guardian.signTypedData(params));
+  }
+
   async signUserOp(userOp: UserOperationRequest): Promise<Hex> {
     const pausedUntil = this.getPausedUntil();
     if (!this.chain) {