Adapter setups

import { PrivyClient, type Hex, type Quantity } from "@privy-io/server-auth";
import { ethers } from "ethers";

interface PrivyServerSignerOptions {
  walletId: string;
  walletAddress: string;
  privy: PrivyClient;
  provider: ethers.Provider;
}

type JsonSafe =
  | string
  | number
  | boolean
  | null
  | JsonSafe[]
  | { [key: string]: JsonSafe };

type PrivySignTransactionRequest = Parameters<
  PrivyClient["walletApi"]["ethereum"]["signTransaction"]
>[0];

type PrivySignMessageRequest = Parameters<
  PrivyClient["walletApi"]["ethereum"]["signMessage"]
>[0];

type PrivySignTypedDataRequest = Parameters<
  PrivyClient["walletApi"]["ethereum"]["signTypedData"]
>[0];

export class PrivyServerSigner extends ethers.AbstractSigner {
  private walletId: string;
  private walletAddress: string;
  private privy: PrivyClient;

  constructor(options: PrivyServerSignerOptions) {
    super(options.provider);
    this.walletId = options.walletId;
    this.walletAddress = options.walletAddress;
    this.privy = options.privy;
  }

  connect(provider: ethers.Provider): PrivyServerSigner {
    return new PrivyServerSigner({
      walletId: this.walletId,
      walletAddress: this.walletAddress,
      privy: this.privy,
      provider,
    });
  }

  async getAddress(): Promise<string> {
    return this.walletAddress;
  }

  async signTransaction(tx: ethers.TransactionRequest): Promise<string> {
    const toQuantity = (
      value: ethers.BigNumberish | null | undefined,
    ): Quantity | undefined =>
      value != null ? (ethers.toBeHex(value) as Hex) : undefined;

    const toHex = (value: unknown): Hex | undefined =>
      value != null ? (value.toString() as Hex) : undefined;

    const request: PrivySignTransactionRequest = {
      walletId: this.walletId,
      chainType: "ethereum",
      transaction: {
        to: toHex(tx.to),
        nonce: tx.nonce != null ? Number(tx.nonce) : undefined,
        chainId: tx.chainId != null ? Number(tx.chainId) : undefined,
        data: toHex(tx.data),
        value: toQuantity(tx.value),
        type: (tx.type ?? 2) as 0 | 1 | 2,
        gasLimit: toQuantity(tx.gasLimit),
        maxFeePerGas: toQuantity(tx.maxFeePerGas),
        maxPriorityFeePerGas: toQuantity(tx.maxPriorityFeePerGas),
      },
    };

    const { signedTransaction } =
      await this.privy.walletApi.ethereum.signTransaction(request);

    return signedTransaction;
  }

  async signMessage(message: string | Uint8Array): Promise<string> {
    const request: PrivySignMessageRequest = {
      walletId: this.walletId,
      chainType: "ethereum",
      message: typeof message === "string" ? message : ethers.hexlify(message),
    };

    const { signature } =
      await this.privy.walletApi.ethereum.signMessage(request);

    return signature;
  }

  async signTypedData(
    domain: ethers.TypedDataDomain,
    types: Record<string, ethers.TypedDataField[]>,
    value: Record<string, unknown>,
  ): Promise<string> {
    const toJsonSafe = (input: unknown): JsonSafe => {
      if (typeof input === "bigint") {
        return input.toString();
      }
      if (Array.isArray(input)) {
        return input.map(toJsonSafe);
      }
      if (input && typeof input === "object") {
        return Object.fromEntries(
          Object.entries(input).map(([key, nestedValue]) => [
            key,
            toJsonSafe(nestedValue),
          ]),
        );
      }
      return input as JsonSafe;
    };

    const primaryType =
      Object.keys(types).find((key) => key !== "EIP712Domain") ?? "";

    const jsonSafeDomain = toJsonSafe(domain) as Record<string, unknown>;
    const jsonSafeMessage = toJsonSafe(value) as Record<string, unknown>;

    const request: PrivySignTypedDataRequest = {
      walletId: this.walletId,
      typedData: {
        domain: jsonSafeDomain,
        types,
        message: jsonSafeMessage,
        primaryType,
      },
    };

    const { signature } =
      await this.privy.walletApi.ethereum.signTypedData(request);

    return signature;
  }
}