@paybox-sh/sdk 0.8.5 → 1.0.0

package/README.md

@@ -4,10 +4,9 @@ Typed Node SDK and `paybox` CLI for the PayBox agent API. It mirrors the MCP too
 surface — `list_credentials`, `request_payment`, `claim_payment_credentials`,
 `request_wallet_sign`, `request_secret`, `request_swap`, `discover_services`,
 `pay_x402`, `use_service`, `get_portfolio`, `get_buy_link`,
-`request_account_change`, `get_request`, and read-only plugin tools (`world_*`,
-`hyperliquid_*`) — but talks to the REST API directly, with no MCP host and no
-signing iframe.
-Geofenced World money tools are MCP-only.
+`request_account_change`, `get_request`, and the generic plugin discovery,
+contract, and invocation flow. Core operations use the REST API; plugins use
+the same MCP tools as connector hosts, with no hardcoded per-plugin paths.
 
 Wallet signing is **non-custodial and runs in-process**: the SDK reuses the exact
 signing core from the wallet-sign iframe (`@paybox/mcp-app`), builds the chain
@@ -24,7 +23,7 @@ npx @paybox-sh/sdk login     # or use the CLI directly
 Driving this CLI from an agent? [`SKILL.md`](SKILL.md) ships in the package and
 describes the install and login flow as an agent skill: what the human has to do
 (approve wallets, paste one signing key), and what the agent should not do
-around it. Use the CLI on **Grok Bot**, **Grok Computer**, and any agent on a
+around it. Use the CLI on **Muse**, **Grok Bot**, **Grok Computer**, and any agent on a
 computer with no connector screen — not the grok.com MCP connector path.
 
 ## CLI
@@ -60,8 +59,9 @@ paybox account-change --note "need a wallet grant"  # manage_url for the user to
 paybox request <request_id> --wait        # poll a pending request
 
 # Plugins (enable them in the paybox app first)
-paybox world markets --status active      # browse prediction markets
-paybox hyperliquid markets                # spot discovery
+paybox plugins list --status enabled
+paybox plugins contract paybox://plugins/world
+paybox plugins use world world_get_events --input '{"status":"active"}'
 
 paybox version                            # installed version (+ update check)
 paybox update                             # update the global install to latest
@@ -77,7 +77,7 @@ its own binary). For project installs use `pnpm up`/`pnpm rm`, or `npx
 @paybox-sh/sdk@latest` to always run the latest without installing.
 
 `sign`, `swap`, `pay-x402`, and `use-service` can complete in-process with a
-configured `pbxk1.` key. World buy/sell/redeem are MCP-only.
+configured `pbxk1.` key. Plugin calls return the raw MCP tool result.
 
 For a Solana `swap` the SDK re-pins a fresh recent blockhash immediately before
 signing (parity with the signing window — the quote-time blockhash expires
@@ -85,7 +85,7 @@ within ~60–90s, often before signing), so a swap that dwells for approval no
 longer broadcasts as `BlockhashNotFound`. EVM swaps are unaffected.
 
 `pay-x402` is header mode — on success `output.value.x_payment` is the `X-PAYMENT`
-header to replay on the original request. `use-service` is gateway mode — paybox
+header to replay on the original request. `use-service` is gateway mode — PayBox
 makes the paid call for you and returns the resource's reply on
 `output.value.response`. Pass `--accepts` from the resource's own 402 (start from
 the curated Bazaar set with `paybox discover`).
@@ -122,6 +122,15 @@ const services = await paybox.discoverServices("weather api");
 const rawServices = await paybox.discoverServices("weather api", { raw: true }); // debug only
 const paid = await paybox.useService({ credentialId: walletId, url: services[0].resource });
 // paid.response.output.value.response holds the resource's reply
+
+const plugins = await paybox.discoverPlugins({ status: "enabled" });
+const selected = plugins.plugins.find((plugin) => plugin.id === "aave");
+const contract = await paybox.getPluginContract(selected!.contract_uri!);
+const result = await paybox.usePlugin({
+  pluginId: contract.contract.id,
+  toolId: contract.contract.tools[0].id,
+  input: {},
+});
 ```
 
 ## Configuration

package/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: PayBox CLI setup
-version: 0.8.8
+version: 0.8.13
 description: >-
   Install and log in to the PayBox CLI (@paybox-sh/sdk) so an agent can pay,
   sign, and hold wallet, card, and secret credentials on the user's behalf. Use
@@ -12,11 +12,11 @@ description: >-
 
 The human and agent guide is `https://docs.paybox.sh` (start at
 getting-started and connect/mcp). This file is only the CLI film. Grok
-(grok.com) and Grok Bots are different hosts; do not treat one as the other.
+(grok.com), Grok Bots, and Muse are different hosts; do not treat one as another.
 
 ## Which host
 
-- **Grok Bot, Grok Computer, or any agent on a computer or VM with no connector
+- **Muse, Grok Bot, Grok Computer, or any agent on a computer or VM with no connector
   screen:** this skill is the path. Install and run `paybox login` on that
   machine. Do not send the user to grok.com/connectors and do not paste the MCP
   URL as setup.
@@ -24,13 +24,65 @@ getting-started and connect/mcp). This file is only the CLI film. Grok
   grok.com/connectors. Do not run this CLI install flow unless they explicitly
   want the CLI on a separate machine.
 
-When the user says "install PayBox" and you are Grok Bot or running on a
+When the user says "install PayBox" and you are Muse, Grok Bot, or running on a
 computer, start here immediately.
 
 The user asks to install PayBox. Two things need them: they approve wallet
 access with a passkey, and they paste one signing key. Everything else is yours,
 and they should not see it happen.
 
+## Muse
+
+On Muse this section wins over Grok Bot phone-app and masked-field rules below.
+Prod is `https://api.paybox.sh` / `https://app.paybox.sh`. Stay quiet until they
+say install PayBox / install paybox / Install Paybox. English. Few words. No
+secret dumps. No invented click paths.
+
+Do not send them to Settings → Connectors → Add custom, or to paste an MCP URL.
+Muse **Manage Connectors** (OpenAI, Anthropic, and the rest) is not where
+PayBox is added. Do not run passkey inside Muse. Muse is a chat host, not a
+Grok Bot computer VM. Do not ask for done, listo, or a screenshot. Do not
+fake ready.
+Never wipe `~/.config/paybox`.
+
+Two chat controls, then Welcome. Muse does **not** open those links the way
+Grok Bot does. Every link you send must tell them to tap it. A bare
+markdown pill with no "tap this" line is a failed take.
+
+1. Run device-code login (`paybox login`, or the PayBox capability Authorize
+   flow if this host already has it). The moment you have
+   `verification_uri_complete` and `user_code`, send **one** message:
+   **Tap [Authorize wallets](verification_uri_complete) on your phone
+   browser.** plus `Code: XXXX-XXXX`. One short extra line only if the
+   PayBox **Capability** screen shows **Authorize**: "Or tap Authorize on
+   Paybox under Capabilities." Never mention Add custom. Phone browser
+   (Safari or Chrome), not the native PayBox app and not inside Muse.
+   You do not open the URL. Poll until OAuth is live. Do not end the
+   turn while polling.
+2. When OAuth is live and the signing key is missing, send **Tap
+   [Provision agent key](https://app.paybox.sh/agent-key?client_id=<cid>)
+   on your phone browser.** Then this exact line: **Muse does not have a
+   secure field for the signing key yet; the team is working on it. For
+   now paste the pbxk1 here and rotate it after.** `cid` is the
+   access-token UUID, never `oauth.clientId`. Muse has no masked field.
+   Write `signingKey` into an isolated config. Never `login --signing-key`
+   on argv. Never echo the key.
+
+Ready only when OAuth or an API key is live **and** `canSign` is true. Then
+Welcome to PayBox with two buttons: **Swap 20 USDC to SOL**, **Pay a Solana
+briefing**. Do the one they tap. Stop when that job is done.
+
+If token exchange fails (`refresh_rejected` / egress): one stop line, "Host
+blocks PayBox token exchange. Install NOT complete." Do not offer Settings →
+Add custom as a workaround. If a PayBox capability with **Authorize** is
+visible, point only there. If MCP is already Connected under Manage your MCP
+servers, use that grant — still no Add custom story.
+
+Install the CLI only when this host still needs device-code:
+`npm install -g @paybox-sh/sdk@latest`, then `paybox --json version` (0.8.5+).
+Fresh `PAYBOX_CONFIG_DIR`. Unset `PAYBOX_API_URL` `PAYBOX_API_KEY`
+`PAYBOX_SIGNING_KEY` `PAYBOX_ACCESS_TOKEN`.
+
 ## Install
 
 ```bash
@@ -90,9 +142,10 @@ Send that link even though the CLI also tries to open a browser. When the CLI
 is not on the user's machine, that local open is useless or invisible, and your
 message is the only way they reach the page.
 
-On a phone, Authorize wallets should open the PayBox app. That is the
-correct path. After they tap Connect CLI, the app opens Generate a signing
-key by itself. Do not tell them to come back to chat first.
+On Grok Bot, Authorize wallets should open the PayBox app. That is the
+correct path there. After they tap Connect CLI, the app opens Generate a
+signing key by itself. Do not tell them to come back to chat first. On Muse
+use the Muse section: phone browser, not the native app, not inside Muse.
 
 Then wait. The poll is the continue signal. Do not ask the user to type `done`,
 confirm, or send a screenshot, and do not end your turn while login is running.
@@ -120,9 +173,12 @@ showing the box does not need that machine.
 The moment **this** login has an agent-key URL (stderr, or `cid` from the oauth
 it just saved), put **Generate Signing Key** in chat as that link plus a
 **masked input** for the `pbxk1.` value, in the same turn. Seconds after they
-finish Authorize wallets, not minutes. That chat link must use the JWT `cid`
-and must open the PayBox app on the first tap, the same way Authorize wallets
-does. Do not `Start-Process`, `open`, `rundll32`, or `xdg-open` the authorize,
+finish Authorize wallets, not minutes. That chat link must use the JWT `cid`.
+On Grok Bot it must open the PayBox app on the first tap, the same way
+Authorize wallets does. On Muse tell them to tap the link, then say Muse does
+not have a secure field for the signing key yet; the team is working
+on it. For now paste the pbxk1 here and rotate it after. There is no
+masked field. The link opens in the phone browser. Do not `Start-Process`, `open`, `rundll32`, or `xdg-open` the authorize,
 connect, or agent-key URL yourself. Write what they give you to login's
 prompt stdin when that prompt is alive. If login is wedged after this oauth
 write, keep the box on screen and merge `signingKey` when the host can write
@@ -153,9 +209,15 @@ rather than continuing, because signing and swaps will fail without it.
 From the install request until `canSign` is `true`, exactly two messages, in
 this order:
 
-1. The **Authorize wallets** link plus the code.
-2. **Generate Signing Key** plus the masked `pbxk1.` field, as soon as
+1. The **Authorize wallets** link plus the code. On Muse, the line says
+   to tap that link on the phone browser. Grok Bot can omit that; it
+   opens the link itself.
+2. **Generate Signing Key** plus the signing-key control, as soon as
    **this** login prints `/agent-key?client_id=` or writes a new `oauth`.
+   Grok Bot: masked `pbxk1.` field. Muse: tell them to tap Provision
+   agent key on the phone browser, then: Muse does not have a secure
+   field for the signing key yet; the team is working on it. For now
+   paste the pbxk1 here and rotate it after.
 
 Nothing else. No "Installing…", "Opening…", "Got it", no CLI version, package
 manager, config path, or request id, and no narration of a retry or fallback. If
@@ -232,24 +294,30 @@ catalog index. There may be tens or thousands.
    app, not a host Settings → Plugins screen. Ask them to turn on what
    they want to use, then say when they are back.
 
-2. Then call `discover_plugins` with `status` `enabled`, no `query`, and
-   a small `limit`. That page is what they have on, not the store. From
+2. Then run `paybox --json plugins list --status enabled --limit 10`. That page
+   is what they have on, not the store. From
    those plugins plus the portfolio, suggest a few concrete next moves
    (about six, not one row per plugin). Use each result's `name` and
    contract. Be specific: amounts, which wallet UUID, which market or
    vault from the contract. Mix two enabled plugins in one suggestion
    when that serves the same goal (for example fund or swap, then put
-   the result to work). If nothing is enabled, skip the suggestion list
-   and stay on the Plugins link.
-
-When they name a plugin or a job, search: `discover_plugins` with `query`
-set to what they asked, `status` `enabled` if they already turned it on,
-then page with `next_cursor` only while the current page has no match.
-Official plugin money uses MCP: `get_contract` with `contract_uri`
-unchanged → `use_plugin` with that contract's `plugin_id`, `tool_id`,
-and `input`. Do not invent a `paybox <plugin>` command; only use CLI
-groups that `paybox --help` already lists. Enabled plugin tools may also
-appear on `tools/list`. Plugin money always pauses for passkey.
+   the result to work). On Muse, Welcome is those two buttons first:
+   **Swap 20 USDC to SOL** on the granted Solana wallet, then **Pay a
+   Solana briefing**. Do not offer 0.001 SOL to USDC. If nothing is
+   enabled, skip the extra plugin list and stay on the Plugins link.
+
+When they name a plugin or a job, search with `paybox --json plugins list
+<query> --status enabled`, then page with `--cursor <next_cursor>` only while
+the current page has no match. For an official plugin, run `paybox --json
+plugins contract <contract_uri>` with the URI unchanged, then `paybox --json
+plugins use <plugin_id> <tool_id> --input <json>` with input matching that
+contract. Unofficial discovery results already contain their tool schemas;
+reuse `--invocation-id` only to retrieve the exact same ambiguous call. Plugin
+money always pauses for passkey.
+
+There are no per-plugin commands. `paybox world …` and `paybox hyperliquid …`
+were removed in 1.0.0; reach World and Hyperliquid through `paybox plugins`
+like every other plugin.
 
 If prod MCP (`https://api.paybox.sh/mcp`) is `unreachable` or `needsAuth` while
 `paybox --json whoami` still works, say that. Do not send the human to Settings.
@@ -272,3 +340,9 @@ Do not switch to staging. Do not report the dollar as sent.
   got its own window).
 - Setup chat contained anything besides those two messages.
 - A token, API key, or `pbxk1.` value reached the transcript.
+- On Muse you sent Settings → Connectors → Add custom, or Manage Connectors.
+- On Muse you opened passkey inside Muse.
+- On Muse Authorize wallets opened in the PayBox app or inside Muse.
+- On Muse you sent a link without telling them to tap it.
+- On Muse you faked ready before `canSign` was true.
+- On Muse token exchange failed and you invented an MCP Add custom path.

package/dist/{chunk-WRPYONXW.js → chunk-SMPW2GUM.js}

@@ -133,7 +133,7 @@ async function loginDevice(baseUrl, opts = {}) {
   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`"
+      "this PayBox API does not advertise device_authorization_endpoint \u2014 upgrade the API and retry `paybox login`"
     );
   }
   const resource = mcpResource(baseUrl);
@@ -301,18 +301,52 @@ import { Buffer as Buffer2 } from "buffer";
 import nacl from "tweetnacl";
 import { MoonXEvmSigner, EvmSchemeMismatchError } from "@moon-x/evm-adapter";
 import { MoonXSolanaSigner, SolanaSchemeMismatchError } from "@moon-x/solana-adapter";
-import { Transaction } from "@solana/web3.js";
+import { Transaction, VersionedTransaction } from "@solana/web3.js";
 import { hashTypedData, keccak256, serializeTransaction } from "viem";
+function parseWireU128(value, field) {
+  if (value === void 0 || value === null) {
+    throw new Error(`transaction is missing ${field}`);
+  }
+  if (typeof value === "bigint") {
+    if (value < 0n) {
+      throw new Error(`transaction field ${field} must be a non-negative integer`);
+    }
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value) || value < 0) {
+      throw new Error(`transaction field ${field} must be a non-negative integer`);
+    }
+    return BigInt(value);
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      throw new Error(`transaction field ${field} is empty`);
+    }
+    if (/^0[xX][0-9a-fA-F]+$/.test(trimmed)) {
+      return BigInt(trimmed);
+    }
+    if (!/^\d+$/.test(trimmed)) {
+      throw new Error(`transaction field ${field} is not a valid integer`);
+    }
+    return BigInt(trimmed);
+  }
+  throw new Error(`transaction field ${field} has an invalid type`);
+}
 function reviveTx(w) {
+  if (typeof w !== "object" || w === null || Array.isArray(w)) {
+    throw new Error("transaction must be an object, not a JSON-encoded string");
+  }
   return {
     type: "eip1559",
     to: w.to,
-    value: BigInt(w.value),
+    value: parseWireU128(w.value ?? "0", "value"),
     data: w.data,
     chainId: w.chainId,
-    gas: BigInt(w.gas),
-    maxPriorityFeePerGas: BigInt(w.maxPriorityFeePerGas),
-    maxFeePerGas: BigInt(w.maxFeePerGas),
+    gas: parseWireU128(w.gas, "gas"),
+    maxPriorityFeePerGas: parseWireU128(w.maxPriorityFeePerGas, "maxPriorityFeePerGas"),
+    maxFeePerGas: parseWireU128(w.maxFeePerGas, "maxFeePerGas"),
     nonce: w.nonce
   };
 }
@@ -356,6 +390,14 @@ function solanaSigningPayload(base64Tx) {
   }
   return bytesToHex(new Uint8Array(raw.subarray(i + sigCount * 64)));
 }
+function deserializeSolanaTx(base64Tx) {
+  const raw = Buffer2.from(base64Tx, "base64");
+  try {
+    return Transaction.from(raw);
+  } catch {
+    return VersionedTransaction.deserialize(new Uint8Array(raw));
+  }
+}
 function buildSwapEnvelopes(txs, binding, creds) {
   if (!binding.walletId) {
     throw new Error("PayBox did not supply a wallet id for this operation.");
@@ -484,7 +526,7 @@ async function signIntent(intent, creds, binding, transport) {
         return { ok: true, artifact: { signature: bytesToHex(sig) } };
       }
       case "solanaTransaction": {
-        const tx = Transaction.from(Buffer2.from(intent.transactionBase64, "base64"));
+        const tx = deserializeSolanaTx(intent.transactionBase64);
         const signed = await new MoonXSolanaSigner(ed25519Sign, intent.address).signTransaction(
           tx
         );
@@ -607,6 +649,100 @@ async function signX402Request(post, requestId, plan, creds) {
   await post(`/agent/requests/${requestId}/envelopes`, { envelopes: [envelope] });
 }
 
+// src/mcp.ts
+var PROTOCOL_VERSION = "2025-06-18";
+function responseBody(text) {
+  const events = text.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim());
+  return events.length === 0 ? text : events.join("");
+}
+function errorText(result) {
+  return result.content.filter((item) => item.type === "text" && typeof item.text === "string").map((item) => item.text).join("\n");
+}
+function toolJson(tool, result) {
+  if (result.isError) {
+    throw new Error(errorText(result) || `paybox ${tool} failed`);
+  }
+  const text = result.content.find(
+    (item) => item.type === "text" && typeof item.text === "string"
+  )?.text;
+  if (typeof text !== "string") {
+    throw new Error(`paybox ${tool} returned no JSON content`);
+  }
+  return JSON.parse(text);
+}
+var McpTransport = class {
+  endpoint;
+  bearer;
+  fetchImpl;
+  nextId = 0;
+  initialization;
+  constructor(options) {
+    this.endpoint = `${options.baseUrl}/mcp`;
+    this.bearer = options.bearer;
+    this.fetchImpl = options.fetchImpl;
+  }
+  async callTool(name, args) {
+    await this.initialize();
+    return this.rpc("tools/call", { name, arguments: args });
+  }
+  async initialize() {
+    this.initialization ??= this.rpc("initialize", {
+      protocolVersion: PROTOCOL_VERSION,
+      capabilities: {},
+      clientInfo: { name: "paybox-sdk", version: "1" }
+    }).then(() => this.notify("notifications/initialized", {}));
+    try {
+      await this.initialization;
+    } catch (error) {
+      this.initialization = void 0;
+      throw error;
+    }
+  }
+  async post(payload, method) {
+    const response = await this.fetchImpl(this.endpoint, {
+      method: "POST",
+      headers: {
+        accept: "application/json, text/event-stream",
+        authorization: `Bearer ${await this.bearer()}`,
+        "content-type": "application/json",
+        "mcp-protocol-version": PROTOCOL_VERSION
+      },
+      body: JSON.stringify(payload)
+    });
+    const text = await response.text();
+    if (!response.ok) {
+      throw new Error(
+        `paybox MCP ${method} failed (${response.status}): ${text}`
+      );
+    }
+    return text;
+  }
+  async notify(method, params) {
+    await this.post({ jsonrpc: "2.0", method, params }, method);
+  }
+  async rpc(method, params) {
+    const text = await this.post(
+      {
+        jsonrpc: "2.0",
+        id: ++this.nextId,
+        method,
+        params
+      },
+      method
+    );
+    const parsed = JSON.parse(responseBody(text));
+    if (parsed.error) {
+      throw new Error(
+        `paybox MCP ${method} failed (${parsed.error.code}): ${parsed.error.message}`
+      );
+    }
+    if (parsed.result === void 0) {
+      throw new Error(`paybox MCP ${method} returned no result`);
+    }
+    return parsed.result;
+  }
+};
+
 // src/client.ts
 var DEFAULT_BASE_URL = "https://api.paybox.sh";
 var EXPIRY_SKEW_MS = 6e4;
@@ -631,10 +767,16 @@ var PayboxClient = class _PayboxClient {
   fetchImpl;
   oauth;
   configBacked = false;
+  mcp;
   constructor(options = {}) {
     this.opts = options;
     this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
     this.fetchImpl = options.fetchImpl ?? fetch;
+    this.mcp = new McpTransport({
+      baseUrl: this.baseUrl,
+      bearer: () => this.bearer(),
+      fetchImpl: this.fetchImpl
+    });
   }
   static fromConfig(overrides = {}) {
     const cfg = loadConfig();
@@ -852,6 +994,32 @@ var PayboxClient = class _PayboxClient {
       }
     });
   }
+  async discoverPlugins(args = {}) {
+    return toolJson(
+      "discover_plugins",
+      await this.mcp.callTool("discover_plugins", {
+        query: args.query,
+        source: args.source,
+        status: args.status,
+        limit: args.limit,
+        cursor: args.cursor
+      })
+    );
+  }
+  async getPluginContract(contractUri) {
+    return toolJson(
+      "get_contract",
+      await this.mcp.callTool("get_contract", { contract_uri: contractUri })
+    );
+  }
+  usePlugin(args) {
+    return this.mcp.callTool("use_plugin", {
+      plugin_id: args.pluginId,
+      tool_id: args.toolId,
+      input: args.input,
+      invocation_id: args.invocationId
+    });
+  }
   async payX402(args, opts = {}) {
     return this.withExpiryRetry(
       async () => {
@@ -922,58 +1090,6 @@ var PayboxClient = class _PayboxClient {
       }
     });
   }
-  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
-      }
-    });
-  }
-  worldMarket(eventTicker, withNestedMarkets = true) {
-    return this.request("GET", "/agent/world/market", {
-      query: {
-        event_ticker: eventTicker,
-        with_nested_markets: withNestedMarkets ? void 0 : "false"
-      }
-    });
-  }
-  worldOrderbook(id, byMint = false) {
-    return this.request("GET", "/agent/world/orderbook", {
-      query: { id, by_mint: byMint ? "true" : void 0 }
-    });
-  }
-  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()
-      }
-    });
-  }
-  worldFilterOutcomeMints(addresses) {
-    return this.request("POST", "/agent/world/filter-outcome-mints", {
-      body: { addresses }
-    });
-  }
-  worldPositions(address) {
-    return this.request("GET", "/agent/world/positions", { query: { address } });
-  }
-  hyperliquidMarkets() {
-    return this.request("GET", "/agent/hyperliquid/markets");
-  }
-  hyperliquidPrices() {
-    return this.request("GET", "/agent/hyperliquid/prices");
-  }
-  hyperliquidToken(name) {
-    return this.request("GET", "/agent/hyperliquid/token", { query: { name } });
-  }
   getRequest(requestId) {
     return this.request("GET", `/agent/requests/${requestId}`);
   }
@@ -1010,4 +1126,4 @@ export {
   PayboxError,
   PayboxClient
 };
-//# sourceMappingURL=chunk-WRPYONXW.js.map
+//# sourceMappingURL=chunk-SMPW2GUM.js.map