Self-Custody Trading

import { createAggClient } from "@agg-build/sdk";

const client = createAggClient({
  baseUrl: "https://api.agg.market",
  appId: "your-app-id",
  signer: mySigner,
});

type CustodyWarning = { reason: string; message: string };

// `getSmartRoute()` does not carry `signingAddress` yet — quote through `request()`,
// whose query values are strings on the wire.
const quote = await client.request<{
  quoteId: string;
  status: string;
  custodyWarnings?: CustodyWarning[];
}>("/orderbook/vmo_abc123/route", {
  query: { signingAddress: wallet, maxSpend: "25" },
});

for (const w of quote.custodyWarnings ?? []) {
  // Non-blocking on the quote, but the fill WILL be refused.
  // Surface it before the user commits.
  console.warn(w.reason, w.message);
}

const result = await client.fillSelfCustody({
  quoteId: quote.quoteId,
  signingAddress: wallet,
});

{
  stepId: string;        // echo back verbatim
  type: SignatureRequestType;
  venue: string;         // the venue the fill is for, on bridge legs too — switch on `type`, not this
  signerAddress: string; // this key must produce the signature
  chainId?: number;      // often absent, even on EVM bridge legs — read the chain from the payload
  payload: unknown;      // sign it verbatim
  expiresAt: string;     // ISO-8601 — always read this
}

import { hashTypedData, serializeSignature } from "viem";
import type { SignerFn } from "@agg-build/sdk";

const mySigner: SignerFn = async (req) => {
  switch (req.type) {
    case "eip712":
    case "hl_l1_action":
      return walletClient.signTypedData(req.payload as never);

    case "personal_sign":
      return walletClient.signMessage({ message: req.payload as string });

    case "safe_tx":
      return walletClient.signMessage({
        message: { raw: hashTypedData(req.payload as never) },
      });

    case "eip7702_authorization": {
      const auth = await walletClient.signAuthorization(req.payload as never);
      // viem types both `yParity` and `v` as optional; derive rather than default,
      // or a wrong parity recovers to some other address and the server rejects it.
      const yParity = auth.yParity ?? (auth.v === undefined ? undefined : Number(auth.v) - 27);
      if (yParity !== 0 && yParity !== 1) throw new Error("authorization has no usable parity");
      return serializeSignature({ r: auth.r, s: auth.s, yParity });
    }

    case "transaction": {
      const tx = req.payload as { chainId: string; to: string; value: string; data: string };
      // The wallet must broadcast on this chain, not whichever one it is on.
      await walletClient.switchChain({ id: Number(tx.chainId) });
      // Return the hash immediately — do NOT await the receipt.
      return {
        txHash: await walletClient.sendTransaction({
          to: tx.to as `0x${string}`,
          value: BigInt(tx.value), // decimal wei string; "0" for an approve
          data: tx.data as `0x${string}`,
        }),
      };
    }

    default:
      throw new Error(`unsupported signature request: ${req.type}`);
  }
};