@paybox-sh/sdk 0.5.0 → 0.8.0

package/dist/{chunk-DIMOTJ2E.js → chunk-7VW4QMV4.js}

@@ -43,10 +43,10 @@ function openBrowser(url) {
   } catch {
   }
 }
-var CALLBACK_PAGE = '<!doctype html><meta charset=utf-8><title>Paybox</title><body style="font:16px system-ui;padding:3rem;text-align:center"><h2>Paybox CLI connected</h2><p>You can close this tab and return to the terminal.</p>';
+var CALLBACK_PAGE = '<!doctype html><meta charset=utf-8><title>PayBox</title><body style="font:16px system-ui;padding:3rem;text-align:center"><h2>PayBox CLI connected</h2><p>You can close this tab and return to the terminal.</p>';
 async function loginLoopback(baseUrl, opts = {}) {
   const scope = opts.scope ?? "mcp offline_access";
-  const clientName = opts.clientName ?? "Paybox CLI";
+  const clientName = opts.clientName ?? "PayBox CLI";
   const log = opts.log ?? ((m) => console.error(m));
   const meta = await metadata(baseUrl);
   const resource = mcpResource(baseUrl);
@@ -126,6 +126,91 @@ async function loginLoopback(baseUrl, opts = {}) {
     server.close();
   }
 }
+async function loginDevice(baseUrl, opts = {}) {
+  const scope = opts.scope ?? "mcp offline_access";
+  const clientName = opts.clientName ?? "PayBox CLI";
+  const log = opts.log ?? ((m) => console.error(m));
+  const meta = await metadata(baseUrl);
+  if (!meta.device_authorization_endpoint) {
+    throw new Error(
+      "this Paybox API does not advertise device_authorization_endpoint \u2014 upgrade the API and retry `paybox login`"
+    );
+  }
+  const resource = mcpResource(baseUrl);
+  const reg = await fetch(meta.registration_endpoint, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      client_name: clientName,
+      redirect_uris: ["http://127.0.0.1/device"],
+      token_endpoint_auth_method: "none",
+      grant_types: ["urn:ietf:params:oauth:grant-type:device_code", "refresh_token"],
+      response_types: ["code"],
+      // Must match (or be a superset of) what we ask for below — the server
+      // only grants scope that was declared at registration.
+      scope
+    })
+  });
+  if (!reg.ok) throw new Error(`client registration failed (${reg.status}): ${await reg.text()}`);
+  const { client_id: clientId } = await reg.json();
+  const started = await fetch(meta.device_authorization_endpoint, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({ client_id: clientId, scope, resource })
+  });
+  if (!started.ok) {
+    throw new Error(`device authorization failed (${started.status}): ${await started.text()}`);
+  }
+  const da = await started.json();
+  log(
+    `Open this URL on your phone (or this computer) to approve access:
+  ${da.verification_uri_complete}
+Code: ${da.user_code}
+`
+  );
+  openBrowser(da.verification_uri_complete);
+  const timeoutMs = opts.timeoutMs ?? da.expires_in * 1e3;
+  const deadline = Date.now() + timeoutMs;
+  let intervalSec = da.interval && da.interval > 0 ? da.interval : 5;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, intervalSec * 1e3));
+    const tok = await fetch(meta.token_endpoint, {
+      method: "POST",
+      headers: { "content-type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        device_code: da.device_code,
+        client_id: clientId
+      })
+    });
+    const raw = await tok.text();
+    if (tok.ok) {
+      const t = JSON.parse(raw);
+      return {
+        clientId,
+        accessToken: t.access_token,
+        refreshToken: t.refresh_token,
+        expiresAt: t.expires_in ? Date.now() + t.expires_in * 1e3 : void 0,
+        resource
+      };
+    }
+    let err = raw || "authorization failed";
+    let code = "";
+    try {
+      const body = JSON.parse(raw);
+      code = body.error ?? "";
+      err = body.error_description ?? body.error ?? err;
+    } catch {
+    }
+    if (code === "authorization_pending") continue;
+    if (code === "slow_down") {
+      intervalSec += 5;
+      continue;
+    }
+    throw new Error(err);
+  }
+  throw new Error(`login timed out after ${Math.round(timeoutMs / 1e3)}s \u2014 no approval received`);
+}
 async function refreshTokens(baseUrl, current) {
   if (!current.refreshToken) throw new Error("no refresh token \u2014 run `paybox login` again");
   const meta = await metadata(baseUrl);
@@ -178,7 +263,7 @@ function saveConfig(config) {
   if (process.platform !== "win32") chmodSync(configFile(), 384);
 }
 
-// node_modules/.pnpm/@paybox+mcp-app@file+..+mcp-app_@modelcontextprotocol+sdk@1.29.0_zod@4.4.3__bn.js@5.2.3_ac1e09a20c76a1143611be5dd3d4f9db/node_modules/@paybox/mcp-app/src/creds.ts
+// node_modules/.pnpm/@paybox+mcp-app@file+..+mcp-app_@modelcontextprotocol+sdk@1.29.0_zod@4.4.3__bn.js@5.2.3_ac1e09a20c76a1143611be5dd3d4f9db/node_modules/@paybox/mcp-app/src/signing/creds.ts
 var TOKEN_PREFIX = "pbxk1.";
 function validateHex(s, label) {
   const trimmed = s.trim();
@@ -213,7 +298,7 @@ function parseToken(input) {
   return { apiPubHex, apiPrivHex };
 }
 
-// node_modules/.pnpm/@paybox+mcp-app@file+..+mcp-app_@modelcontextprotocol+sdk@1.29.0_zod@4.4.3__bn.js@5.2.3_ac1e09a20c76a1143611be5dd3d4f9db/node_modules/@paybox/mcp-app/src/sign.ts
+// node_modules/.pnpm/@paybox+mcp-app@file+..+mcp-app_@modelcontextprotocol+sdk@1.29.0_zod@4.4.3__bn.js@5.2.3_ac1e09a20c76a1143611be5dd3d4f9db/node_modules/@paybox/mcp-app/src/signing/sign.ts
 import { Buffer as Buffer2 } from "buffer";
 import nacl from "tweetnacl";
 import { MoonXEvmSigner, EvmSchemeMismatchError } from "@moon-x/evm-adapter";
@@ -268,18 +353,18 @@ function solanaSigningPayload(base64Tx) {
     if ((b & 128) === 0) break;
     shift += 7;
   }
-  if (sigCount !== 1) {
-    throw new Error(`expected a single-signer solana tx, got ${sigCount} signature slot(s)`);
+  if (sigCount < 1) {
+    throw new Error("solana tx has no signature slots");
   }
-  return bytesToHex(new Uint8Array(raw.subarray(i + 64)));
+  return bytesToHex(new Uint8Array(raw.subarray(i + sigCount * 64)));
 }
 function buildSwapEnvelopes(txs, binding, creds) {
   if (!binding.walletId) {
-    throw new Error("paybox did not supply a wallet id for this operation.");
+    throw new Error("PayBox did not supply a wallet id for this operation.");
   }
   if (!binding.keyId || !binding.derivationPath) {
     throw new Error(
-      "This wallet isn't provisioned for signing yet (missing key binding). Re-provision it in the paybox app, then retry."
+      "This wallet isn't provisioned for signing yet (missing key binding). Re-provision it in the PayBox app, then retry."
     );
   }
   return txs.map((t) => {
@@ -293,11 +378,11 @@ function eip712SigningHash(typedData) {
 }
 function buildX402Envelope(typedData, binding, creds) {
   if (!binding.walletId) {
-    throw new Error("paybox did not supply a wallet id for this payment.");
+    throw new Error("PayBox did not supply a wallet id for this payment.");
   }
   if (!binding.keyId || !binding.derivationPath) {
     throw new Error(
-      "This wallet isn't provisioned for signing yet (missing key binding). Re-provision it in the paybox app, then retry."
+      "This wallet isn't provisioned for signing yet (missing key binding). Re-provision it in the PayBox app, then retry."
     );
   }
   const { signed_body, agent_signature } = buildEnvelope(
@@ -320,19 +405,19 @@ function buildIssuedAtEnvelope(creds) {
 }
 async function signIntent(intent, creds, binding, transport) {
   if (!binding.walletId) {
-    return { ok: false, error: "paybox did not supply a wallet id for this operation." };
+    return { ok: false, error: "PayBox did not supply a wallet id for this operation." };
   }
   if (!binding.keyId || !binding.derivationPath) {
     return {
       ok: false,
-      error: "This wallet isn't provisioned for signing yet (missing key binding). Re-provision it in the paybox app, then retry."
+      error: "This wallet isn't provisioned for signing yet (missing key binding). Re-provision it in the PayBox app, then retry."
     };
   }
   const ecdsaSign = async (digest) => {
     const result = await transport(buildEnvelope(digest, binding, creds));
     const { r, s, recovery_id } = result.signature;
     if (r == null || s == null || recovery_id == null) {
-      throw new Error("MoonX returned an ECDSA result without {r, s, recovery_id}");
+      throw new Error("the signing service returned an ECDSA result without {r, s, recovery_id}");
     }
     return {
       r: `0x${r}`,
@@ -343,7 +428,7 @@ async function signIntent(intent, creds, binding, transport) {
   const ed25519Sign = async (message) => {
     const result = await transport(buildEnvelope(bytesToHex(message), binding, creds));
     const sig = result.signature.signature;
-    if (!sig) throw new Error("MoonX returned an Ed25519 result without a signature");
+    if (!sig) throw new Error("the signing service returned an Ed25519 result without a signature");
     return hexToBytes(sig);
   };
   try {
@@ -412,6 +497,11 @@ async function signIntent(intent, creds, binding, transport) {
 
 // src/signer.ts
 function credsFromToken(token) {
+  if (token.trim().startsWith("pbx_live_")) {
+    throw new Error(
+      "invalid signing key: got a `pbx_live_` API key; expected a `pbxk1.` token (keypair only)"
+    );
+  }
   const kp = parseToken(token);
   if (!kp) {
     throw new Error("invalid signing key: expected a `pbxk1.` token (keypair only)");
@@ -441,16 +531,35 @@ async function signWalletRequest(post, requestId, intent, creds, binding) {
   await post(`/agent/requests/${requestId}/signature`, { artifact: result.artifact });
   return result.artifact;
 }
+function isSolanaRefreshablePlan(plan) {
+  const txs = plan.txs;
+  const solana = txs.some((t) => t.vm === "solana");
+  return solana && txs.some(
+    (t) => t.kind === "swap" || t.kind === "prediction_trade" || t.kind === "jupiter_swap"
+  );
+}
+async function refreshSwapPlan(post, requestId, plan) {
+  const r = await post(`/agent/requests/${requestId}/refresh`, {});
+  if (!r || typeof r.plan !== "object" || r.plan === null) {
+    throw new Error("swap refresh returned no plan");
+  }
+  const refreshed = r.plan;
+  if (!Array.isArray(refreshed.txs) || refreshed.txs.length === 0) {
+    throw new Error("swap refresh returned a plan with no txs");
+  }
+  return refreshed;
+}
 async function signSwapRequest(post, requestId, plan, creds) {
+  const signPlan = isSolanaRefreshablePlan(plan) ? await refreshSwapPlan(post, requestId, plan) : plan;
   let binding = {
-    walletId: plan.binding.wallet_id,
-    keyId: plan.binding.key_id ?? "",
-    derivationPath: plan.binding.derivation_path ?? ""
+    walletId: signPlan.binding.wallet_id,
+    keyId: signPlan.binding.key_id ?? "",
+    derivationPath: signPlan.binding.derivation_path ?? ""
   };
   if (binding.walletId && (!binding.keyId || !binding.derivationPath)) {
     binding = await resolveBinding(post, requestId, creds);
   }
-  const envelopes = buildSwapEnvelopes(plan.txs, binding, creds);
+  const envelopes = buildSwapEnvelopes(signPlan.txs, binding, creds);
   await post(`/agent/requests/${requestId}/envelopes`, { envelopes });
 }
 async function signX402Request(post, requestId, plan, creds) {
@@ -473,6 +582,10 @@ async function signX402Request(post, requestId, plan, creds) {
 // src/client.ts
 var DEFAULT_BASE_URL = "https://api.paybox.sh";
 var EXPIRY_SKEW_MS = 6e4;
+function signingResultForResponse(result, response) {
+  const exposesPlan = response.status === "pending_approval" || response.status === "pending_signature";
+  return { ...result, response, plan: exposesPlan ? result.plan : null };
+}
 var PayboxError = class extends Error {
   constructor(status, body, context) {
     super(`paybox ${context} failed (${status}): ${body}`);
@@ -508,9 +621,17 @@ var PayboxClient = class _PayboxClient {
     }
     return client;
   }
-  /** Whether in-process signing is available (a `pbxk1.` key is configured). */
+  signingCreds() {
+    if (!this.opts.signingKey) return null;
+    try {
+      return credsFromToken(this.opts.signingKey);
+    } catch {
+      return null;
+    }
+  }
+  /** Whether in-process signing is available (a parseable `pbxk1.` key is set). */
   get canSign() {
-    return Boolean(this.opts.signingKey);
+    return this.signingCreds() !== null;
   }
   async bearer() {
     if (this.opts.token) return this.opts.token;
@@ -547,7 +668,8 @@ var PayboxClient = class _PayboxClient {
     return text ? JSON.parse(text) : void 0;
   }
   poster = (path, body) => this.request("POST", path, { body });
-  /** List the credentials this client may use (the `list_credentials` tool). */
+  /** List granted credentials plus the `ungranted` credentials (id, name, kind,
+   *  safe metadata) the user owns but hasn't granted this connector. */
   listCredentials() {
     return this.request("GET", "/agent/grants");
   }
@@ -557,6 +679,16 @@ var PayboxClient = class _PayboxClient {
       query: { address: args.address, network_ids: args.networkIds }
     });
   }
+  /** Verify one confirmed Solana transaction's exact wallet/mint effect, then
+   *  read the current balance at or after its slot (`verify_solana_balance`). */
+  verifySolanaBalance(args) {
+    const body = {
+      address: args.address,
+      token_mint: args.tokenMint,
+      transaction_signature: args.transactionSignature
+    };
+    return this.request("POST", "/agent/portfolio/verify-solana-balance", { body });
+  }
   /** Charge a card credential (the `request_payment` tool). */
   requestPayment(args) {
     const operation = {
@@ -582,122 +714,329 @@ var PayboxClient = class _PayboxClient {
   /** Sign with a wallet credential (the `request_wallet_sign` tool). Signs
    *  in-process and returns the completed request when a signing key is set and
    *  the request clears immediately; otherwise returns the pending response.
-   *  Uses `/agent/wallet-sign`, which echoes the wallet binding so the signer
-   *  need not resolve it separately. */
+   *  Uses `/agent/wallet-sign`, which echoes the wallet binding only while
+   *  approval or signature is pending so the signer need not resolve it
+   *  separately. Terminal responses carry a null binding. */
   async requestWalletSign(args, opts = {}) {
-    const operation = {
-      type: "wallet_sign",
-      credential_id: args.credentialId,
-      intent: args.intent
-    };
-    const { response, binding } = await this.request(
-      "POST",
-      "/agent/wallet-sign",
-      { body: { operation } }
+    return this.withExpiryRetry(
+      async () => {
+        const operation = {
+          type: "wallet_sign",
+          credential_id: args.credentialId,
+          intent: args.intent
+        };
+        const { response, binding } = await this.request(
+          "POST",
+          "/agent/wallet-sign",
+          { body: { operation } }
+        );
+        const creds = this.signingCreds();
+        if ((opts.autoSign ?? true) && response.status === "pending_signature" && creds) {
+          const sign = () => signWalletRequest(this.poster, response.request_id, args.intent, creds, binding);
+          await this.signWithReconcile(response.request_id, sign);
+          return this.getRequest(response.request_id);
+        }
+        return response;
+      },
+      (r) => r
     );
-    if ((opts.autoSign ?? true) && response.status === "pending_signature" && this.opts.signingKey) {
-      await signWalletRequest(
-        this.poster,
-        response.request_id,
-        args.intent,
-        credsFromToken(this.opts.signingKey),
-        binding
-      );
-      return this.getRequest(response.request_id);
-    }
-    return response;
   }
   /** Swap tokens from a wallet credential (the `request_swap` tool). Returns the
-   *  parked response + sign-ready plan; signs + submits in-process when a signing
-   *  key is set and the swap cleared immediately. */
+   *  parked response and its sign-ready plan while approval or signature is
+   *  pending; terminal responses carry a null plan. Signs + submits in-process
+   *  when a signing key is set and the swap cleared immediately. */
   async requestSwap(args, opts = {}) {
-    const operation = {
-      type: "swap",
-      credential_id: args.credentialId,
-      src_chain: args.srcChain,
-      dst_chain: args.dstChain ?? args.srcChain,
-      src_token: args.srcToken,
-      dst_token: args.dstToken,
-      amount: args.amount,
-      swap_direction: args.swapDirection ?? "exact-amount-in",
-      slippage_bps: args.slippageBps ?? 50,
-      recipient: args.recipient ?? null,
-      value_cents: args.valueCents ?? null
-    };
-    const result = await this.request("POST", "/agent/swap", { body: { operation } });
-    if ((opts.autoSign ?? true) && result.response.status === "pending_signature" && this.opts.signingKey) {
-      await signSwapRequest(
-        this.poster,
-        result.response.request_id,
-        result.plan,
-        credsFromToken(this.opts.signingKey)
-      );
-      return { ...result, response: await this.getRequest(result.response.request_id) };
+    return this.withExpiryRetry(
+      async () => {
+        const operation = {
+          type: "swap",
+          credential_id: args.credentialId,
+          src_chain: args.srcChain,
+          dst_chain: args.dstChain ?? args.srcChain,
+          src_token: args.srcToken,
+          dst_token: args.dstToken,
+          amount: args.amount,
+          swap_direction: args.swapDirection ?? "exact-amount-in",
+          // Keep in sync with the request_swap MCP tool default (server side).
+          slippage_bps: args.slippageBps ?? 150,
+          recipient: args.recipient ?? null,
+          value_cents: args.valueCents ?? null
+        };
+        const result = await this.request("POST", "/agent/swap", {
+          body: { operation }
+        });
+        return this.completeSwap(result, opts);
+      },
+      (r) => r.response
+    );
+  }
+  /** Complete a swap request: optionally wait out a `pending_approval` dwell,
+   *  then sign the plan in-process and submit envelopes. Signing first refreshes
+   *  the parked request via `/agent/requests/{id}/refresh`, so a long approval
+   *  dwell never signs stale bytes. */
+  async completeSwap(result, opts) {
+    const creds = this.signingCreds();
+    if (!(opts.autoSign ?? true) || !creds) {
+      return signingResultForResponse(result, result.response);
     }
-    return result;
+    let response = result.response;
+    if (response.status === "pending_approval" && opts.waitForApproval) {
+      response = await this.waitWhileApproval(response.request_id, opts.waitForApproval);
+    }
+    if (response.status !== "pending_signature") {
+      return signingResultForResponse(result, response);
+    }
+    const plan = result.plan;
+    if (!plan) {
+      throw new Error("paybox returned pending_signature without a swap signing plan");
+    }
+    const sign = () => signSwapRequest(this.poster, response.request_id, plan, creds);
+    await this.signWithReconcile(response.request_id, sign);
+    return signingResultForResponse(
+      result,
+      await this.requestAfterSign(response.request_id, opts.waitForApproval)
+    );
+  }
+  /** Poll while the request sits in `pending_approval` (the user is approving
+   *  with their passkey); returns the first non-approval state. */
+  async waitWhileApproval(requestId, wait) {
+    const o = typeof wait === "object" ? wait : {};
+    const interval = o.intervalMs ?? 2e3;
+    const deadline = Date.now() + (o.timeoutMs ?? 3e5);
+    for (; ; ) {
+      const r = await this.getRequest(requestId);
+      if (r.status !== "pending_approval" || Date.now() > deadline) return r;
+      await new Promise((res) => setTimeout(res, interval));
+    }
+  }
+  /** Run an operation and, if it terminates on a server-marked expiry
+   *  (`retryable` on a terminal `error`/`denied`: the window elapsed and nothing
+   *  was signed or spent), re-issue it exactly once (SPE-456). Never loops: the
+   *  second attempt's result is returned as-is. */
+  async withExpiryRetry(run, responseOf) {
+    const first = await run();
+    const r = responseOf(first);
+    if ((r.status === "error" || r.status === "denied") && r.retryable) {
+      return run();
+    }
+    return first;
   }
-  /** Discover paid x402 services from the Bazaar catalog (the `discover_services`
-   *  tool). Pass a query for a ranked search; omit it for the catalog listing. */
-  async discoverServices(query) {
-    const r = await this.request("GET", "/agent/services", {
-      query: { query }
+  /** Sign a parked request; if the sign/submit call fails, reconcile against the
+   *  authoritative state once (SPE-456). The server leaves a pre-broadcast
+   *  completion failure recoverable — the claim is released and the row stays
+   *  `pending_signature` — so re-sign a still-open request a single time; a
+   *  terminal or already-broadcast row is left as-is for the caller to read (and
+   *  for `withExpiryRetry` to re-issue if it is retryable). Bounded to one extra
+   *  attempt: a second failure propagates. */
+  async signWithReconcile(requestId, sign) {
+    try {
+      await sign();
+    } catch {
+      const reconciled = await this.getRequest(requestId);
+      if (reconciled.status !== "pending_signature") return;
+      await sign();
+    }
+  }
+  /** Discover x402 services with the original array-returning response. */
+  async discoverServices(query, opts = {}) {
+    const result = await this.request("GET", "/agent/services", {
+      query: {
+        query,
+        network: opts.network === "all" ? void 0 : opts.network,
+        raw: opts.raw ? "true" : void 0
+      }
+    });
+    return result.services;
+  }
+  /** Discover one bounded page of x402 services. Reuse the returned cursor with
+   * the same query and network while `has_more` is true. */
+  async discoverServicesPage(query, opts = {}) {
+    return this.request("GET", "/agent/services", {
+      query: {
+        query,
+        network: opts.network === "all" ? void 0 : opts.network,
+        limit: (opts.limit ?? 10).toString(),
+        cursor: opts.cursor,
+        raw: opts.raw ? "true" : void 0
+      }
     });
-    return r.services;
   }
   /** Pay a paid x402 endpoint from a wallet credential (the `pay_x402` tool,
    *  header mode). Signs in-process when a signing key is set and the payment
    *  clears immediately — then the X-PAYMENT header is on the completed
    *  response's `output.value.x_payment` (replay it on the original request). */
   async payX402(args, opts = {}) {
-    const result = await this.request("POST", "/agent/x402", {
-      body: {
-        credential_id: args.credentialId,
-        accepts: args.accepts,
-        resource_url: args.resourceUrl
-      }
-    });
-    return this.completeX402(result, opts);
+    return this.withExpiryRetry(
+      async () => {
+        const result = await this.request("POST", "/agent/x402", {
+          body: {
+            credential_id: args.credentialId,
+            accepts: args.accepts,
+            resource_url: args.resourceUrl
+          }
+        });
+        return this.completeX402(result, opts);
+      },
+      (r) => r.response
+    );
   }
   /** Fetch a paid x402 resource and have paybox pay for it (the `use_service`
    *  tool, gateway mode): paybox probes the url, pays the 402, re-fetches with the
    *  payment, and returns the resource's reply on `output.value.response`. */
   async useService(args, opts = {}) {
-    const result = await this.request("POST", "/agent/use-service", {
-      body: {
+    return this.withExpiryRetry(
+      async () => {
+        const result = await this.request("POST", "/agent/use-service", {
+          body: {
+            credential_id: args.credentialId,
+            url: args.url,
+            method: args.method,
+            body: args.body
+          }
+        });
+        return this.completeX402(result, opts);
+      },
+      (r) => r.response
+    );
+  }
+  /** Shared completion for the two x402 entry points: optionally wait out a
+   *  `pending_approval` dwell, then sign the parked typed data in-process and
+   *  return the finished request, exactly like the swap path. */
+  async completeX402(result, opts) {
+    const creds = this.signingCreds();
+    if (!(opts.autoSign ?? true) || !creds) {
+      return signingResultForResponse(result, result.response);
+    }
+    let response = result.response;
+    if (response.status === "pending_approval" && opts.waitForApproval) {
+      response = await this.waitWhileApproval(response.request_id, opts.waitForApproval);
+    }
+    if (response.status !== "pending_signature") {
+      return signingResultForResponse(result, response);
+    }
+    const plan = result.plan;
+    if (!plan) {
+      throw new Error("paybox returned pending_signature without an x402 signing plan");
+    }
+    const sign = () => signX402Request(this.poster, response.request_id, plan, creds);
+    await this.signWithReconcile(response.request_id, sign);
+    return signingResultForResponse(
+      result,
+      await this.requestAfterSign(response.request_id, opts.waitForApproval)
+    );
+  }
+  /** Claim the usable card credentials of an approved payment (the
+   *  `claim_payment_credentials` tool). One-time: the claim is consumed. */
+  claimPaymentCredentials(requestId) {
+    return this.request("POST", `/agent/requests/${requestId}/credentials`);
+  }
+  /** Open the account-change flow (the `request_account_change` tool): returns a
+   *  `manage_url` deep link for the USER to open — they update this client's
+   *  access (or add a credential) in their own passkey-gated app session.
+   *  Nothing is parked or applied server-side. */
+  requestAccountChange(note) {
+    return this.request("POST", "/agent/account-change", { body: { note } });
+  }
+  /** A signed MoonPay checkout URL funding a granted wallet (the `get_buy_link`
+   *  tool). Share the URL with the user; generating it charges nothing. */
+  getBuyLink(args) {
+    return this.request("GET", "/agent/buy-link", {
+      query: {
         credential_id: args.credentialId,
-        url: args.url,
-        method: args.method,
-        body: args.body
+        destination_chain: args.destinationChain,
+        currency_code: args.currencyCode,
+        amount_usd: args.amountUsd?.toString()
       }
     });
-    return this.completeX402(result, opts);
   }
-  /** Shared completion for the two x402 entry points: sign the parked typed data
-   *  in-process (when a key is set + the request cleared) and return the finished
-   *  request, exactly like the swap path. */
-  async completeX402(result, opts) {
-    if ((opts.autoSign ?? true) && result.response.status === "pending_signature" && this.opts.signingKey) {
-      await signX402Request(
-        this.poster,
-        result.response.request_id,
-        result.plan,
-        credsFromToken(this.opts.signingKey)
-      );
-      return { ...result, response: await this.getRequest(result.response.request_id) };
-    }
-    return result;
+  // ---- World REST discovery; money tools require the geofenced MCP window. ----
+  /** Browse World prediction markets (the `world_find_markets` tool). */
+  worldMarkets(args = {}) {
+    return this.request("GET", "/agent/world/markets", {
+      query: {
+        events: args.events ? "true" : void 0,
+        limit: args.limit?.toString(),
+        cursor: args.cursor?.toString(),
+        event_ticker: args.eventTicker,
+        series_ticker: args.seriesTicker,
+        status: args.status
+      }
+    });
+  }
+  /** One World event with its markets (the `world_get_market` tool). Nested
+   *  markets default on, matching the tool — they carry the outcome mint ids
+   *  the orderbook/trade calls need. */
+  worldMarket(eventTicker, withNestedMarkets = true) {
+    return this.request("GET", "/agent/world/market", {
+      query: {
+        event_ticker: eventTicker,
+        // Omit when true (the server default); send only the explicit opt-out.
+        with_nested_markets: withNestedMarkets ? void 0 : "false"
+      }
+    });
+  }
+  /** A World market's orderbook (the `world_orderbook` tool). */
+  worldOrderbook(id, byMint = false) {
+    return this.request("GET", "/agent/world/orderbook", {
+      query: { id, by_mint: byMint ? "true" : void 0 }
+    });
+  }
+  /** A World market's price history (the `world_market_prices` tool). */
+  worldPrices(args) {
+    return this.request("GET", "/agent/world/prices", {
+      query: {
+        ticker: args.ticker,
+        start_ts: args.startTs.toString(),
+        end_ts: args.endTs.toString(),
+        resolution: args.resolution?.toString()
+      }
+    });
+  }
+  /** Filter addresses down to World outcome mints (the
+   *  `world_filter_outcome_mints` tool). */
+  worldFilterOutcomeMints(addresses) {
+    return this.request("POST", "/agent/world/filter-outcome-mints", {
+      body: { addresses }
+    });
+  }
+  /** A wallet's World prediction-market positions: classified `positions` /
+   *  `settled` entries (each with a `position_result`) plus `settlement_cash`
+   *  for a settled winner's CASH cash-out (swap CASH to USDC via request_swap).
+   *  The `world_positions` tool. */
+  worldPositions(address) {
+    return this.request("GET", "/agent/world/positions", { query: { address } });
+  }
+  // ---- Hyperliquid plugin (read-only spot discovery) — requires the user to
+  // have enabled the `hyperliquid` plugin in the paybox app. ----
+  /** Hyperliquid spot markets (the `hyperliquid_markets` tool). */
+  hyperliquidMarkets() {
+    return this.request("GET", "/agent/hyperliquid/markets");
+  }
+  /** Hyperliquid spot prices (the `hyperliquid_prices` tool). */
+  hyperliquidPrices() {
+    return this.request("GET", "/agent/hyperliquid/prices");
+  }
+  /** Resolve one Hyperliquid token by name (the `hyperliquid_token` tool). */
+  hyperliquidToken(name) {
+    return this.request("GET", "/agent/hyperliquid/token", { query: { name } });
   }
   /** Poll a request's status (the `get_request` tool). */
   getRequest(requestId) {
     return this.request("GET", `/agent/requests/${requestId}`);
   }
+  /** After in-process sign, `--wait` polls through settlement/confirmation;
+   *  without it, return the first snapshot (the historical no-wait contract). */
+  requestAfterSign(requestId, wait) {
+    if (!wait) return this.getRequest(requestId);
+    return this.waitForRequest(requestId, typeof wait === "object" ? wait : {});
+  }
   /** Poll until the request leaves a pending state (or the timeout elapses). */
   async waitForRequest(requestId, opts = {}) {
     const interval = opts.intervalMs ?? 2e3;
     const deadline = Date.now() + (opts.timeoutMs ?? 3e5);
     for (; ; ) {
       const r = await this.getRequest(requestId);
-      const pending = r.status === "pending_approval" || r.status === "pending_signature";
+      const pending = r.status === "pending_approval" || r.status === "pending_signature" || r.status === "pending_settlement" || r.status === "pending_confirmation";
       if (!pending || Date.now() > deadline) return r;
       await new Promise((res) => setTimeout(res, interval));
     }
@@ -710,6 +1049,7 @@ export {
   agentClientId,
   openBrowser,
   loginLoopback,
+  loginDevice,
   refreshTokens,
   configDir,
   configFile,
@@ -719,4 +1059,4 @@ export {
   PayboxError,
   PayboxClient
 };
-//# sourceMappingURL=chunk-DIMOTJ2E.js.map
+//# sourceMappingURL=chunk-7VW4QMV4.js.map