Alchemy Smart Wallets

# Magic Server Wallet credentials
SERVER_WALLET_SECRET_KEY=sk_live_XXXXXXXXXXXX
NEXT_PUBLIC_OIDC_PROVIDER_ID=your-oidc-provider-id

# Alchemy
ALCHEMY_API_KEY=your-alchemy-api-key
ALCHEMY_GAS_POLICY_ID=your-gas-policy-id  # optional, enables gas sponsorship

import { createSmartWalletClient } from "@account-kit/wallet-client";
import type { SmartAccountSigner } from "@aa-sdk/core";
import { alchemy, baseSepolia } from "@account-kit/infra";
import { NextResponse } from "next/server";
import { getServerSession } from "next-auth";
import { authOptions } from "@/app/api/auth/[...nextauth]/route";
import { hashMessage, hashTypedData, serializeSignature } from "viem";
import type { Address, Hex, SignedAuthorization } from "viem";

const TEE_BASE = "https://tee.express.magiclabs.com";

async function teeRequest<T>(path: string, jwt: string, body: object): Promise<T> {
  const res = await fetch(`${TEE_BASE}${path}`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${jwt}`,
      "X-Magic-Secret-Key": process.env.SERVER_WALLET_SECRET_KEY!,
      "X-OIDC-Provider-ID": process.env.NEXT_PUBLIC_OIDC_PROVIDER_ID!,
      "X-Magic-Chain": "ETH",
    },
    body: JSON.stringify(body),
  });
  if (!res.ok) throw new Error(`TEE error: ${res.status}`);
  return res.json();
}

export async function POST(req: Request) {
  const session = await getServerSession(authOptions);
  if (!session?.idToken) {
    return NextResponse.json({ error: "Authentication required" }, { status: 401 });
  }
  const jwt = session.idToken;
  const body = await req.json().catch(() => ({}));
  const mode = body.mode === "batch" ? "batch" : "single";

  // 1. Fetch EOA
  const { public_address: eoaAddress } = await teeRequest<{ public_address: string }>(
    "/v1/wallet", jwt, { chain: "ETH" }
  );

  // 2. Build signer
  const decToHex = (dec: string): Hex =>
    `0x${BigInt(dec).toString(16).padStart(64, "0")}` as Hex;

  const signRawHash = async (hash: Hex): Promise<Hex> => {
    const res = await teeRequest<{ r: string; s: string; v: number }>(
      "/v1/wallet/sign/data", jwt, { raw_data_hash: hash, chain: "ETH" }
    );
    const yParity = Number(res.v) >= 27 ? Number(res.v) - 27 : Number(res.v);
    return serializeSignature({ r: decToHex(res.r), s: decToHex(res.s), yParity });
  };

  const signer = {
    signerType: "magic-tee",
    inner: {},
    getAddress: async (): Promise<Address> => eoaAddress as Address,
    signMessage: async (message: any) => signRawHash(hashMessage(message)),
    signTypedData: async (params: any) => signRawHash(hashTypedData(params)),
    signAuthorization: async (unsignedAuth: any): Promise<SignedAuthorization<number>> => {
      const res = await teeRequest<{ r: string; s: string; y_parity: number }>(
        "/v1/wallet/sign/eip7702", jwt, {
          chain_id: unsignedAuth.chainId,
          address: unsignedAuth.address,
          nonce: unsignedAuth.nonce,
          chain: "ETH",
        }
      );
      return {
        address: unsignedAuth.address,
        chainId: unsignedAuth.chainId,
        nonce: unsignedAuth.nonce,
        r: decToHex(res.r),
        s: decToHex(res.s),
        yParity: res.y_parity,
      } as SignedAuthorization<number>;
    },
  };

  // 3. Create client
  const client = createSmartWalletClient({
    transport: alchemy({ apiKey: process.env.ALCHEMY_API_KEY! }),
    chain: baseSepolia,
    signer: signer as unknown as SmartAccountSigner,
    ...(process.env.ALCHEMY_GAS_POLICY_ID
      ? { policyId: process.env.ALCHEMY_GAS_POLICY_ID }
      : {}),
  });

  // 4. Send calls
  const BURN = "0x000000000000000000000000000000000000dEaD" as Address;
  const ZERO = "0x0000000000000000000000000000000000000000" as Address;
  const calls =
    mode === "batch"
      ? [
          { to: BURN, value: "0x0" as Hex, data: "0x" as Hex },
          { to: ZERO, value: "0x0" as Hex, data: "0x" as Hex },
        ]
      : [{ to: BURN, value: "0x0" as Hex, data: "0x" as Hex }];

  const result = await client.sendCalls({
    from: eoaAddress as Address,
    calls,
    capabilities: { eip7702Auth: true },
  });

  const status = await client.waitForCallsStatus({ id: result.id });
  const txHash = status.receipts?.[0]?.transactionHash ?? result.id;

  return NextResponse.json({
    txHash, mode, callCount: calls.length,
    chain: baseSepolia.name, sponsored: !!process.env.ALCHEMY_GAS_POLICY_ID,
  });
}