import { WoTClient } from "@anthropic/wot-sdk";

const client = new WoTClient({
  baseUrl: "https://wot-oracle.dtonon.com",
  timeout: 5000,
  retries: 3,
});

const result = await client.getDistance(fromPubkey, toPubkey);

console.log(result.distance);    // number | null
console.log(result.paths);       // number
console.log(result.mutual);      // boolean

// With options
const result = await client.getDistance(from, to, {
  maxHops: 4,
  includeDetails: true,
});

const trusted = await client.isInWoT(fromPubkey, toPubkey);

// With custom threshold
const veryTrusted = await client.isInWoT(fromPubkey, toPubkey, 2);

const follows = await client.getFollows(pubkey);
console.log(`Following ${follows.length} accounts`);

const common = await client.getCommonFollows(alice, bob);
console.log(`They both follow ${common.length} accounts`);

const results = await client.getDistanceBatch(fromPubkey, [
  "target1...",
  "target2...",
  "target3...",
]);

// Returns array of results
results.forEach(r => {
  console.log(`${r.to}: ${r.distance} hops`);
});

const path = await client.getPath(fromPubkey, toPubkey);

if (path) {
  console.log("Connection path:", path.join(" → "));
}

const stats = await client.getStats();

console.log(`Total users: ${stats.total_users}`);
console.log(`Total follows: ${stats.total_follows}`);
console.log(`Uptime: ${stats.uptime}`);

const healthy = await client.checkHealth();
if (!healthy) {
  console.error("Oracle server is down");
}

const publicOracle = new WoTClient({
  baseUrl: "https://wot-oracle.dtonon.com",
});

const privateOracle = new WoTClient({
  baseUrl: "https://my-oracle.example.com",
  headers: { "Authorization": "Bearer my-token" },
});

const client = new WoTClient({
  baseUrl: "https://wot-oracle.dtonon.com",
  fetch: customFetch,
});

import { WoTError, WoTValidationError, WoTNetworkError } from "@anthropic/wot-sdk";

try {
  const result = await client.getDistance(from, to);
} catch (error) {
  if (error instanceof WoTValidationError) {
    console.error("Invalid input:", error.message);
  } else if (error instanceof WoTNetworkError) {
    console.error("Network error:", error.message);
    console.log("Retry after:", error.retryAfter);
  } else if (error instanceof WoTError) {
    console.error("WoT error:", error.code, error.message);
  }
}

import { WoTProvider } from "@anthropic/wot-sdk/react";

function App() {
  return (
    <WoTProvider baseUrl="https://wot-oracle.dtonon.com">
      <MyApp />
    </WoTProvider>
  );
}

import { useDistance } from "@anthropic/wot-sdk/react";

function TrustBadge({ from, to }: { from: string; to: string }) {
  const { distance, loading, error } = useDistance(from, to);

  if (loading) return <span>Loading...</span>;
  if (error) return <span>Error: {error.message}</span>;
  if (distance === null) return <span>Not connected</span>;

  return <span>{distance} hops away</span>;
}

import { useIsInWoT } from "@anthropic/wot-sdk/react";

function TrustedIndicator({ from, to }: { from: string; to: string }) {
  const { trusted, loading } = useIsInWoT(from, to, 2);

  if (loading) return null;
  return trusted ? <span className="text-green-500">Trusted</span> : null;
}

import { useWoTClient } from "@anthropic/wot-sdk/react";

function MyComponent() {
  const client = useWoTClient();

  const handleClick = async () => {
    const result = await client.getDistance(from, to);
    // ...
  };

  return <button onClick={handleClick}>Check</button>;
}