Adapter setups

PRIVY_APP_ID=YOUR_PRIVY_APP_ID
PRIVY_APP_SECRET=YOUR_PRIVY_APP_SECRET
PRIVY_AUTHORIZATION_PRIVATE_KEY=YOUR_PRIVY_AUTHORIZATION_PRIVATE_KEY
PRIVY_WALLET_ID=YOUR_PRIVY_SERVER_WALLET_ID
PRIVY_WALLET_ADDRESS=YOUR_PRIVY_SERVER_WALLET_ADDRESS

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;
  }
}

import { AppKit } from "@circle-fin/app-kit";
import { EthersAdapter } from "@circle-fin/adapter-ethers-v6";
import { PrivyClient } from "@privy-io/server-auth";
import { ethers } from "ethers";
import { PrivyServerSigner } from "./PrivyServerSigner";

const privy = new PrivyClient(
  process.env.PRIVY_APP_ID!,
  process.env.PRIVY_APP_SECRET!,
  {
    walletApi: {
      authorizationPrivateKey: process.env.PRIVY_AUTHORIZATION_PRIVATE_KEY!,
    },
  },
);

const appKit = new AppKit();
const supportedChains = (await appKit.getSupportedChains()).filter(
  (chain) => chain.type === "evm",
);
const arcTestnet = supportedChains.find(
  (chain) => chain.chain === "Arc_Testnet",
);

if (!arcTestnet) {
  throw new Error("Arc Testnet is not supported");
}

const provider = new ethers.JsonRpcProvider(arcTestnet.rpcEndpoints[0]);

const signer = new PrivyServerSigner({
  walletId: process.env.PRIVY_WALLET_ID!,
  walletAddress: process.env.PRIVY_WALLET_ADDRESS!,
  privy,
  provider,
});

const adapter = new EthersAdapter(
  {
    signer,
    getProvider: ({ chain }) =>
      new ethers.JsonRpcProvider(chain.rpcEndpoints[0]),
  },
  {
    addressContext: "user-controlled",
    supportedChains,
  },
);

import { createEthersAdapterFromProvider } from "@circle-fin/adapter-ethers-v6";
import type { Eip1193Provider } from "ethers";

declare global {
  interface Window {
    ethereum?: Eip1193Provider;
  }
}

if (!window.ethereum) {
  throw new Error("No wallet provider found");
}

const adapter = await createEthersAdapterFromProvider({
  provider: window.ethereum,
});