Anchor management

CREATE TABLE anchors_catalog (
  id TEXT PRIMARY KEY,                    -- {domain}:{type}:{country}:{currency}
  name TEXT NOT NULL,
  domain TEXT NOT NULL,
  country TEXT NOT NULL,                  -- ISO 3166-1 alpha-2 code
  currency TEXT NOT NULL,                 -- Asset code (USDC, XLM, MXN, etc.)
  type TEXT NOT NULL,                     -- 'on-ramp' or 'off-ramp'
  active BOOLEAN DEFAULT true,
  
  -- SEP capabilities (validated via stellar.toml)
  sep24 BOOLEAN DEFAULT false,
  sep6 BOOLEAN DEFAULT false,
  sep31 BOOLEAN DEFAULT false,
  sep10 BOOLEAN DEFAULT false,
  operational BOOLEAN DEFAULT false,
  
  -- Fee metadata (from SEP-24/SEP-6 /info endpoints)
  fee_fixed DECIMAL,
  fee_percent DECIMAL,
  fee_source TEXT,                        -- 'sep24' | 'sep6' | 'default'
  
  -- Endpoint URLs (from stellar.toml)
  transfer_server_sep24 TEXT,
  transfer_server_sep6 TEXT,
  web_auth_endpoint TEXT,
  direct_payment_server TEXT,
  kyc_server TEXT,
  
  -- Metadata
  diagnostics TEXT[],
  last_checked_at TIMESTAMPTZ,
  created_at TIMESTAMPTZ DEFAULT NOW(),
  updated_at TIMESTAMPTZ DEFAULT NOW()
);

CREATE INDEX idx_anchors_active_country ON anchors_catalog(active, country);
CREATE INDEX idx_anchors_active_type ON anchors_catalog(active, type);
CREATE INDEX idx_anchors_domain ON anchors_catalog(domain);

{
  "anchors": [
    {
      "name": "MoneyGram",
      "domain": "stellar.moneygram.com",
      "countries": ["US", "MX", "PH"],
      "currencies": ["USDC", "MXN", "PHP"],
      "type": "on-ramp"
    }
  ]
}

export async function discoverAnchorFromDomain(input: { domain: string }) {
  const tomlUrl = `https://${input.domain}/.well-known/stellar.toml`;
  const response = await fetch(tomlUrl);
  
  if (!response.ok) {
    throw new Error(`stellar.toml not found at ${tomlUrl} (${response.status})`);
  }
  
  const tomlText = await response.text();
  const parsed = TOML.parse(tomlText);
  
  return {
    domain: input.domain,
    webAuthEndpoint: parsed.WEB_AUTH_ENDPOINT,
    transferServerSep24: parsed.TRANSFER_SERVER_0024 || parsed.TRANSFER_SERVER,
    transferServerSep6: parsed.TRANSFER_SERVER_SEP0006 || parsed.TRANSFER_SERVER,
    directPaymentServer: parsed.DIRECT_PAYMENT_SERVER,
    kycServer: parsed.KYC_SERVER,
    signingKey: parsed.SIGNING_KEY
  };
}

export async function fetchSep24Info(input: {
  transferServerSep24: string;
}) {
  const response = await fetch(`${input.transferServerSep24}/info`);
  const info = await response.json();
  
  // Extract fee information from deposit/withdraw sections
  const fees = extractFeeFromInfo(info, assetCode);
  
  return { info, fees };
}

export async function resolveAnchorCapabilities(input: {
  domain: string;
  assetCode: string;
}): Promise<ResolvedAnchorCapabilities> {
  const diagnostics: string[] = [];
  
  // Fetch stellar.toml
  const sep1 = await discoverAnchorFromDomain({ domain: input.domain });
  
  // Check SEP support
  const sep = {
    sep24: Boolean(sep1.transferServerSep24),
    sep6: Boolean(sep1.transferServerSep6),
    sep31: Boolean(sep1.directPaymentServer),
    sep10: Boolean(sep1.webAuthEndpoint)
  };
  
  // Fetch fee data from SEP-24 /info
  let fees = { source: "default" };
  if (sep1.transferServerSep24) {
    const r = await fetchSep24Info({ transferServerSep24: sep1.transferServerSep24 });
    const extracted = extractFeeFromInfo(r.info, input.assetCode);
    if (extracted?.fixed || extracted?.percent) {
      fees = { ...extracted, source: "sep24" };
    }
  }
  
  // Determine operational status
  const operational = Boolean(
    sep.sep10 && sep.sep24 && sep1.webAuthEndpoint && sep1.transferServerSep24
  );
  
  return { domain: sep1.domain, sep, endpoints: sep1, fees, diagnostics, operational };
}

{
  "crons": [
    {
      "path": "/api/cron/anchors-sync",
      "schedule": "*/15 * * * *"
    }
  ]
}

export default async function handler(req: VercelRequest, res: VercelResponse) {
  // Verify cron secret
  const secret = process.env.CRON_SECRET;
  if (secret && req.query.secret !== secret) {
    return res.status(401).json({ error: "Unauthorized" });
  }
  
  // Discover anchors from Horizon
  const mode = (req.query.mode as string) || "horizon";
  const anchors = await discoverAnchors({ mode });
  
  // Upsert into catalog
  const upserted = await upsertAnchorsCatalog(anchors);
  
  // Refresh capabilities for active anchors
  const refreshLimit = Number(req.query.refreshLimit) || 100;
  const active = await listActiveAnchors();
  const toRefresh = active.slice(0, refreshLimit);
  
  for (const anchor of toRefresh) {
    const capabilities = await resolveAnchorCapabilities({
      domain: anchor.domain,
      assetCode: anchor.currency
    });
    
    await updateAnchorCapabilities({
      id: anchor.id,
      sep24: capabilities.sep.sep24,
      sep6: capabilities.sep.sep6,
      sep31: capabilities.sep.sep31,
      sep10: capabilities.sep.sep10,
      operational: capabilities.operational,
      diagnostics: capabilities.diagnostics,
      lastCheckedAt: new Date().toISOString()
    });
  }
  
  return res.status(200).json({ upserted, refreshed: toRefresh.length });
}

ANCHOR_ALLOWED_ASSETS=USDC,XLM

ANCHOR_ALLOWED_DOMAINS=stellar.moneygram.com,clpx.finance

ANCHOR_DOMAIN_COUNTRY_OVERRIDES=clpx.finance:CL,ntokens.com:BR

// Get anchors for a specific corridor
export async function getAnchorsForCorridor(input: {
  origin: string;
  destination: string;
}): Promise<AnchorCatalogEntry[]> {
  const { data } = await supabase
    .from("anchors_catalog")
    .select("*")
    .eq("active", true)
    .in("country", [input.origin, input.destination]);
  
  return filterAnchors(data.map(mapCatalogRow));
}

// List all active anchors
export async function listActiveAnchors(): Promise<AnchorCatalogEntry[]> {
  const { data } = await supabase
    .from("anchors_catalog")
    .select("*")
    .eq("active", true);
  
  return filterAnchors(data.map(mapCatalogRow));
}

// Update anchor capabilities after validation
export async function updateAnchorCapabilities(
  input: CapabilityUpdateInput
): Promise<void> {
  await supabase
    .from("anchors_catalog")
    .update({
      sep24: input.sep24,
      operational: input.operational,
      diagnostics: input.diagnostics,
      last_checked_at: input.lastCheckedAt
    })
    .eq("id", input.id);
}

// Disable an anchor
export async function setAnchorActive(input: {
  id: string;
  active: boolean;
}): Promise<void> {
  await supabase
    .from("anchors_catalog")
    .update({ active: input.active })
    .eq("id", input.id);
}