How Hock works

/**
 * Hock Agent 001: an autonomous borrower that uses Hock exactly the way any outside agent would,
 * through the public MCP server (hock.markets/mcp). Every hour it locks $HOCK, borrows HYPE on a
 * one-day loan, and repays it early, so its repayment record builds in public on-chain.
 *
 * It runs on the Worker's cron every ten minutes. Each run does at most one thing: a price check,
 * an approval, a borrow or a repayment, then exits; the next run sees the result. Its key is the
 * Cloudflare secret HOCK_AGENT_KEY and never leaves the Worker.
 */
import {
  createPublicClient,
  createWalletClient,
  defineChain,
  erc20Abi,
  formatEther,
  parseEther,
  type Address,
  type Hex,
} from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { HOCK_TOKEN, RPC_URL, deploymentOf, rpcTransport } from "../lib/deployment";
import { handleMcp } from "../mcp/server";

export const AGENT_NAME = "Hock Agent 001";
/** $HOCK it locks for each loan. */
export const COLLATERAL = "500000";
export const TERM_DAYS = 1;
/** More than the whole $HOCK supply, so one approval covers every loan. */
const APPROVE_ONCE = "1000000000000";
/** Repay a loan once it has been open this long. */
// runs land a few seconds early on the ten-minute marks; 35 min means the 40-minute run repays
const HOLD_S = 35 * 60;
/** Open the next loan once this long has passed since the last one opened. */
const EVERY_S = 55 * 60;
/** Never hold a loan closer than this to its due date. */
const REPAY_WINDOW_S = 6 * 3600;

type Tx = { chainId: number; to: Address; data: Hex; value: string };
type Plan = { action: string; why: string; tx?: Tx };
/** One MCP tool call, as the agent made it: for the public activity feed. */
export type Step = { tool: string; args: Record<string, unknown>; result: string; ms: number };

let rpcId = 0;
/** Call one of Hock's MCP tools, through the same JSON-RPC interface outside agents use. */
async function tool<T = Record<string, unknown>>(
  trace: Step[],
  name: string,
  args: Record<string, unknown>,
  summary: (r: T) => string,
) {
  const t0 = Date.now();
  const res = await handleMcp(
    new Request("https://hock.markets/mcp", {
      method: "POST",
      headers: { "content-type": "application/json" },
      body: JSON.stringify({
        jsonrpc: "2.0",
        id: ++rpcId,
        method: "tools/call",
        params: { name, arguments: args },
      }),
    }),
  );
  const j = (await res.json()) as {
    result?: { isError?: boolean; structuredContent?: T; content?: { text: string }[] };
  };
  if (!j.result || j.result.isError) {
    const msg = j.result?.content?.[0]?.text ?? "no result";
    trace.push({ tool: name, args, result: `error: ${msg}`, ms: Date.now() - t0 });
    throw new Error(`${name}: ${msg}`);
  }
  const out = j.result.structuredContent as T;
  trace.push({ tool: name, args, result: summary(out), ms: Date.now() - t0 });
  return out;
}

const elysium = defineChain({
  id: 99901,
  name: "Elysium",
  nativeCurrency: { name: "HYPE", symbol: "HYPE", decimals: 18 },
  rpcUrls: { default: { http: [RPC_URL] } },
});
export const client = createPublicClient({
  chain: elysium,
  transport: rpcTransport({ retryCount: 3 }),
});

/** Decide the one thing to do now. */
export async function plan(me: Address, trace: Step[] = []): Promise<Plan> {
  const { loans } = await tool<{
    loans: {
      loan_id: string;
      state: string;
      seconds_left: number;
      repay_hype: number;
      opened: string;
    }[];
  }>(trace, "get_loans", { wallet: me }, (r) => {
    const n = r.loans.filter((l) => l.state === "active").length;
    return `${r.loans.length} loans, ${n} open`;
  });
  const now = Date.now() / 1000;
  const open = loans.find((l) => l.state === "active");
  if (open) {
    const age = now - Date.parse(open.opened) / 1000;
    if (age < HOLD_S && open.seconds_left > REPAY_WINDOW_S)
      return { action: "wait", why: `loan ${open.loan_id} open ${Math.round(age / 60)} min` };
    const r = await tool<{ transaction: Tx }>(
      trace,
      "build_repay",
      { loan_id: open.loan_id },
      () => `unsigned tx, value ${open.repay_hype} HYPE`,
    );
    return {
      action: "repay",
      why: `repaying ${open.repay_hype} HYPE on ${open.loan_id}`,
      tx: r.transaction,
    };
  }

  // no open loan: borrow again on the hour
  const last = Math.max(0, ...loans.map((l) => Date.parse(l.opened) / 1000));
  const since = now - last;
  // the price check must be 1 to 30 minutes old at borrow time, so it goes in one run early
  if (since < EVERY_S - 10 * 60)
    return { action: "wait", why: `next loan in ${Math.round((EVERY_S - since) / 60)} min` };
  const core = deploymentOf(HOCK_TOKEN).core;
  const allowed = await client.readContract({
    address: HOCK_TOKEN,
    abi: erc20Abi,
    functionName: "allowance",
    args: [me, core],
  });
  if (allowed < parseEther(COLLATERAL)) {
    // approve once for every future loan, not just this one
    const r = await tool<{ transaction: Tx }>(
      trace,
      "build_approve",
      { token: HOCK_TOKEN, amount: APPROVE_ONCE },
      () => "unsigned tx",
    );
    return { action: "approve", why: "approving $HOCK for its loans", tx: r.transaction };
  }
  const q = await tool<{
    ok: boolean;
    reason?: string;
    message?: string;
    receive_now_hype?: number;
  }>(trace, "quote_loan", { token: HOCK_TOKEN, amount: COLLATERAL, term_days: TERM_DAYS }, (r) =>
    r.ok ? `receive ${r.receive_now_hype} HYPE now` : `not now: ${r.reason}`,
  );
  // no snapshot to price against, or the price ran up past the last one: record a fresh one
  if (!q.ok && (q.reason === "needs_price_check" || q.reason === "PriceMoving")) {
    const r = await tool<{ transaction: Tx }>(
      trace,
      "build_price_check",
      { token: HOCK_TOKEN },
      () => "unsigned tx",
    );
    return {
      action: "price_check",
      why:
        q.reason === "PriceMoving"
          ? "the price ran up since the last check, so it records a new one"
          : "the quote needs a fresh price snapshot",
      tx: r.transaction,
    };
  }
  if (!q.ok) return { action: "wait", why: q.message ?? q.reason ?? "no quote" };
  if (since < EVERY_S)
    return { action: "wait", why: `next loan in ${Math.round((EVERY_S - since) / 60)} min` };

  const r = await tool<{ transaction: Tx | null; reason?: string }>(
    trace,
    "build_borrow",
    { token: HOCK_TOKEN, amount: COLLATERAL, term_days: TERM_DAYS },
    (b) => (b.transaction ? "unsigned tx" : `not now: ${b.reason}`),
  );
  if (!r.transaction) return { action: "wait", why: r.reason ?? "borrow not available" };
  return {
    action: "borrow",
    why: `borrowing ${q.receive_now_hype} HYPE against ${COLLATERAL} $HOCK on a ${TERM_DAYS}-day loan`,
    tx: r.transaction,
  };
}

/** One cron run: plan, then sign and send at most one transaction. */
export async function tick(key: string | undefined, dryRun = false) {
  if (!key) return { action: "off", why: "HOCK_AGENT_KEY is not set" };
  const account = privateKeyToAccount(key as Hex);
  const me = account.address;
  // a transaction from the last run still in flight: let it land first
  const [latest, pending] = await Promise.all([
    client.getTransactionCount({ address: me, blockTag: "latest" }),
    client.getTransactionCount({ address: me, blockTag: "pending" }),
  ]);
  if (pending > latest) return { action: "wait", why: "previous transaction still pending" };

  const p = await plan(me);
  const out: Record<string, unknown> = { agent: me, ...p, tx: undefined };
  if (!p.tx || dryRun) {
    console.log(`[${AGENT_NAME}] ${p.action}: ${p.why}`);
    return { ...out, tx: p.tx };
  }
  const balance = await client.getBalance({ address: me });
  if (balance < BigInt(p.tx.value) + parseEther("0.002"))
    return { ...out, action: "wait", why: `needs more HYPE (has ${formatEther(balance)})` };
  const wallet = createWalletClient({ account, chain: elysium, transport: rpcTransport() });
  const hash = await wallet.sendTransaction({
    to: p.tx.to,
    data: p.tx.data,
    value: BigInt(p.tx.value),
  });
  console.log(`[${AGENT_NAME}] ${p.action}: ${p.why} → ${hash}`);
  return { ...out, hash };
}