Add @handle support to a send flow

import { createResolver, WasmResolver, ResolveError, looksLikeName } from '@x1id/resolve';
import { readFileSync } from 'node:fs';
import { createRequire } from 'node:module';

const require = createRequire(import.meta.url);
const wasmPath = require.resolve('@x1id/resolve/wasm/x1_resolve_wasm.wasm');
const wasm = await WasmResolver.fromBytes(readFileSync(wasmPath));

// testnet works the same: rpcUrl: 'https://rpc.testnet.x1.xyz'
const x1id = createResolver({ rpcUrl: 'https://rpc.mainnet.x1.xyz', wasm });

function onRecipientInputChange(value: string) {
  if (looksLikeName(value)) {
    resolveRecipient(value); // → Step 2
  } else {
    // Treat as a raw address: run your existing validation/checksum path
    setRecipient(validateRawAddress(value));
  }
}

/** What the recipient field renders. The address is never shown alone. */
interface Recipient {
  address: string;
  display: string;   // "@jack" or "jack.x1" — the user must see which one they're paying
  verified: boolean; // false → show a warning before the user can send
}

type ResolveOutcome = { recipient: Recipient } | { hint: string };

async function resolveRecipient(input: string): Promise<ResolveOutcome> {
  try {
    const r = await x1id.resolve(input);
    return {
      recipient: {
        address: r.address,
        display: r.namespace === 'handle' ? `@${r.name}` : r.name,
        verified: r.verification === 'verified',
      },
    };
  } catch (e) {
    if (e instanceof ResolveError) {
      switch (e.code) {
        case 'not-found':           return { hint: 'No name found' };
        case 'ambiguous':           return { hint: 'Type either @jack or jack.x1 — not both' };
        case 'invalid-handle':      return { hint: 'Handles allow letters, digits and hyphens only' };
        case 'invalid-domain':      return { hint: "That doesn't look like a valid domain" };
        case 'no-record-for-chain': return { hint: 'This name has no address on the selected chain' };
        case 'rpc-error':           return { hint: 'Network issue — try again' };
        default:                    return { hint: 'Could not resolve that name' };
      }
    }
    throw e; // an unexpected, non-ResolveError failure — don't swallow it
  }
}

for (const input of ['@nike', 'jack.x1', '@jack.x1', 'not a name']) {
  console.log(input, '→', await resolveRecipient(input));
}
// "@nike"      → { recipient: { address: "E2cELM…", display: "@nike",   verified: true  } }  ← held by the treasury: Step 4 refuses it
// "jack.x1"    → { recipient: { address: "9pXw…", display: "jack.x1", verified: false } }  (mainnet RPC)
// "@jack.x1"   → { hint: "Type either @jack or jack.x1 — not both" }
// "not a name" → never reaches resolveRecipient — looksLikeName() returns false first

const TREASURY = 'E2cELMtby3YYYbDdxamuGKWCyte3kwLywv19pEk2iUq6'; // Config.treasury (immutable)
const fresh = createResolver({ rpcUrl: 'https://rpc.mainnet.x1.xyz', wasm, cacheTtlMs: 0 });

type PreSend = { ok: true; address: string } | { ok: false; reason: string };

async function checkBeforeSend(input: string, chain: 'X1' | 'SOL' | 'ETH' | 'BTC' = 'X1'): Promise<PreSend> {
  const r = await fresh.resolve(input, { chain }); // uncached; throws ResolveError as in Step 2
  if (r.address === TREASURY) return { ok: false, reason: 'This name is held by X1ID and has no owner yet.' };

  // The REST checks take top-level @handles only. Scoped names (name.tld) and
  // subnames (pay.alice) are resolved by the SDK above; /quote rejects them.
  const topLevelHandle = r.namespace === 'handle' && !r.name.includes('.');
  if (topLevelHandle) {
    const base = 'https://api.x1id.io';
    const name = encodeURIComponent(r.name);
    const [quote, rest] = await Promise.all([fetch(`${base}/quote/${name}`), fetch(`${base}/resolve/${name}?fresh=1`)]); // fresh: skip the ~20 s answer cache
    // Fail closed: if a check can't be read (429, 5xx), don't send.
    if (!quote.ok || !rest.ok) return { ok: false, reason: 'Could not verify this name right now. Try again.' };
    const q = await quote.json();
    const res = await rest.json();
    if (q.status === 'held') return { ok: false, reason: 'This name is reserved and held by X1ID.' };
    if (res.lease?.lapsed === true) return { ok: false, reason: "This name's lease has lapsed." };
  }
  return { ok: true, address: r.address };
}

function recipientConfirmation(recipient: Recipient) {
  return {
    heading: `Sending to ${recipient.display}`,  // always the name, never just the address
    subheading: recipient.address,
    warning: recipient.verified ? null : "This address hasn't been verified for this chain.",
    sendEnabled: true,
  };
}

async function resolveForChain(input: string, chain: 'X1' | 'SOL' | 'ETH' | 'BTC') {
  try {
    return { recipient: await x1id.resolve(input, { chain }) };
  } catch (e) {
    if (e instanceof ResolveError && e.code === 'no-record-for-chain') {
      return { hint: `@${input.replace(/^@/, '')} has no address on ${chain} yet` };
    }
    throw e;
  }
}

async function labelFor(address: string): Promise<string> {
  const name = await x1id.reverse(address); // "nike" | "9pXw….x1" | null
  if (name === null) return shorten(address);      // no primary set — show the address
  if (name.includes('.')) return shorten(address); // X1NS fallback carries no label; keep the address
  return `@${name}`;                               // on-chain primary handle
}