@paybox-sh/sdk 0.7.0 → 0.8.0

package/dist/{chunk-EBB4HNOB.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";
@@ -275,11 +360,11 @@ function solanaSigningPayload(base64Tx) {
 }
 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)");
@@ -444,7 +534,9 @@ async function signWalletRequest(post, requestId, intent, creds, binding) {
 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");
+  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`, {});
@@ -490,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}`);
@@ -525,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;
@@ -564,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");
   }
@@ -574,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 = {
@@ -599,72 +714,88 @@ 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 } });
-    return this.completeSwap(result, opts);
-  }
-  /** Shared completion for swap-shaped requests (`request_swap` and the World
-   *  trade): optionally wait out a `pending_approval` dwell, then sign the plan
-   *  in-process and submit envelopes. Signing re-pins a Solana plan's blockhash
-   *  (and re-quotes a stale World order) via `/agent/requests/{id}/refresh`
-   *  first, so a long approval dwell never signs stale bytes. */
+    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) {
-    if (!(opts.autoSign ?? true) || !this.opts.signingKey) return result;
+    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 { ...result, response };
+      return signingResultForResponse(result, response);
+    }
+    const plan = result.plan;
+    if (!plan) {
+      throw new Error("paybox returned pending_signature without a swap signing plan");
     }
-    await signSwapRequest(
-      this.poster,
-      response.request_id,
-      result.plan,
-      credsFromToken(this.opts.signingKey)
+    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)
     );
-    return { ...result, response: await this.getRequest(response.request_id) };
   }
   /** Poll while the request sits in `pending_approval` (the user is approving
    *  with their passkey); returns the first non-approval state. */
@@ -678,63 +809,121 @@ var PayboxClient = class _PayboxClient {
       await new Promise((res) => setTimeout(res, interval));
     }
   }
-  /** Discover curated paid x402 services from the Bazaar catalog (the
-   *  `discover_services` tool). Pass a query to search the curated set; omit it
-   *  for the curated listing. Set `raw` only to inspect uncurated compact
-   *  Bazaar service summaries. */
+  /** 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;
+  }
+  /** 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 r = await this.request("GET", "/agent/services", {
-      query: { query, raw: opts.raw ? "true" : void 0 }
+    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: {
-        credential_id: args.credentialId,
-        url: args.url,
-        method: args.method,
-        body: args.body
-      }
-    });
-    return this.completeX402(result, opts);
+    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) {
-    if (!(opts.autoSign ?? true) || !this.opts.signingKey) return result;
+    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 { ...result, response };
+      return signingResultForResponse(result, response);
     }
-    await signX402Request(
-      this.poster,
-      response.request_id,
-      result.plan,
-      credsFromToken(this.opts.signingKey)
+    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)
     );
-    return { ...result, response: await this.getRequest(response.request_id) };
   }
   /** Claim the usable card credentials of an approved payment (the
    *  `claim_payment_credentials` tool). One-time: the claim is consumed. */
@@ -754,15 +943,13 @@ var PayboxClient = class _PayboxClient {
     return this.request("GET", "/agent/buy-link", {
       query: {
         credential_id: args.credentialId,
+        destination_chain: args.destinationChain,
         currency_code: args.currencyCode,
         amount_usd: args.amountUsd?.toString()
       }
     });
   }
-  // ---- World plugin (prediction markets) — requires the user to have enabled
-  // the `world` plugin in the paybox app. Reads are discovery-only; `worldTrade`
-  // parks a force-approved PredictionTrade the SDK signs in-process after the
-  // user approves (pass `waitForApproval` to wait + sign headlessly). ----
+  // ---- 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", {
@@ -812,28 +999,13 @@ var PayboxClient = class _PayboxClient {
       body: { addresses }
     });
   }
-  /** Solana token positions for an address (the `world_positions` tool). */
+  /** 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 } });
   }
-  /** Trade a World prediction market (the `world_buy_outcome` /
-   *  `world_change_position` / `world_redeem` tools). Always parks as
-   *  `pending_approval` (trades are force-approved); pass
-   *  `{ waitForApproval: true }` to wait for the user's passkey approval and
-   *  sign in-process. */
-  async worldTrade(args, opts = {}) {
-    const result = await this.request("POST", "/agent/world/trade", {
-      body: {
-        credential_id: args.credentialId,
-        market_mint: args.marketMint,
-        side: args.side,
-        size: args.size,
-        slippage_bps: args.slippageBps,
-        value_cents: args.valueCents
-      }
-    });
-    return this.completeSwap(result, opts);
-  }
   // ---- 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). */
@@ -852,6 +1024,12 @@ var PayboxClient = class _PayboxClient {
   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;
@@ -871,6 +1049,7 @@ export {
   agentClientId,
   openBrowser,
   loginLoopback,
+  loginDevice,
   refreshTokens,
   configDir,
   configFile,
@@ -880,4 +1059,4 @@ export {
   PayboxError,
   PayboxClient
 };
-//# sourceMappingURL=chunk-EBB4HNOB.js.map
+//# sourceMappingURL=chunk-7VW4QMV4.js.map