Wallet provider setups

CIRCLE_API_KEY=YOUR_TEST_API_KEY:...:...
CIRCLE_ENTITY_SECRET=YOUR_64_CHAR_ENTITY_SECRET
CIRCLE_WALLET_SET_ID=         # filled in by the provisioning step on first run
CIRCLE_SCA_WALLET_ADDRESS=

import { AppKit } from "@circle-fin/app-kit";
import { createCircleWalletsAdapter } from "@circle-fin/adapter-circle-wallets";
import { initiateDeveloperControlledWalletsClient } from "@circle-fin/developer-controlled-wallets";

// One-time wallet provisioning. Run this script once with the IDs blank;
// copy the printed values into .env, then re-run for normal operation.
const circleClient = initiateDeveloperControlledWalletsClient({
  apiKey: process.env.CIRCLE_API_KEY!,
  entitySecret: process.env.CIRCLE_ENTITY_SECRET!,
});

if (!process.env.CIRCLE_WALLET_SET_ID) {
  const ws = await circleClient.createWalletSet({ name: "app-kit-wallets" });
  console.log("CIRCLE_WALLET_SET_ID=" + ws.data!.walletSet!.id);
  process.exit(0);
}

if (!process.env.CIRCLE_SCA_WALLET_ADDRESS) {
  const wallets = await circleClient.createWallets({
    walletSetId: process.env.CIRCLE_WALLET_SET_ID!,
    blockchains: ["ARC-TESTNET" as any],
    accountType: "SCA",
    count: 1,
  });
  console.log(
    "CIRCLE_SCA_WALLET_ADDRESS=" + wallets.data!.wallets![0]!.address,
  );
  process.exit(0);
}

// Same adapter as the EOA case — the wallet address determines whether this
// signs an EOA transaction or an SCA UserOperation.
const kit = new AppKit();
const adapter = createCircleWalletsAdapter({
  apiKey: process.env.CIRCLE_API_KEY!,
  entitySecret: process.env.CIRCLE_ENTITY_SECRET!,
});

CIRCLE_MODULAR_CLIENT_KEY=YOUR_TEST_CLIENT_KEY:...:...
CIRCLE_MODULAR_OWNER_KEY=0xYOUR_OWNER_PRIVATE_KEY

// The SDK reads `window.location.hostname` directly. Declaring `window` as
// undefined silences the throw in Node while keeping `typeof window === 'undefined'`.
(globalThis as any).window = undefined;

// Circle's API validates the `X-AppInfo` `uri` against your Allowed Domains.
// Rewrite outbound modular-sdk requests so `uri=localhost` matches.
const originalFetch = globalThis.fetch.bind(globalThis);
globalThis.fetch = (async (input: any, init: any = {}) => {
  const url = typeof input === "string" ? input : input?.url;
  if (
    typeof url === "string" &&
    url.startsWith("https://modular-sdk.circle.com/")
  ) {
    const headers = new Headers(init.headers ?? input?.headers);
    headers.set(
      "X-AppInfo",
      (
        headers.get("X-AppInfo") ?? "platform=web;version=1.0.13;uri=unknown"
      ).replace(/uri=[^;]*/, "uri=localhost"),
    );
    return originalFetch(input, { ...init, headers });
  }
  return originalFetch(input, init);
}) as typeof fetch;

import { AppKit } from "@circle-fin/app-kit";
import { ViemAdapter } from "@circle-fin/adapter-viem-v2";
import {
  toModularTransport,
  toCircleSmartAccount,
  toCircleModularWalletClient,
  getModularWalletAddress,
} from "@circle-fin/modular-wallets-core";
import { createPublicClient, createWalletClient, http } from "viem";
import { createBundlerClient } from "viem/account-abstraction";
import { privateKeyToAccount } from "viem/accounts";
import { arcTestnet } from "viem/chains";

const kit = new AppKit();
const owner = privateKeyToAccount(
  process.env.CIRCLE_MODULAR_OWNER_KEY as `0x${string}`,
);

// Build the modular transport, smart account, and bundler client for Arc Testnet.
const transport = toModularTransport(
  "https://modular-sdk.circle.com/v1/rpc/w3s/buidl/arcTestnet",
  process.env.CIRCLE_MODULAR_CLIENT_KEY!,
);
const rpClient = createPublicClient({ chain: arcTestnet, transport });
const circleClient = toCircleModularWalletClient({ client: rpClient });
const { address: scaAddress } = (await getModularWalletAddress({
  client: circleClient,
  owner,
})) as any;
const smartAccount = await toCircleSmartAccount({
  client: rpClient,
  owner,
  address: scaAddress,
});

const walletClient = createWalletClient({
  account: smartAccount,
  chain: arcTestnet,
  transport: http(),
});
const bundlerClient = createBundlerClient({
  account: smartAccount,
  chain: arcTestnet,
  transport,
});

// Public RPCs don't implement eth_signTypedData_v4 — route through the smart account.
(walletClient as any).signTypedData = async (params: any) =>
  smartAccount.signTypedData(params);

// The bundler only accepts eth_sendUserOperation — wrap sendTransaction calls.
(walletClient as any).sendTransaction = async (args: any) => {
  const gp: any = await rpClient.request({
    method: "circle_getUserOperationGasPrice" as any,
    params: [] as any,
  });
  const hash = await bundlerClient.sendUserOperation({
    calls: [{ to: args.to, value: args.value ?? 0n, data: args.data ?? "0x" }],
    maxPriorityFeePerGas: BigInt(gp.medium.maxPriorityFeePerGas),
    maxFeePerGas: BigInt(gp.medium.maxFeePerGas),
  });
  const { receipt } = await bundlerClient.waitForUserOperationReceipt({ hash });
  return receipt.transactionHash;
};

// The Viem adapter wraps walletClient so the App Kit SDK can use it across
// send, bridge, swap, and unified balance operations.
const supportedChains = (await kit.getSupportedChains()).filter(
  (c: any) => c.type === "evm",
);
const adapter = new ViemAdapter(
  {
    getPublicClient: ({ chain }) =>
      createPublicClient({ chain, transport: http() }),
    getWalletClient: () => walletClient as any,
  },
  {
    addressContext: "developer-controlled",
    supportedChains: supportedChains as any,
  },
);

PRIVY_APP_ID=YOUR_PRIVY_APP_ID
PRIVY_APP_SECRET=YOUR_PRIVY_APP_SECRET
PRIVY_WALLET_ID=          # filled in by the provisioning step on first run
PRIVY_WALLET_ADDRESS=

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

// Privy's stock signer assumes wallets linked to an end user. Server wallets
// don't have a user, so extend AbstractSigner and authenticate by walletId.
class PrivyServerSigner extends ethers.AbstractSigner {
  constructor(
    private walletId: string,
    private walletAddress: string,
    private privy: PrivyClient,
    provider: ethers.Provider,
  ) {
    super(provider);
  }

  // Required: return a new signer bound to the given provider.
  connect(provider: ethers.Provider) {
    return new PrivyServerSigner(
      this.walletId,
      this.walletAddress,
      this.privy,
      provider,
    );
  }

  async getAddress() {
    return this.walletAddress;
  }

  // Sign and return the raw transaction. ethers passes BigInts; Privy expects
  // hex strings, so coerce numeric fields before sending.
  async signTransaction(tx: any): Promise<string> {
    const toHex = (v: any) => (v != null ? ethers.toBeHex(v) : undefined);
    const { signedTransaction } =
      await this.privy.walletApi.ethereum.signTransaction({
        walletId: this.walletId,
        chainType: "ethereum" as any,
        transaction: {
          to: tx.to?.toString(),
          nonce: tx.nonce != null ? Number(tx.nonce) : undefined,
          chainId: tx.chainId != null ? Number(tx.chainId) : undefined,
          data: tx.data?.toString(),
          value: toHex(tx.value),
          type: tx.type ?? 2,
          gasLimit: toHex(tx.gasLimit),
          maxFeePerGas: toHex(tx.maxFeePerGas),
          maxPriorityFeePerGas: toHex(tx.maxPriorityFeePerGas),
        } as any,
      });
    return signedTransaction as string;
  }

  // Sign an arbitrary message (for example, SIWE).
  async signMessage(message: string | Uint8Array): Promise<string> {
    const { signature } = await this.privy.walletApi.ethereum.signMessage({
      walletId: this.walletId,
      chainType: "ethereum" as any,
      message: typeof message === "string" ? message : ethers.hexlify(message),
    } as any);
    return signature;
  }

  // Sign EIP-712 typed data. Privy JSON-serializes the payload, which can't
  // serialize BigInt, so recursively coerce BigInts to strings first.
  async signTypedData(domain: any, types: any, value: any): Promise<string> {
    const toJsonSafe = (v: any): any =>
      typeof v === "bigint"
        ? v.toString()
        : Array.isArray(v)
          ? v.map(toJsonSafe)
          : v && typeof v === "object"
            ? Object.fromEntries(
                Object.entries(v).map(([k, x]) => [k, toJsonSafe(x)]),
              )
            : v;
    const primaryType =
      Object.keys(types).find((k) => k !== "EIP712Domain") ?? "";
    const { signature } = await this.privy.walletApi.ethereum.signTypedData({
      walletId: this.walletId,
      typedData: {
        domain: toJsonSafe(domain),
        types,
        message: toJsonSafe(value),
        primaryType,
      },
    } as any);
    return signature;
  }
}

const privy = new PrivyClient(
  process.env.PRIVY_APP_ID!,
  process.env.PRIVY_APP_SECRET!,
);

// One-time wallet provisioning. Run this script once with PRIVY_WALLET_ID
// blank; copy the printed values into .env, then re-run for normal operation.
if (!process.env.PRIVY_WALLET_ID) {
  const w = await privy.walletApi.createWallet({ chainType: "ethereum" });
  console.log("PRIVY_WALLET_ID=" + w.id);
  console.log("PRIVY_WALLET_ADDRESS=" + w.address);
  process.exit(0);
}

// Resolve the Arc Testnet chain from the App Kit SDK's supported list. Swap
// in any other supported EVM chain by changing the .find() filter.
const kit = new AppKit();
const supportedChains = (await kit.getSupportedChains()).filter(
  (c: any) => c.type === "evm",
);
const arcTestnet = supportedChains.find((c: any) => c.chain === "Arc_Testnet")!;

const signer = new PrivyServerSigner(
  process.env.PRIVY_WALLET_ID!,
  process.env.PRIVY_WALLET_ADDRESS!,
  privy,
  new ethers.JsonRpcProvider(arcTestnet.rpcEndpoints[0]),
);

// The Ethers adapter wraps the signer so the App Kit SDK can use it across
// send, bridge, swap, and unified balance operations.
const adapter = new EthersAdapter(
  {
    getProvider: ({ chain }) =>
      new ethers.JsonRpcProvider(chain.rpcEndpoints[0]),
    signer,
  },
  {
    addressContext: "user-controlled",
    supportedChains: supportedChains as any,
  },
);

TURNKEY_API_PUBLIC_KEY=YOUR_PUBLIC_KEY
TURNKEY_API_PRIVATE_KEY=YOUR_PRIVATE_KEY
TURNKEY_ORG_ID=YOUR_ORG_UUID
TURNKEY_WALLET_ADDRESS=       # filled in by the provisioning step on first run

import { AppKit } from "@circle-fin/app-kit";
import { EthersAdapter } from "@circle-fin/adapter-ethers-v6";
import { Turnkey as TurnkeyServerSDK } from "@turnkey/sdk-server";
import { TurnkeySigner } from "@turnkey/ethers";
import { ethers } from "ethers";

const turnkey = new TurnkeyServerSDK({
  apiBaseUrl: "https://api.turnkey.com",
  apiPublicKey: process.env.TURNKEY_API_PUBLIC_KEY!,
  apiPrivateKey: process.env.TURNKEY_API_PRIVATE_KEY!,
  defaultOrganizationId: process.env.TURNKEY_ORG_ID!,
});

// One-time wallet provisioning. Run this script once with TURNKEY_WALLET_ADDRESS
// blank; copy the printed address into .env, then re-run for normal operation.
if (!process.env.TURNKEY_WALLET_ADDRESS) {
  const { walletId, addresses } = await turnkey.apiClient().createWallet({
    walletName: "AppKit",
    accounts: [
      {
        curve: "CURVE_SECP256K1",
        pathFormat: "PATH_FORMAT_BIP32",
        path: "m/44'/60'/0'/0/0",
        addressFormat: "ADDRESS_FORMAT_ETHEREUM",
      },
    ],
  });
  console.log("TURNKEY_WALLET_ADDRESS=" + addresses[0]);
  console.log("(walletId=" + walletId + ")");
  process.exit(0);
}

// Resolve the Arc Testnet chain from the App Kit SDK's supported list.
const kit = new AppKit();
const supportedChains = (await kit.getSupportedChains()).filter(
  (c: any) => c.type === "evm",
);
const arcTestnet = supportedChains.find((c: any) => c.chain === "Arc_Testnet")!;

const signer = new TurnkeySigner({
  client: turnkey.apiClient(),
  organizationId: process.env.TURNKEY_ORG_ID!,
  signWith: process.env.TURNKEY_WALLET_ADDRESS!,
}).connect(new ethers.JsonRpcProvider(arcTestnet.rpcEndpoints[0]));

// The Ethers adapter wraps the signer so the App Kit SDK can use it across
// send, bridge, swap, and unified balance operations.
const adapter = new EthersAdapter(
  {
    getProvider: ({ chain }) =>
      new ethers.JsonRpcProvider(chain.rpcEndpoints[0]),
    signer,
  },
  {
    addressContext: "user-controlled",
    supportedChains: supportedChains as any,
  },
);