zklicensing 0.1.0-beta.2 → 0.1.0-beta.21

package/src/index.ts

@@ -0,0 +1,362 @@
+// Copyright (c) 2025-2026 zkLicensing project developers
+// SPDX-License-Identifier: BUSL-1.1
+
+/**
+ * verifyLicense — client SDK.
+ *
+ * Calls the licensing service's GET /verify until the on-chain refund
+ * window for the license has closed; from that point on returns from a
+ * local anchor and never touches the network again. The refund-window
+ * decision is server-side: the service returns `refundWindowClosed:
+ * boolean` on its /verify response, computed from its own record of
+ * `purchaseSlot + REFUND_WINDOW_N` against the on-chain `currentSlot`.
+ * The SDK gates anchor writes on that boolean and never trusts a
+ * `purchaseSlot` supplied by the local license file, so a user who forges
+ * their proof metadata cannot force the offline branch prematurely.
+ *
+ * Anchor purity: every field persisted in the Anchor derives from the
+ * service's /verify response — `anchoredSlot`, `expirySlot`. The only
+ * client-supplied input to the offline branch is `proof.expirySlot`,
+ * used solely as the loadAnchor binding key. A tampered license file
+ * therefore never gets a wrong answer; it gets no offline branch at all
+ * and falls through to the licensing service on every call.
+ */
+
+import {
+  REFUND_WINDOW_N,
+  GRACE_PERIOD_N,
+  MS_PER_SLOT_N,
+  SLOTS_PER_DAY_N,
+} from './slotConstants.js';
+
+const MS_PER_SLOT = MS_PER_SLOT_N;
+const SLOTS_PER_DAY = SLOTS_PER_DAY_N;
+
+// The one and only verify endpoint. Every issued license routes here
+// regardless of network — the platform verifier resolves devnet vs
+// mainnet from the zkAppAddress (each deployment is unique per network).
+// Tests inject a mock via VerifyOptions.fetcher, not by rewriting this URL.
+export const DEFAULT_VERIFIER_URL = 'https://zklicensing.com/api/verify';
+
+// Anchor records are keyed by (zkAppAddress, licenseHash). zkAppAddress
+// is generation-scoped by construction: each redeploy puts the
+// LicensingApp at a fresh address (see backend's finalizeRedeploy and
+// AppRecord.deploymentHistory[]), so keying on it implicitly captures
+// generation. An anchor for a retired address is orphaned once the license
+// file names the successor, and re-created cleanly on its next verify.
+const ANCHOR_KEY_PREFIX = 'zklic_anchor_';
+
+function anchorKey(zkAppAddress: string, licenseHash: string): string {
+  return `${ANCHOR_KEY_PREFIX}${zkAppAddress}_${licenseHash}`;
+}
+
+export interface Storage {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+}
+
+export interface ProofInput {
+  licenseHash: string;
+  zkAppAddress: string;
+  expirySlot: number;
+}
+
+export interface VerifyOptions {
+  storage?: Storage | null;
+  fetcher?: typeof fetch;
+  now?: () => number;
+}
+
+export interface VerifyResult {
+  valid: boolean;
+  expirySlot: number;
+  // ISO-8601 timestamp of estimated expiry. `null` when the license is
+  // unknown / refunded / unreachable. In the offline branch this is
+  // estimated from the anchor + local clock.
+  expiresAt: string | null;
+  // Estimated current Mina slot. From the licensing service in the
+  // chain branch; estimated from the anchor + elapsed local time in the
+  // offline branch.
+  currentSlot: number;
+  inGracePeriod: boolean;
+  // Whole days until expiry. Negative while in the grace period (down
+  // to ~-7) and below that once fully expired. 0 when expirySlot is
+  // unknown.
+  remainingDays: number;
+  reason: string | null;
+  source: 'offline' | 'chain';
+}
+
+interface Anchor {
+  anchoredSlot: number;
+  anchoredAtMs: number;
+  expirySlot: number;
+  // The service's effectiveExpirySlot when the license counts from the app's
+  // fork slot (it lapsed during the pre-fork sales freeze).
+  effectiveExpirySlot?: number;
+}
+
+function defaultStorage(): Storage | null {
+  if (typeof globalThis !== 'undefined' && (globalThis as any).localStorage) {
+    return (globalThis as any).localStorage as Storage;
+  }
+  return null;
+}
+
+function loadAnchor(
+  storage: Storage,
+  zkAppAddress: string,
+  licenseHash: string,
+  expirySlot: number,
+): Anchor | null {
+  try {
+    const raw = storage.getItem(anchorKey(zkAppAddress, licenseHash));
+    if (!raw) return null;
+    const a = JSON.parse(raw) as Anchor;
+    // `a.expirySlot` is the SERVICE's value captured at anchor time;
+    // the `expirySlot` argument is the LOCAL license file's value. Match
+    // ⇒ local file agrees with chain truth as of anchoring ⇒ offline is
+    // safe. Mismatch has two honest meanings:
+    //   - renewal: chain moved, local file updated ⇒ re-anchor via chain check
+    //   - forgery: local file edited ⇒ every call falls through to the
+    //     licensing service, which reports truth. The forger gets no
+    //     offline branch at all.
+    if (a.expirySlot !== expirySlot) return null;
+    return a;
+  } catch {
+    return null;
+  }
+}
+
+function saveAnchor(
+  storage: Storage,
+  zkAppAddress: string,
+  licenseHash: string,
+  anchor: Anchor,
+): void {
+  try {
+    storage.setItem(anchorKey(zkAppAddress, licenseHash), JSON.stringify(anchor));
+  } catch {
+    // Storage may be full or read-only; the offline path simply won't activate.
+  }
+}
+
+function computeRemainingDays(expirySlot: number, currentSlot: number): number {
+  if (expirySlot === 0) return 0;
+  return Math.floor((expirySlot - currentSlot) / SLOTS_PER_DAY);
+}
+
+function offlineCheck(anchor: Anchor, nowMs: number): VerifyResult {
+  const elapsedSlots = Math.max(0, Math.floor((nowMs - anchor.anchoredAtMs) / MS_PER_SLOT));
+  const estCurrentSlot = anchor.anchoredSlot + elapsedSlots;
+  const until = anchor.effectiveExpirySlot ?? anchor.expirySlot;
+  const expired = estCurrentSlot > until + GRACE_PERIOD_N;
+  const inGracePeriod = !expired && estCurrentSlot > until;
+  const expiresAt = new Date(nowMs + (until - estCurrentSlot) * MS_PER_SLOT).toISOString();
+  return {
+    valid: !expired,
+    expirySlot: anchor.expirySlot,
+    expiresAt,
+    currentSlot: estCurrentSlot,
+    inGracePeriod,
+    remainingDays: computeRemainingDays(until, estCurrentSlot),
+    reason: expired
+      ? 'License has expired'
+      : inGracePeriod
+      ? 'License is in grace period — renew to avoid interruption'
+      : null,
+    source: 'offline',
+  };
+}
+
+export async function verifyLicense(
+  proof: ProofInput,
+  options: VerifyOptions = {}
+): Promise<VerifyResult> {
+  const storage = options.storage === null ? null : options.storage ?? defaultStorage();
+  const fetcher = options.fetcher ?? (typeof fetch !== 'undefined' ? fetch : undefined);
+  const nowFn = options.now ?? (() => Date.now());
+
+  if (storage) {
+    const anchor = loadAnchor(storage, proof.zkAppAddress, proof.licenseHash, proof.expirySlot);
+    if (anchor) return offlineCheck(anchor, nowFn());
+  }
+
+  if (!fetcher) {
+    return {
+      valid: false,
+      expirySlot: proof.expirySlot,
+      expiresAt: null,
+      currentSlot: 0,
+      inGracePeriod: false,
+      remainingDays: 0,
+      reason: 'No fetch implementation available; cannot verify',
+      source: 'chain',
+    };
+  }
+
+  const url =
+    `${DEFAULT_VERIFIER_URL}` +
+    `?licenseHash=${encodeURIComponent(proof.licenseHash)}` +
+    `&zkAppAddress=${encodeURIComponent(proof.zkAppAddress)}`;
+
+  let data: any;
+  try {
+    const resp = await fetcher(url);
+    if (!resp.ok) {
+      return {
+        valid: false,
+        expirySlot: proof.expirySlot,
+        expiresAt: null,
+        currentSlot: 0,
+        inGracePeriod: false,
+        remainingDays: 0,
+        reason: `Verification request failed (HTTP ${resp.status})`,
+        source: 'chain',
+      };
+    }
+    data = await resp.json();
+  } catch (err: any) {
+    return {
+      valid: false,
+      expirySlot: proof.expirySlot,
+      expiresAt: null,
+      currentSlot: 0,
+      inGracePeriod: false,
+      remainingDays: 0,
+      reason: err?.message ?? 'Verification request errored',
+      source: 'chain',
+    };
+  }
+
+  // Service's authoritative expiry, or null if the response omits it.
+  // Only the null-safe form may be written into the anchor; the
+  // chain-result display value below falls back to the local license file
+  // for user-facing fields, which is safe (display only).
+  const respExpirySlotStrict: number | null =
+    typeof data.expirySlot === 'number' ? data.expirySlot : null;
+  const respExpirySlot: number = respExpirySlotStrict ?? proof.expirySlot;
+  const respCurrentSlot: number = typeof data.currentSlot === 'number' ? data.currentSlot : 0;
+  const result: VerifyResult = {
+    valid: !!data.valid,
+    expirySlot: respExpirySlot,
+    expiresAt: typeof data.expiresAt === 'string' ? data.expiresAt : null,
+    currentSlot: respCurrentSlot,
+    inGracePeriod: !!data.inGracePeriod,
+    remainingDays: typeof data.remainingDays === 'number'
+      ? data.remainingDays
+      : computeRemainingDays(respExpirySlot, respCurrentSlot),
+    reason: data.reason ?? null,
+    source: 'chain',
+  };
+
+  // Anchor gate uses the service's own refund-window decision. The
+  // service knows the true purchaseSlot (stored in its LicenseRecord)
+  // and the true currentSlot; the SDK never trusts a purchaseSlot or
+  // expirySlot supplied by the local license file, since that file is
+  // client-writable and could be forged. If the service omits
+  // `expirySlot`, we fail-closed on the offline path — no anchor
+  // written, subsequent calls stay online.
+  if (
+    storage &&
+    result.valid &&
+    data.refundWindowClosed === true &&
+    typeof data.currentSlot === 'number' &&
+    respExpirySlotStrict !== null
+  ) {
+    saveAnchor(storage, proof.zkAppAddress, proof.licenseHash, {
+      anchoredSlot: data.currentSlot,
+      anchoredAtMs: nowFn(),
+      expirySlot: respExpirySlotStrict,
+      ...(typeof data.effectiveExpirySlot === 'number' ? { effectiveExpirySlot: data.effectiveExpirySlot } : {}),
+    });
+  }
+
+  return result;
+}
+
+// Re-exported so tests and downstream tooling can reference the same values
+// the SDK uses internally without re-deriving them.
+export { REFUND_WINDOW_N, GRACE_PERIOD_N, MS_PER_SLOT };
+
+// Non-custodial device binding surface, here alongside buy / renew / refund
+// so vendor integrations can pull the whole family from one import path.
+// These load o1js (bindClient, unbindClient, deviceIdentity) only when
+// called, so this entry imports without o1js (an optional peer): an app
+// that only verifies licenses doesn't need it. Each also has its own
+// subpath (`zklicensing/bind`, `zklicensing/unbind`,
+// `zklicensing/device-identity`).
+type BindClient = typeof import('./bindClient.js');
+type UnbindClient = typeof import('./unbindClient.js');
+type DeviceIdentityModule = typeof import('./deviceIdentity.js');
+const bindClient = () => import('./bindClient.js');
+const unbindClient = () => import('./unbindClient.js');
+const deviceIdentityModule = () => import('./deviceIdentity.js');
+export async function proveBind(...a: Parameters<BindClient['proveBind']>): ReturnType<BindClient['proveBind']> { return (await bindClient()).proveBind(...a); }
+export async function confirmBind(...a: Parameters<BindClient['confirmBind']>): ReturnType<BindClient['confirmBind']> { return (await bindClient()).confirmBind(...a); }
+export async function pollBindStatus(...a: Parameters<BindClient['pollBindStatus']>): ReturnType<BindClient['pollBindStatus']> { return (await bindClient()).pollBindStatus(...a); }
+export async function fetchBindingState(...a: Parameters<BindClient['fetchBindingState']>): ReturnType<BindClient['fetchBindingState']> { return (await bindClient()).fetchBindingState(...a); }
+export async function proveUnbind(...a: Parameters<UnbindClient['proveUnbind']>): ReturnType<UnbindClient['proveUnbind']> { return (await unbindClient()).proveUnbind(...a); }
+export async function confirmUnbind(...a: Parameters<UnbindClient['confirmUnbind']>): ReturnType<UnbindClient['confirmUnbind']> { return (await unbindClient()).confirmUnbind(...a); }
+export async function pollUnbindStatus(...a: Parameters<UnbindClient['pollUnbindStatus']>): ReturnType<UnbindClient['pollUnbindStatus']> { return (await unbindClient()).pollUnbindStatus(...a); }
+export async function getOrCreateDeviceIdentity(...a: Parameters<DeviceIdentityModule['getOrCreateDeviceIdentity']>): ReturnType<DeviceIdentityModule['getOrCreateDeviceIdentity']> { return (await deviceIdentityModule()).getOrCreateDeviceIdentity(...a); }
+export type {
+  ProveBindRequest,
+  ProveBindResponse,
+  ConfirmBindRequest,
+  BindStatus,
+  PollBindStatusOptions,
+} from './bindClient.js';
+export type {
+  ProveUnbindRequest,
+  ProveUnbindResponse,
+  ConfirmUnbindRequest,
+  UnbindStatus,
+  PollUnbindStatusOptions,
+} from './unbindClient.js';
+export type { DeviceIdentity } from './deviceIdentity.js';
+
+// The synchronous o1js helpers are on their subpaths only (they can't load
+// o1js lazily): `computeDeviceCommitment` from `zklicensing/device-identity`,
+// `verifyOffline` and `deviceCommitmentFromFields` from
+// `zklicensing/verify-offline`.
+export type {
+  VerifyOfflineInput,
+  VerifyOfflineResult,
+  DeviceSlotSnapshot,
+} from './verifyOffline.js';
+
+// Non-custodial trust anchor for `verifyOffline`. Reads the live
+// `licensesRoot` (zkapp.appState[0]) directly from Mina — pair it with
+// `verifyOffline` when you do not want to trust the licensing service's
+// reported root. Also available at the `zklicensing/on-chain-root`
+// subpath. o1js is imported lazily so callers that skip this helper
+// don't pay the o1js dep cost at load time.
+export { fetchOnChainLicensesRoot, DEFAULT_MINA_GRAPHQL_URLS } from './onChainRoot.js';
+export type { FetchOnChainLicensesRootInput, NetworkName } from './onChainRoot.js';
+
+// The receipt file a buyer downloads: `license-<appId>.json`. Look for it
+// under this name in your app's data folder. Also available at the
+// `zklicensing/record` subpath.
+export { licenseFileName, platformFeeNano, vendorShareNano } from './licenseRecord.js';
+
+// Human-readable seat names for the device-binding UI ("Silent Otter",
+// "Curious Panda"). Deterministic in `licenseHash + slotIndex + boundAtSlot`,
+// so every viewer of the same license computes the same name per slot
+// without a naming sidecar. Also available at the `zklicensing/seat-name`
+// subpath.
+export { seatNameFor, SEAT_NAME_COMBINATIONS } from './seatName.js';
+export type { SeatNameInput } from './seatName.js';
+
+// Vendor-signed escrow release. The licensing service proves the release tx
+// with the vendor's address as fee payer and returns unsigned tx JSON; the
+// vendor's wallet signs the fee-payer AU and broadcasts. Removes the
+// service's own feepayer key from the release critical path — vendors can
+// release even when the auto-release loop is disabled.
+export { proveVendorRelease, confirmVendorRelease } from './releaseClient.js';
+export type {
+  ProveVendorReleaseRequest,
+  ProveVendorReleaseResponse,
+  ConfirmVendorReleaseRequest,
+  ConfirmVendorReleaseResponse,
+} from './releaseClient.js';

package/src/keysClient.ts

@@ -0,0 +1,135 @@
+// Copyright (c) 2025-2026 zkLicensing project developers
+// SPDX-License-Identifier: BUSL-1.1
+
+/**
+ * keysClient.ts — key changes on a licensing app, through the keeper.
+ *
+ * - The keys an app holds on chain (vendor, payout address and a pending
+ *   change, platform key and treasury).
+ * - Payout address: the vendor proposes a new one (their wallet sends it);
+ *   it takes effect PAYOUT_DELAY_SLOTS_N slots (48 h) later unless
+ *   cancelled. The keeper applies it then; anyone may (applyPayout).
+ * - Vendor account move: the current and the new wallet both sign a text
+ *   and, for every live deployment, the contract's vendorKeyMessage.
+ * - License transfer (resale): the new owner opens it with the public key
+ *   of their new passphrase (the passphrase never leaves their device), the
+ *   current owner signs, the new owner signs, and the new owner's wallet
+ *   sends it. Only once nothing of the purchase is in escrow.
+ *
+ * Signatures over fields are Mina Schnorr signatures (base58), as an
+ * o1js `Signature` or a wallet's `signFields` gives.
+ */
+
+import { Field, PublicKey, Signature, UInt32, type PrivateKey } from 'o1js';
+import { licenseTransferMessage, vendorKeyMessage } from './contractInterface.js';
+import { networkField } from './permitMessages.js';
+import { ownerPubKeyHash } from './licenseLeaf.js';
+
+export type KeysClientOptions = { keeperUrl: string; fetcher?: typeof fetch };
+
+export type AppKeys = {
+  appId: string; network: 'devnet' | 'mainnet'; zkAppAddress: string; slot: number;
+  vendor: string; vendorNonce: number; payout: string;
+  pendingPayout: { payout: string; effectiveSlot: number } | null;
+  platform: { key: string; treasury: string; epoch: number };
+};
+
+export type LicenseTransfer = {
+  id: string; network: 'devnet' | 'mainnet'; zkAppAddress: string;
+  from: string; to: string; newOwner: string; leafHash: string; validUntil: number; message: string[];
+  oldOwner?: string; status: 'signing' | 'ready' | 'sent' | 'done'; createdAt: string; txHash?: string;
+};
+
+/** A wallet that signs texts and fields (Auro's signMessage / signFields shapes). */
+export type MoveWallet = {
+  address: string;
+  signMessage(message: string): Promise<{ field: string; scalar: string }>;
+  signFields(fields: string[]): Promise<string>;
+};
+
+export class KeysError extends Error {
+  constructor(message: string, readonly status: number, readonly code?: string) { super(message); }
+}
+
+export function createKeysClient(opts: KeysClientOptions) {
+  const base = opts.keeperUrl.replace(/\/+$/, '');
+  const f = opts.fetcher ?? fetch;
+  async function call<T>(method: string, path: string, body?: unknown): Promise<T> {
+    const r = await f(base + path, { method, headers: { 'content-type': 'application/json' }, ...(body === undefined ? {} : { body: JSON.stringify(body) }) });
+    const json = await r.json().catch(() => null) as any;
+    if (!r.ok) throw new KeysError(json?.error ?? `${method} ${path} failed (${r.status})`, r.status, json?.code);
+    return json as T;
+  }
+
+  return {
+    /** The keys the app holds on chain. */
+    getAppKeys: (zkAppAddress: string) => call<AppKeys>('GET', `/app-keys?zkAppAddress=${encodeURIComponent(zkAppAddress)}`),
+
+    /** Proves a payout change for the vendor's wallet to sign and send (its `vendorAddress` must be the app's vendor key). */
+    provePayout: (a: { zkAppAddress: string; vendorAddress: string; payout: string }) =>
+      call<{ provenTxJson: string; payout: string }>('POST', '/prove/payout', a),
+    /** Proves the cancellation of a pending payout change (vendor's wallet). */
+    provePayoutCancel: (a: { zkAppAddress: string; vendorAddress: string }) =>
+      call<{ provenTxJson: string; cancelled: string }>('POST', '/prove/payout/cancel', a),
+    /** Proves applying a payout change past its delay, with any fee payer (the keeper does it itself). */
+    provePayoutApply: (a: { zkAppAddress: string; feePayer: string }) =>
+      call<{ provenTxJson: string; payout: string }>('POST', '/prove/payout/apply', a),
+
+    /**
+     * Moves the vendor account from `from` to `to`: both wallets sign the
+     * move and every live deployment's key change. The keeper's records move
+     * at once; it sends the contract changes (or anyone, with /prove/vendor-key).
+     * `network` is the one the wallets' text signatures are made on.
+     */
+    async moveVendorAccount(a: { network: 'devnet' | 'mainnet'; from: MoveWallet; to: MoveWallet }) {
+      const prep = await call<{ text: string; changes: Array<{ appId: string; network: 'devnet' | 'mainnet'; zkAppAddress: string; nonce: number; message: string[] }> }>(
+        'POST', '/vendors/move/prepare', { from: a.from.address, to: a.to.address });
+      // Check each message is the key change it says it is before signing.
+      for (const c of prep.changes) {
+        const expected = vendorKeyMessage({ network: networkField(c.network), app: PublicKey.fromBase58(c.zkAppAddress), nonce: UInt32.from(c.nonce), vendor: PublicKey.fromBase58(a.to.address) }).map(String);
+        if (expected.join() !== c.message.join()) throw new KeysError(`The key change for ${c.zkAppAddress} is not the one asked for: not signing`, 0, 'SIGNATURE_INVALID');
+      }
+      const changes = [];
+      for (const c of prep.changes) changes.push({ zkAppAddress: c.zkAppAddress, oldSignature: await a.from.signFields(c.message), newSignature: await a.to.signFields(c.message) });
+      return call<{ moved: { from: string; to: string }; changes: unknown[]; keeperSends: boolean }>('POST', '/vendors/move', {
+        network: a.network, from: a.from.address, to: a.to.address,
+        oldTextSignature: await a.from.signMessage(prep.text), newTextSignature: await a.to.signMessage(prep.text), changes,
+      });
+    },
+
+    // ── license transfer ────────────────────────────────────────────────────
+
+    /** The new owner opens a transfer with the public key of their new passphrase (deriveOwnershipKeypair). */
+    openTransfer: (a: { zkAppAddress: string; licenseHash: string; newOwnerPubKey: string }) =>
+      call<{ transfer: LicenseTransfer }>('POST', '/transfers', a).then(r => r.transfer),
+    getTransfer: (id: string) => call<{ transfer: LicenseTransfer }>('GET', `/transfers/${encodeURIComponent(id)}`).then(r => r.transfer),
+    /**
+     * Signs the transfer with an ownership key: the current owner's (`role:
+     * 'old'`; from findOwnershipKeypair, since a license carried over from an
+     * earlier generation is keyed to that one's address) or the new owner's
+     * (`'new'`; deriveOwnershipKeypair with the transfer's zkAppAddress). The message is checked first
+     * against the transfer's details.
+     */
+    async signTransfer(id: string, role: 'old' | 'new', ownerKey: PrivateKey) {
+      const t = await call<{ transfer: LicenseTransfer }>('GET', `/transfers/${encodeURIComponent(id)}`).then(r => r.transfer);
+      const pub = ownerKey.toPublicKey();
+      if (role === 'old' && ownerPubKeyHash(pub).toString() !== t.from) throw new KeysError('This passphrase does not own the license', 0, 'FORBIDDEN');
+      if (role === 'new' && pub.toBase58() !== t.newOwner) throw new KeysError('This passphrase is not the one the transfer was opened for', 0, 'FORBIDDEN');
+      const expected = licenseTransferMessage({
+        network: networkField(t.network), app: PublicKey.fromBase58(t.zkAppAddress), leafHash: Field(t.leafHash), to: Field(t.to), validUntil: UInt32.from(t.validUntil),
+      }).map(String);
+      if (expected.join() !== t.message.join() || ownerPubKeyHash(PublicKey.fromBase58(t.newOwner)).toString() !== t.to) {
+        throw new KeysError('The transfer message does not match its details: not signing', 0, 'SIGNATURE_INVALID');
+      }
+      const signature = Signature.create(ownerKey, t.message.map(x => Field(x))).toBase58();
+      return call<{ transfer: LicenseTransfer }>('POST', `/transfers/${encodeURIComponent(id)}/signatures`, {
+        role, signature, ...(role === 'old' ? { ownerPubKey: pub.toBase58() } : {}),
+      }).then(r => r.transfer);
+    },
+    /** Both signed: proves the transfer for `feePayer` (the new owner's wallet) to sign and send. */
+    proveTransfer: (id: string, feePayer: string) => call<{ provenTxJson: string; transferId: string }>('POST', '/prove/transfer', { id, feePayer }),
+    confirmTransfer: (id: string, txHash: string) => call<{ ok: true }>('POST', '/confirm/transfer', { id, txHash }),
+  };
+}
+
+export type KeysClient = ReturnType<typeof createKeysClient>;