@candledottv/cli 0.11.13 → 0.11.15

package/dist/index.js

@@ -6210,6 +6210,55 @@ function serializeSignedTransaction(message, signature) {
 function toBase642(bytes) {
   return Buffer.from(bytes).toString("base64");
 }
+function sanitizeDiagnostic(text, keep) {
+  const clean2 = text.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").replace(/https?:\/\/\S+/gi, "<url>").replace(/(api[-_]?key|token|auth)=\S+/gi, "$1=<redacted>");
+  return clean2.length > keep ? `${clean2.slice(0, keep)}…` : clean2;
+}
+function sanitizeSimulation(message, data) {
+  let err = null;
+  if (data.err !== undefined && data.err !== null) {
+    let encoded;
+    try {
+      encoded = JSON.stringify(data.err);
+    } catch {
+      encoded = "unrepresentable";
+    }
+    err = encoded === undefined ? null : sanitizeDiagnostic(encoded, DIAGNOSTIC_ERR_CHARS - 1);
+  }
+  const lines = Array.isArray(data.logs) ? data.logs.filter((line) => typeof line === "string") : [];
+  const kept = lines.slice(-DIAGNOSTIC_LOG_LINES);
+  return {
+    message: sanitizeDiagnostic(typeof message === "string" ? message : "", DIAGNOSTIC_MESSAGE_CHARS - 1),
+    err,
+    logs: kept.map((line) => sanitizeDiagnostic(line, DIAGNOSTIC_LOG_LINE_CHARS)),
+    logsOmitted: lines.length - kept.length,
+    ...Number.isSafeInteger(data.unitsConsumed) ? { unitsConsumed: data.unitsConsumed } : {}
+  };
+}
+function definiteSendRejection(error) {
+  if (!(error instanceof SolanaRpcError))
+    return null;
+  if (error.method !== "sendTransaction")
+    return null;
+  if (error.status !== undefined)
+    return null;
+  if (error.responseIdMatched !== true)
+    return null;
+  if (error.rateLimited)
+    return null;
+  if (error.rpcCode === RPC_PREFLIGHT_FAILED_CODE && error.simulation !== undefined && error.simulation.err !== null) {
+    return { reason: "preflight-failed", rpcCode: RPC_PREFLIGHT_FAILED_CODE, diagnostics: error.simulation };
+  }
+  if (error.rpcCode === RPC_MIN_CONTEXT_SLOT_CODE && error.contextSlot !== undefined) {
+    return {
+      reason: "context-behind",
+      rpcCode: RPC_MIN_CONTEXT_SLOT_CODE,
+      diagnostics: null,
+      contextSlot: error.contextSlot
+    };
+  }
+  return null;
+}
 function rpcRetryDelayMs(error) {
   return Math.min(error.retryAfterMs ?? RPC_RETRY_DEFAULT_MS, RPC_RETRY_CAP_MS);
 }
@@ -6273,16 +6322,56 @@ function createSolanaRpc(url, fetchFn, sleep) {
       return await once(method, params, signal);
     }
   }
+  async function read(method, params, opts, answersContext = true) {
+    const required = opts?.minContextSlot;
+    if (required === undefined) {
+      const result = await call(method, params);
+      const slot = answersContext ? contextSlotOf(result) : undefined;
+      if (slot !== undefined)
+        opts?.onContext?.(slot);
+      return result;
+    }
+    let observed;
+    for (let attempt = 0;; attempt += 1) {
+      let slot;
+      try {
+        const result = await call(method, params);
+        if (!answersContext)
+          return result;
+        slot = contextSlotOf(result);
+        if (slot === undefined) {
+          throw new SolanaRpcError(`RPC ${method} answered without a context slot, so minimum context slot ${required} cannot be verified`, { method, contextUnverified: true });
+        }
+        if (slot >= required) {
+          opts?.onContext?.(slot);
+          return result;
+        }
+      } catch (error) {
+        if (!(error instanceof SolanaRpcError) || error.rpcCode !== RPC_MIN_CONTEXT_SLOT_CODE)
+          throw error;
+        slot = error.contextSlot;
+      }
+      if (slot !== undefined)
+        observed = observed === undefined ? slot : Math.max(observed, slot);
+      const wait = RPC_CONTEXT_BEHIND_SLEEPS_MS[attempt];
+      if (wait === undefined) {
+        throw new SolanaRpcError(`RPC ${method} failed: the node is behind minimum context slot ${required} (observed ${observed ?? "unknown"})`, { method, contextBehind: { required, observed } });
+      }
+      await sleep(wait);
+    }
+  }
   async function once(method, params, signal) {
     id += 1;
+    const requestId = id;
     const res = await fetchFn(url, {
       method: "POST",
       headers: { "content-type": "application/json" },
-      body: JSON.stringify({ jsonrpc: "2.0", id, method, params }),
+      body: JSON.stringify({ jsonrpc: "2.0", id: requestId, method, params }),
       ...signal !== undefined ? { signal } : {}
     });
     if (!res.ok) {
       throw new SolanaRpcError(`RPC ${method} failed: HTTP ${res.status}`, {
+        method,
         status: res.status,
         ...res.status === 429 ? (() => {
           const after = retryAfterMs(res.headers.get("retry-after"), Date.now());
@@ -6292,23 +6381,31 @@ function createSolanaRpc(url, fetchFn, sleep) {
     }
     const json = await res.json();
     if (json.error) {
+      const code = json.error.code;
+      const data = json.error.data;
+      const dataObject = data !== null && typeof data === "object" && !Array.isArray(data) ? data : undefined;
+      const contextSlot = dataObject?.contextSlot;
       throw new SolanaRpcError(`RPC ${method} failed: ${json.error.code ?? ""} ${json.error.message ?? ""}`.trim(), {
-        ...typeof json.error.code === "number" ? { rpcCode: json.error.code } : {}
+        ...typeof code === "number" ? { rpcCode: code } : {},
+        method,
+        responseIdMatched: json.id === requestId,
+        ...code === RPC_PREFLIGHT_FAILED_CODE && dataObject ? { simulation: sanitizeSimulation(json.error.message, dataObject) } : {},
+        ...code === RPC_MIN_CONTEXT_SLOT_CODE && Number.isSafeInteger(contextSlot) ? { contextSlot } : {}
       });
     }
     return json.result;
   }
   return {
-    async getLatestBlockhash() {
-      const r = await call("getLatestBlockhash", [{ commitment: "finalized" }]);
+    async getLatestBlockhash(opts) {
+      const r = await read("getLatestBlockhash", [withMinContextSlot({ commitment: "finalized" }, opts)], opts);
       return r.value.blockhash;
     },
-    async getBalance(address) {
-      const r = await call("getBalance", [address, { commitment: "finalized" }]);
+    async getBalance(address, opts) {
+      const r = await read("getBalance", [address, withMinContextSlot({ commitment: "finalized" }, opts)], opts);
       return BigInt(r.value);
     },
-    async getTokenAccountsByOwner(owner, programId) {
-      const r = await call("getTokenAccountsByOwner", [owner, { programId }, { encoding: "jsonParsed", commitment: "finalized" }]);
+    async getTokenAccountsByOwner(owner, programId, opts) {
+      const r = await read("getTokenAccountsByOwner", [owner, { programId }, withMinContextSlot({ encoding: "jsonParsed", commitment: "finalized" }, opts)], opts);
       return r.value.map((v) => ({
         pubkey: v.pubkey,
         mint: v.account.data.parsed.info.mint,
@@ -6318,8 +6415,8 @@ function createSolanaRpc(url, fetchFn, sleep) {
         programId
       }));
     },
-    async getFeeForMessage(messageBase64) {
-      const r = await call("getFeeForMessage", [messageBase64, { commitment: "finalized" }]);
+    async getFeeForMessage(messageBase64, opts) {
+      const r = await read("getFeeForMessage", [messageBase64, withMinContextSlot({ commitment: "finalized" }, opts)], opts);
       return r.value === null ? null : BigInt(r.value);
     },
     async getMinimumBalanceForRentExemption(size) {
@@ -6328,8 +6425,8 @@ function createSolanaRpc(url, fetchFn, sleep) {
         throw new Error("Invalid rent exemption quote");
       return BigInt(rent);
     },
-    async getAccountInfo(address) {
-      const r = await call("getAccountInfo", [address, { encoding: "base64", commitment: "finalized" }]);
+    async getAccountInfo(address, opts) {
+      const r = await read("getAccountInfo", [address, withMinContextSlot({ encoding: "base64", commitment: "finalized" }, opts)], opts);
       const value = r.value;
       if (!value)
         return null;
@@ -6344,20 +6441,17 @@ function createSolanaRpc(url, fetchFn, sleep) {
         data: new Uint8Array(Buffer.from(encoded, "base64"))
       };
     },
-    async getEpoch() {
-      const r = await call("getEpochInfo", [{ commitment: "finalized" }]);
+    async getEpoch(opts) {
+      const r = await read("getEpochInfo", [withMinContextSlot({ commitment: "finalized" }, opts)], opts, false);
       if (!Number.isSafeInteger(r?.epoch))
         throw new Error("RPC getEpochInfo answered without an epoch");
       return BigInt(r.epoch);
     },
-    async getMultipleAccounts(addresses) {
+    async getMultipleAccounts(addresses, opts) {
       const out = [];
       for (let at = 0;at < addresses.length; at += 100) {
         const chunk = addresses.slice(at, at + 100);
-        const r = await call("getMultipleAccounts", [
-          chunk,
-          { encoding: "base64", commitment: "finalized" }
-        ]);
+        const r = await read("getMultipleAccounts", [chunk, withMinContextSlot({ encoding: "base64", commitment: "finalized" }, opts)], opts);
         if (!Array.isArray(r?.value) || r.value.length !== chunk.length) {
           throw new Error("RPC getMultipleAccounts answered with the wrong number of accounts");
         }
@@ -6366,17 +6460,17 @@ function createSolanaRpc(url, fetchFn, sleep) {
       }
       return out;
     },
-    async simulateTransaction(txBase64, addresses) {
-      const r = await call("simulateTransaction", [
+    async simulateTransaction(txBase64, addresses, opts) {
+      const r = await read("simulateTransaction", [
         txBase64,
-        {
+        withMinContextSlot({
           sigVerify: false,
           replaceRecentBlockhash: true,
           commitment: "finalized",
           encoding: "base64",
           accounts: { encoding: "base64", addresses }
-        }
-      ]);
+        }, opts)
+      ], opts);
       const value = r?.value;
       if (!value || typeof value !== "object")
         throw new Error("RPC simulateTransaction answered without a value");
@@ -6400,22 +6494,26 @@ function createSolanaRpc(url, fetchFn, sleep) {
         throw new SolanaRpcError("RPC getTokenSupply answered without a value");
       return { decimals: r.value.decimals };
     },
-    async sendTransaction(txBase64) {
+    async sendTransaction(txBase64, opts) {
       return await call("sendTransaction", [
         txBase64,
-        { encoding: "base64", skipPreflight: false, preflightCommitment: "finalized", maxRetries: 3 }
+        withMinContextSlot({ encoding: "base64", skipPreflight: false, preflightCommitment: "finalized", maxRetries: 3 }, opts)
       ]);
     },
     async getSignatureStatus(signature) {
       const r = await call("getSignatureStatuses", [[signature], { searchTransactionHistory: true }]);
-      return r.value[0] ?? null;
+      const status = r.value[0] ?? null;
+      if (status === null)
+        return null;
+      const { slot, ...rest } = status;
+      return Number.isSafeInteger(slot) ? { ...rest, slot } : rest;
     },
     async hasSignatureHistory(address) {
       const r = await call("getSignaturesForAddress", [address, { limit: 1 }]);
       return Array.isArray(r) && r.length > 0;
     },
-    async isBlockhashValid(blockhash, commitment = "finalized") {
-      const r = await call("isBlockhashValid", [blockhash, { commitment }]);
+    async isBlockhashValid(blockhash, commitment = "finalized", opts) {
+      const r = await read("isBlockhashValid", [blockhash, withMinContextSlot({ commitment }, opts)], opts);
       if (typeof r?.value !== "boolean")
         throw new Error("isBlockhashValid answered with a non-boolean value");
       return r.value;
@@ -6463,7 +6561,73 @@ function createSolanaRpc(url, fetchFn, sleep) {
     }
   };
 }
-var SYSTEM_PROGRAM_ID = "11111111111111111111111111111111", TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", TOKEN_2022_PROGRAM_ID = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb", ASSOCIATED_TOKEN_PROGRAM_ID = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL", PDA_MARKER, PROGRAM_ACCOUNTS_V2_LIMIT = 1000, SolanaRpcError, RPC_RATE_LIMIT_CODE = -32429, RPC_RETRY_DEFAULT_MS = 2000, RPC_RETRY_CAP_MS = 1e4, NEVER_RETRIED;
+function withMinContextSlot(config, opts) {
+  return opts?.minContextSlot === undefined ? config : { ...config, minContextSlot: opts.minContextSlot };
+}
+function contextSlotOf(result) {
+  const context = result !== null && typeof result === "object" ? result.context : undefined;
+  const slot = context !== null && typeof context === "object" ? context.slot : undefined;
+  return Number.isSafeInteger(slot) ? slot : undefined;
+}
+function createContextFloor(seed) {
+  let slot;
+  const floor = {
+    get slot() {
+      return slot;
+    },
+    raise(observed) {
+      if (!Number.isSafeInteger(observed) || observed < 0)
+        return;
+      if (slot === undefined || observed > slot)
+        slot = observed;
+    }
+  };
+  if (seed !== undefined)
+    floor.raise(seed);
+  return floor;
+}
+function withContextFloor(rpc, floor) {
+  const required = (opts) => {
+    const own = opts?.minContextSlot;
+    return {
+      get minContextSlot() {
+        return floor.slot === undefined ? own : own === undefined ? floor.slot : Math.max(floor.slot, own);
+      },
+      ...opts?.onContext !== undefined ? { onContext: opts.onContext } : {}
+    };
+  };
+  const finalized = (opts) => {
+    const base = required(opts);
+    return {
+      get minContextSlot() {
+        return base.minContextSlot;
+      },
+      onContext: (slot) => {
+        floor.raise(slot);
+        opts?.onContext?.(slot);
+      }
+    };
+  };
+  return {
+    getLatestBlockhash: (opts) => rpc.getLatestBlockhash(finalized(opts)),
+    getBalance: (address, opts) => rpc.getBalance(address, finalized(opts)),
+    getTokenAccountsByOwner: (owner, programId, opts) => rpc.getTokenAccountsByOwner(owner, programId, finalized(opts)),
+    getAccountInfo: (address, opts) => rpc.getAccountInfo(address, finalized(opts)),
+    getEpoch: (opts) => rpc.getEpoch(finalized(opts)),
+    getMultipleAccounts: (addresses, opts) => rpc.getMultipleAccounts(addresses, finalized(opts)),
+    simulateTransaction: (txBase64, addresses, opts) => rpc.simulateTransaction(txBase64, addresses, finalized(opts)),
+    getFeeForMessage: (messageBase64, opts) => rpc.getFeeForMessage(messageBase64, finalized(opts)),
+    sendTransaction: (txBase64, opts) => rpc.sendTransaction(txBase64, required(opts)),
+    isBlockhashValid: (blockhash, commitment, opts) => rpc.isBlockhashValid(blockhash, commitment, commitment === undefined || commitment === "finalized" ? finalized(opts) : required(opts)),
+    getSignatureStatus: (signature) => rpc.getSignatureStatus(signature),
+    getMinimumBalanceForRentExemption: (size) => rpc.getMinimumBalanceForRentExemption(size),
+    getTokenSupply: (mint) => rpc.getTokenSupply(mint),
+    hasSignatureHistory: (address) => rpc.hasSignatureHistory(address),
+    getProgramAccounts: (...args) => Reflect.apply(rpc.getProgramAccounts, rpc, args),
+    getProgramAccountsV2: (...args) => Reflect.apply(rpc.getProgramAccountsV2, rpc, args)
+  };
+}
+var SYSTEM_PROGRAM_ID = "11111111111111111111111111111111", TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", TOKEN_2022_PROGRAM_ID = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb", ASSOCIATED_TOKEN_PROGRAM_ID = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL", PDA_MARKER, PROGRAM_ACCOUNTS_V2_LIMIT = 1000, SolanaRpcError, RPC_PREFLIGHT_FAILED_CODE = -32002, RPC_MIN_CONTEXT_SLOT_CODE = -32016, RPC_CONTEXT_BEHIND_SLEEPS_MS, DIAGNOSTIC_LOG_LINES = 20, DIAGNOSTIC_LOG_LINE_CHARS = 240, DIAGNOSTIC_MESSAGE_CHARS = 300, DIAGNOSTIC_ERR_CHARS = 512, RPC_RATE_LIMIT_CODE = -32429, RPC_RETRY_DEFAULT_MS = 2000, RPC_RETRY_CAP_MS = 1e4, NEVER_RETRIED;
 var init_solana_lite = __esm(() => {
   init_ed25519();
   init_sha256();
@@ -6474,6 +6638,12 @@ var init_solana_lite = __esm(() => {
     retryAfterMs;
     rpcCode;
     rateLimited;
+    method;
+    responseIdMatched;
+    simulation;
+    contextSlot;
+    contextBehind;
+    contextUnverified;
     constructor(message, facts = {}) {
       super(message);
       this.name = "SolanaRpcError";
@@ -6481,8 +6651,21 @@ var init_solana_lite = __esm(() => {
       this.retryAfterMs = facts.retryAfterMs;
       this.rpcCode = facts.rpcCode;
       this.rateLimited = facts.status === 429 || facts.rpcCode === RPC_RATE_LIMIT_CODE || /too many requests/i.test(message);
-    }
-  };
+      if (facts.method !== undefined)
+        this.method = facts.method;
+      if (facts.responseIdMatched !== undefined)
+        this.responseIdMatched = facts.responseIdMatched;
+      if (facts.simulation !== undefined)
+        this.simulation = facts.simulation;
+      if (facts.contextSlot !== undefined)
+        this.contextSlot = facts.contextSlot;
+      if (facts.contextBehind !== undefined)
+        this.contextBehind = facts.contextBehind;
+      if (facts.contextUnverified)
+        this.contextUnverified = true;
+    }
+  };
+  RPC_CONTEXT_BEHIND_SLEEPS_MS = [1000, 2000];
   NEVER_RETRIED = new Set(["sendTransaction", "getProgramAccounts", "getProgramAccountsV2"]);
 });
 
@@ -15462,7 +15645,9 @@ function classifyStatus(status) {
   if (status === null || status === undefined)
     return { kind: "missing" };
   if (status.confirmationStatus === "finalized") {
-    return status.err === null || status.err === undefined ? { kind: "finalized" } : { kind: "failed", err: status.err };
+    if (status.err !== null && status.err !== undefined)
+      return { kind: "failed", err: status.err };
+    return Number.isSafeInteger(status.slot) ? { kind: "finalized", slot: status.slot } : { kind: "finalized" };
   }
   return { kind: "nonfinal", confirmationStatus: status.confirmationStatus, err: status.err };
 }
@@ -15511,8 +15696,9 @@ async function resolvePending(reads, pending) {
   return { kind: "expired", detail: `never observed and its blockhash is no longer valid: it cannot land` };
 }
 function settle(observation, signature) {
-  if (observation.kind === "finalized")
-    return { kind: "finalized" };
+  if (observation.kind === "finalized") {
+    return observation.slot === undefined ? { kind: "finalized" } : { kind: "finalized", slot: observation.slot };
+  }
   if (observation.kind === "failed") {
     return { kind: "failed", detail: `transaction ${signature} failed on chain: ${JSON.stringify(observation.err)}` };
   }
@@ -33127,12 +33313,12 @@ function refusalState(raw) {
   const state = error.state;
   return state === "disable-pending" || state === "enabled" ? state : null;
 }
-async function broadcastAndFinalize(rpc, ctx, secret, feePayer, instructions, pending, recordPending, clearPending) {
+async function broadcastAndFinalize(rpc, ctx, secret, feePayer, instructions, pending, recordPending, clearPending, floor) {
   const blockhash = await rpc.getLatestBlockhash();
   const message = compileLegacyMessage({ feePayer, recentBlockhash: blockhash, instructions });
-  return broadcastMessage(rpc, ctx, secret, message, blockhash, pending, recordPending, clearPending);
+  return broadcastMessage(rpc, ctx, secret, message, blockhash, pending, recordPending, clearPending, floor);
 }
-async function broadcastMessage(rpc, ctx, secret, message, blockhash, pending, recordPending, clearPending) {
+async function broadcastMessage(rpc, ctx, secret, message, blockhash, pending, recordPending, clearPending, floor) {
   const { deps } = ctx;
   const signatureBytes = signMessage(message, secret);
   const signature = base58.encode(signatureBytes);
@@ -33147,24 +33333,52 @@ async function broadcastMessage(rpc, ctx, secret, message, blockhash, pending, r
     return { status: "not-sent", error: "could not record the pending transaction locally; not broadcast" };
   }
   let echoNote = "";
+  let guardedStatus;
   try {
     const echoed = await rpc.sendTransaction(toBase642(wire));
     if (echoed !== signature) {
       echoNote = `; the RPC echoed a different signature (${echoed}), which was ignored`;
     }
   } catch (error) {
-    if (isRateLimited(error))
-      notePostSignatureRateLimit(ctx, signature);
-    return {
-      status: "uncertain",
-      signature,
-      error: `send did not answer cleanly (${describeRpcFailure(error)}); it may still land`
-    };
+    const rejection = definiteSendRejection(error);
+    if (rejection) {
+      const detail = rejection.reason === "context-behind" ? `rejected before simulation (not broadcast): the RPC node is behind slot ${floor.slot ?? "required by this run"} (it is at ${rejection.contextSlot})` : `rejected at simulation (not broadcast): RPC ${rejection.rpcCode}: ${rejection.diagnostics?.message ?? "preflight failed"}`;
+      try {
+        guardedStatus = await rpc.getSignatureStatus(signature);
+      } catch (guardError) {
+        if (isRateLimited(guardError))
+          notePostSignatureRateLimit(ctx, signature);
+        return {
+          status: "uncertain",
+          signature,
+          error: `${detail}; status guard failed (${sanitizeSimulation(describeRpcFailure(guardError), {}).message}); ${signature} may still land`,
+          ...rejection.diagnostics ? { diagnostics: rejection.diagnostics } : {}
+        };
+      }
+      if (guardedStatus === null) {
+        return {
+          ...rejection,
+          status: "rejected",
+          signature,
+          error: detail,
+          pendingCleared: await clearPending(signature)
+        };
+      }
+    } else {
+      if (isRateLimited(error))
+        notePostSignatureRateLimit(ctx, signature);
+      return {
+        status: "uncertain",
+        signature,
+        error: `send did not answer cleanly (${describeRpcFailure(error)}); it may still land`
+      };
+    }
   }
   for (let i = 0;i < CONFIRM_MAX_POLLS; i++) {
     let status;
     try {
-      status = await rpc.getSignatureStatus(signature);
+      status = guardedStatus ?? await rpc.getSignatureStatus(signature);
+      guardedStatus = undefined;
     } catch (error) {
       if (isRateLimited(error))
         notePostSignatureRateLimit(ctx, signature);
@@ -33175,13 +33389,15 @@ async function broadcastMessage(rpc, ctx, secret, message, blockhash, pending, r
       };
     }
     const observed = classifyStatus(status);
+    const slot = status?.slot === undefined ? {} : { slot: status.slot };
     if (observed.kind === "finalized")
-      return { status: "finalized", signature };
+      return { status: "finalized", signature, ...slot };
     if (observed.kind === "failed") {
       await clearPending(signature);
       return {
         status: "failed",
         signature,
+        ...slot,
         error: `transaction ${signature} failed on chain: ${JSON.stringify(observed.err)}`
       };
     }
@@ -33326,7 +33542,27 @@ Stop the agent from your Candle session if you have not, and re-run candle tee d
       return 1;
     }
     const vaultKey = decodePubkey(vault);
-    const rpc = solana.rpc;
+    const floor = createContextFloor();
+    for (const receipt of entry.tee?.sweepReceipts ?? [])
+      if (receipt.slot !== undefined)
+        floor.raise(receipt.slot);
+    const isContextFailure = (error) => error instanceof SolanaRpcError && Boolean(error.contextBehind || error.contextUnverified || floor.slot !== undefined && error.rpcCode === -32602);
+    let contextFailure;
+    const floored = withContextFloor(solana.rpc, floor);
+    const rpc = new Proxy(floored, {
+      get(target, key) {
+        const method = target[key];
+        return async (...args2) => {
+          try {
+            return await method(...args2);
+          } catch (error) {
+            if (isContextFailure(error))
+              contextFailure = error;
+            throw error;
+          }
+        };
+      }
+    });
     const retained = entry.tee?.sweepReceipts ?? [];
     const receipts = [];
     const residuals = [];
@@ -33334,6 +33570,8 @@ Stop the agent from your Candle session if you have not, and re-run candle tee d
     const alreadyRecordedLocally = entry.tee?.sweptAt !== undefined;
     const pendingStill = [];
     const retainReceipt = async (receipt) => {
+      if (receipt.slot !== undefined)
+        floor.raise(receipt.slot);
       receipts.push(receipt);
       const kept = await commitActiveTee(active, (target) => {
         const existing = target.tee?.sweepReceipts ?? [];
@@ -33361,6 +33599,7 @@ Stop the agent from your Candle session if you have not, and re-run candle tee d
         residuals.push({ kind: "local-record-failed", detail: kept.message });
       return kept.ok;
     };
+    const cleanupFailures = new Map;
     const clearPending = async (signature) => {
       const kept = await commitActiveTee(active, (target) => {
         target.tee = {
@@ -33368,12 +33607,58 @@ Stop the agent from your Candle session if you have not, and re-run candle tee d
           sweepPending: (target.tee?.sweepPending ?? []).filter((p) => p.signature !== signature)
         };
       });
-      if (!kept.ok)
+      if (!kept.ok) {
         residuals.push({ kind: "local-record-failed", detail: kept.message });
+        cleanupFailures.set(signature, sanitizeSimulation(kept.message, {}).message);
+      }
+      return kept.ok;
     };
-    const broadcast2 = (instructions, pending) => broadcastAndFinalize(rpc, ctx, secret, teePubkey, instructions, pending, recordPending, clearPending);
+    const attemptedAccounts = new Set;
+    const broadcast2 = (instructions, pending) => {
+      if (pending.account)
+        attemptedAccounts.add(pending.account);
+      return broadcastAndFinalize(rpc, ctx, secret, teePubkey, instructions, pending, recordPending, clearPending, floor);
+    };
+    let rejectionCount = 0;
+    let blockingReason = "not signed: an earlier transaction is still in flight";
     const settle2 = (outcome, pending, describe2, failedKind) => {
+      if (outcome.status === "rejected") {
+        rejectionCount++;
+        const detail = `${outcome.error}; ${pending.kind === "sol" ? "SOL transfer" : pending.kind} of ${pending.amountRaw} ${pending.kind === "sol" ? "lamports" : "raw"}, signed as ${outcome.signature}`;
+        residuals.push({
+          ...pending,
+          kind: failedKind ?? `${describe2}-rejected`,
+          detail,
+          signature: outcome.signature,
+          broadcast: false,
+          rejection: { reason: outcome.reason, rpcCode: outcome.rpcCode, pendingCleared: outcome.pendingCleared },
+          ...outcome.diagnostics ? { diagnostics: outcome.diagnostics } : {}
+        });
+        if (!json) {
+          deps.stdout.write(`  ${detail}
+`);
+          if (outcome.diagnostics) {
+            if (outcome.diagnostics.err !== null)
+              deps.stdout.write(`    program error: ${outcome.diagnostics.err}
+`);
+            for (const line of outcome.diagnostics.logs)
+              deps.stdout.write(`    log: ${line}
+`);
+          }
+        }
+        if (!outcome.pendingCleared) {
+          blockingReason = "not signed: a rejected transaction's local pending record could not be cleared";
+          return false;
+        }
+        if (rejectionCount >= 3) {
+          blockingReason = "not signed: 3 transactions were rejected at simulation in this run; re-run after checking the diagnostics";
+          return false;
+        }
+        return true;
+      }
       if (outcome.status === "failed") {
+        if (outcome.slot !== undefined)
+          floor.raise(outcome.slot);
         residuals.push({
           kind: failedKind ?? `${describe2}-failed`,
           detail: outcome.error,
@@ -33384,19 +33669,46 @@ Stop the agent from your Candle session if you have not, and re-run candle tee d
         return true;
       }
       if (outcome.status === "not-sent") {
-        residuals.push({ kind: `${describe2}-not-sent`, detail: outcome.error });
+        residuals.push({ ...pending, kind: `${describe2}-not-sent`, detail: outcome.error });
+        blockingReason = "not signed: the local pending transaction could not be recorded";
         return false;
       }
       residuals.push({
         kind: "finality-uncertain",
         detail: outcome.error,
+        ...pending.account ? { account: pending.account } : {},
+        ...outcome.diagnostics ? { diagnostics: outcome.diagnostics } : {},
         ...pending.mint ? { mint: pending.mint } : {},
         amountRaw: pending.amountRaw
       });
+      blockingReason = "not signed: an earlier transaction is still in flight";
       pendingStill.push({ ...pending, signature: outcome.signature, blockhash: "", submittedAt: "" });
       return false;
     };
     let signingBlocked = false;
+    const notAttempted = (acct) => {
+      if (acct && (attemptedAccounts.has(acct.pubkey) || residuals.some((r) => r.account === acct.pubkey)))
+        return;
+      residuals.push({
+        kind: "not-attempted",
+        detail: `${acct ? "account" : "SOL transfer"} ${blockingReason}`,
+        ...acct ? { account: acct.pubkey, mint: acct.mint, amountRaw: acct.amountRaw } : {}
+      });
+      if (!acct)
+        solHandledAsResidual = true;
+    };
+    const stopForContext = (error, acct) => {
+      if (!isContextFailure(error))
+        return false;
+      blockingReason = "not signed: an RPC context failure stopped signing in this run";
+      signingBlocked = true;
+      residuals.push({
+        kind: error.contextBehind ? "rpc-context-behind" : "rpc-context-unverified",
+        detail: `Nothing was signed for ${acct ? "this account" : "this step"}: RPC ${solana.endpoint.host} ${sanitizeSimulation(describeRpcFailure(error), {}).message}. Fix: ${rpcFixLines(ctx).join(", ")}`,
+        ...acct ? { account: acct.pubkey, mint: acct.mint, amountRaw: acct.amountRaw } : {}
+      });
+      return true;
+    };
     const reads = {
       status: (signature) => rpc.getSignatureStatus(signature),
       blockhashValid: (blockhash) => rpc.isBlockhashValid(blockhash)
@@ -33409,6 +33721,7 @@ Stop the agent from your Candle session if you have not, and re-run candle tee d
           ...p.mint ? { mint: p.mint } : {},
           amountRaw: p.amountRaw,
           signature: p.signature,
+          ...resolution.slot === undefined ? {} : { slot: resolution.slot },
           finalizedAt: new Date(deps.now()).toISOString()
         });
         if (!json)
@@ -33417,7 +33730,10 @@ Stop the agent from your Candle session if you have not, and re-run candle tee d
         continue;
       }
       if (resolution.kind === "failed" || resolution.kind === "expired") {
-        await clearPending(p.signature);
+        if (!await clearPending(p.signature)) {
+          signingBlocked = true;
+          blockingReason = "not signed: an earlier pending record could not be cleared";
+        }
         if (!json)
           deps.stdout.write(`  pending ${p.signature}: ${resolution.detail}; its balance is swept again
 `);
@@ -33433,17 +33749,21 @@ Stop the agent from your Candle session if you have not, and re-run candle tee d
       signingBlocked = true;
     }
     const candidateAccounts = new Set;
+    const knownAccounts = new Map;
     const lpCloses = [];
     {
       let token2022Accounts = [];
       try {
         token2022Accounts = await rpc.getTokenAccountsByOwner(address, TOKEN_2022_PROGRAM_ID);
       } catch (error) {
-        residuals.push({
-          kind: "inventory",
-          detail: `could not list Token-2022 accounts for position discovery: ${describeRpcFailure(error)}`
-        });
+        if (!stopForContext(error))
+          residuals.push({
+            kind: "inventory",
+            detail: `could not list Token-2022 accounts for position discovery: ${describeRpcFailure(error)}`
+          });
       }
+      for (const acct of token2022Accounts)
+        knownAccounts.set(acct.pubkey, acct);
       const candidates = token2022Accounts.filter(isPositionCandidate);
       for (const acct of candidates)
         candidateAccounts.add(acct.pubkey);
@@ -33454,8 +33774,10 @@ Stop the agent from your Candle session if you have not, and re-run candle tee d
 `);
         const verified = [];
         for (const acct of candidates) {
-          if (signingBlocked)
-            break;
+          if (signingBlocked) {
+            notAttempted(acct);
+            continue;
+          }
           if (!apiKey || !entry.linkedWalletId) {
             leftover(DAMM_POSITION_CLOSE_UNAVAILABLE, acct, "no bound API key is available to build the close; the NFT was left in place");
             continue;
@@ -33486,6 +33808,8 @@ Stop the agent from your Candle session if you have not, and re-run candle tee d
             nftMint: acct.mint,
             nftAccount: acct.pubkey
           });
+          if (contextFailure && stopForContext(contextFailure, acct))
+            continue;
           if (!verdict.ok) {
             leftover(DAMM_CLOSE_TRANSACTION_REFUSED, acct, `${verdict.reason}; refused before signing`);
             continue;
@@ -33494,13 +33818,15 @@ Stop the agent from your Candle session if you have not, and re-run candle tee d
         }
         for (const { acct, verdict } of verified) {
           if (signingBlocked) {
-            leftover(DAMM_POSITION_CLOSE_UNAVAILABLE, acct, "not signed: an earlier transaction is still in flight");
+            notAttempted(acct);
             continue;
           }
           let blockhashValid;
           try {
             blockhashValid = await rpc.isBlockhashValid(verdict.tx.message.recentBlockhash, "confirmed");
           } catch (error) {
+            if (stopForContext(error, acct))
+              continue;
             leftover(DAMM_POSITION_CLOSE_UNAVAILABLE, acct, `could not check the close build's blockhash: ${describeRpcFailure(error)}; not signed`);
             continue;
           }
@@ -33523,7 +33849,8 @@ Stop the agent from your Candle session if you have not, and re-run candle tee d
             account: acct.pubkey,
             amountRaw: acct.amountRaw
           };
-          const outcome = await broadcastMessage(rpc, ctx, secret, verdict.tx.message.bytes, verdict.tx.message.recentBlockhash, pending, recordPending, clearPending);
+          attemptedAccounts.add(acct.pubkey);
+          const outcome = await broadcastMessage(rpc, ctx, secret, verdict.tx.message.bytes, verdict.tx.message.recentBlockhash, pending, recordPending, clearPending, floor);
           if (outcome.status !== "finalized") {
             if (!settle2(outcome, pending, "lp-close"))
               signingBlocked = true;
@@ -33534,6 +33861,7 @@ Stop the agent from your Candle session if you have not, and re-run candle tee d
             mint: acct.mint,
             amountRaw: acct.amountRaw,
             signature: outcome.signature,
+            ...outcome.slot === undefined ? {} : { slot: outcome.slot },
             finalizedAt: new Date(deps.now()).toISOString()
           });
           if (!json)
@@ -33547,16 +33875,21 @@ Stop the agent from your Candle session if you have not, and re-run candle tee d
       try {
         tokenAccounts.push(...await rpc.getTokenAccountsByOwner(address, programId));
       } catch (error) {
-        residuals.push({
-          kind: "inventory",
-          detail: `could not list ${programId === TOKEN_PROGRAM_ID ? "token" : "Token-2022"} accounts: ${describeRpcFailure(error)}`
-        });
+        if (!stopForContext(error))
+          residuals.push({
+            kind: "inventory",
+            detail: `could not list ${programId === TOKEN_PROGRAM_ID ? "token" : "Token-2022"} accounts: ${describeRpcFailure(error)}`
+          });
       }
     }
+    for (const acct of tokenAccounts)
+      knownAccounts.set(acct.pubkey, acct);
     let epoch;
     for (const acct of tokenAccounts) {
-      if (signingBlocked)
-        break;
+      if (signingBlocked) {
+        notAttempted(acct);
+        continue;
+      }
       const token2022 = acct.programId === TOKEN_2022_PROGRAM_ID;
       if (candidateAccounts.has(acct.pubkey)) {
         if (!emergency)
@@ -33596,6 +33929,8 @@ Stop the agent from your Candle session if you have not, and re-run candle tee d
               owner: teePubkey,
               amount
             });
+            if (contextFailure)
+              throw contextFailure;
             if (hook.ok)
               extraAccounts = hook.accounts;
             else {
@@ -33646,7 +33981,6 @@ Stop the agent from your Candle session if you have not, and re-run candle tee d
           const named = profile ? classifyTokenSendFailure({ profile, frozen: destinationFrozen, extraAccountsMissing }) : undefined;
           if (!settle2(outcome, pending, "token-transfer", named)) {
             signingBlocked = true;
-            break;
           }
           continue;
         }
@@ -33656,12 +33990,15 @@ Stop the agent from your Candle session if you have not, and re-run candle tee d
           mint: acct.mint,
           amountRaw: acct.amountRaw,
           signature,
+          ...outcome.slot === undefined ? {} : { slot: outcome.slot },
           finalizedAt: new Date(deps.now()).toISOString()
         });
         if (!json)
           deps.stdout.write(`  moved ${acct.amountRaw} raw of ${acct.mint} and closed its account: ${signature}
 `);
       } catch (error) {
+        if (stopForContext(error, acct))
+          continue;
         residuals.push({
           kind: "token-transfer-failed",
           detail: describeRpcFailure(error),
@@ -33671,6 +34008,8 @@ Stop the agent from your Candle session if you have not, and re-run candle tee d
         });
       }
     }
+    if (signingBlocked)
+      notAttempted();
     try {
       const balance = signingBlocked ? 0n : await rpc.getBalance(address);
       if (balance > 0n) {
@@ -33709,6 +34048,7 @@ Stop the agent from your Candle session if you have not, and re-run candle tee d
               kind: "sol",
               amountRaw: amount.toString(),
               signature,
+              ...outcome.slot === undefined ? {} : { slot: outcome.slot },
               finalizedAt: new Date(deps.now()).toISOString()
             });
             if (!json)
@@ -33719,8 +34059,12 @@ Stop the agent from your Candle session if you have not, and re-run candle tee d
       }
     } catch (error) {
       solHandledAsResidual = true;
-      residuals.push({ kind: "sol-transfer-failed", detail: describeRpcFailure(error) });
+      if (!stopForContext(error))
+        residuals.push({ kind: "sol-transfer-failed", detail: describeRpcFailure(error) });
     }
+    if (signingBlocked)
+      for (const acct of knownAccounts.values())
+        notAttempted(acct);
     const inventory = { observedAt: new Date(deps.now()).toISOString(), verified: false, lamports: null, tokenAccounts: null };
     try {
       const listed = new Set(residuals.map((r) => r.account).filter((a) => a !== undefined));
@@ -33819,6 +34163,7 @@ Stop the agent from your Candle session if you have not, and re-run candle tee d
           signature: p.signature
         })),
         inventory,
+        contextFloorSlot: floor.slot ?? null,
         recordedOnServer,
         ...lpCloses.length > 0 ? { lpCloses } : {}
       })}
@@ -33845,6 +34190,18 @@ Stop the agent from your Candle session if you have not, and re-run candle tee d
 `);
     if (pendingStill.length > 0)
       deps.stdout.write(`${pendingStill.length} transaction(s) still in flight (${pendingStill.map((p) => p.signature).join(", ")}). Re-run this sweep: a finalized one becomes a receipt, an expired one is swept again.
+`);
+    const rejected = residuals.filter((r) => r.rejection);
+    if (pendingStill.length === 0 && rejected.length > 0 && rejected.every((r) => r.rejection?.pendingCleared)) {
+      deps.stdout.write(`Nothing from this run is in flight: ${rejected.length} transaction(s) were rejected before broadcast. Re-run this sweep now.
+`);
+      if (rejected.some((r) => r.rejection?.reason === "context-behind"))
+        deps.stdout.write(`Fix: ${rpcFixLines(ctx).join(", ")}
+`);
+    }
+    for (const r of rejected)
+      if (!r.rejection?.pendingCleared)
+        deps.stdout.write(`The local pending record for ${r.signature} could not be removed (${cleanupFailures.get(r.signature ?? "")}). It was never broadcast; the next run drops it once its blockhash expires, normally within two minutes. Re-run after that.
 `);
     if (serverState === "disable-pending" && !emergency)
       deps.stdout.write(`Remote signing authority is not verified denied. Re-run: candle tee disable ${address}, then re-run this sweep to record it.
@@ -42485,20 +42842,20 @@ var require_resolve = __commonJS((exports) => {
     return false;
   }
   function countKeys(schema) {
-    let count = 0;
+    let count2 = 0;
     for (const key in schema) {
       if (key === "$ref")
         return Infinity;
-      count++;
+      count2++;
       if (SIMPLE_INLINED.has(key))
         continue;
       if (typeof schema[key] == "object") {
-        (0, util_1.eachItem)(schema[key], (sch) => count += countKeys(sch));
+        (0, util_1.eachItem)(schema[key], (sch) => count2 += countKeys(sch));
       }
-      if (count === Infinity)
+      if (count2 === Infinity)
         return Infinity;
     }
-    return count;
+    return count2;
   }
   function getFullPath(resolver, id = "", normalize4) {
     if (normalize4 !== false)
@@ -45553,8 +45910,8 @@ var require_contains = __commonJS((exports) => {
       cxt.result(valid, () => cxt.reset());
       function validateItemsWithCount() {
         const schValid = gen2.name("_valid");
-        const count = gen2.let("count", 0);
-        validateItems(schValid, () => gen2.if(schValid, () => checkLimits(count)));
+        const count2 = gen2.let("count", 0);
+        validateItems(schValid, () => gen2.if(schValid, () => checkLimits(count2)));
       }
       function validateItems(_valid, block2) {
         gen2.forRange("i", 0, len, (i) => {
@@ -45567,16 +45924,16 @@ var require_contains = __commonJS((exports) => {
           block2();
         });
       }
-      function checkLimits(count) {
-        gen2.code((0, codegen_1._)`${count}++`);
+      function checkLimits(count2) {
+        gen2.code((0, codegen_1._)`${count2}++`);
         if (max === undefined) {
-          gen2.if((0, codegen_1._)`${count} >= ${min}`, () => gen2.assign(valid, true).break());
+          gen2.if((0, codegen_1._)`${count2} >= ${min}`, () => gen2.assign(valid, true).break());
         } else {
-          gen2.if((0, codegen_1._)`${count} > ${max}`, () => gen2.assign(valid, false).break());
+          gen2.if((0, codegen_1._)`${count2} > ${max}`, () => gen2.assign(valid, false).break());
           if (min === 1)
             gen2.assign(valid, true);
           else
-            gen2.if((0, codegen_1._)`${count} >= ${min}`, () => gen2.assign(valid, true));
+            gen2.if((0, codegen_1._)`${count2} >= ${min}`, () => gen2.assign(valid, true));
         }
       }
     }
@@ -49488,7 +49845,7 @@ var init_convert = __esm(() => {
 });
 
 // ../mcp/src/version.ts
-var SERVER_VERSION = "0.10.4";
+var SERVER_VERSION = "0.10.6";
 
 // ../mcp/src/update-notice.ts
 function newer(a, b) {
@@ -49524,7 +49881,7 @@ var init_update_notice = __esm(() => {
 });
 
 // ../mcp/src/orchestrate.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 function requireApiKey(cfg) {
   if (!cfg.apiKey) {
     throw new Error("CANDLE_AGENT_API_KEY is required for this tool. Set it in the environment or MCP client config.");
@@ -49636,7 +49993,7 @@ async function readPaperInventory(cfg, doFetch, extra) {
 }
 async function executeTrade(args, cfg, doFetch) {
   const apiKey = requireApiKey(cfg);
-  const clientTradeId = args.clientTradeId ?? randomUUID5();
+  const clientTradeId = args.clientTradeId ?? randomUUID6();
   if (args.amount !== undefined && args.percent !== undefined) {
     return errText("pass exactly one of amount or percent, not both", { clientTradeId });
   }
@@ -49774,7 +50131,7 @@ async function executeTrade(args, cfg, doFetch) {
 }
 async function executeLaunchAndSeed(args, cfg, doFetch) {
   const apiKey = requireApiKey(cfg);
-  const clientLaunchId = args.clientLaunchId ?? randomUUID5();
+  const clientLaunchId = args.clientLaunchId ?? randomUUID6();
   const { devBuy, dryRun, buyAmount: _rawBuyAmount, ...launchFields } = args;
   let buyAmount;
   if (devBuy !== undefined) {
@@ -49940,6 +50297,878 @@ var init_orchestrate = __esm(() => {
   };
 });
 
+// ../mcp/src/hyperliquid.ts
+function pushUint2(out, value, width) {
+  for (let i = width - 1;i >= 0; i--)
+    out.push(Number(value >> BigInt(i * 8) & 0xffn));
+}
+function packInteger2(out, value) {
+  if (value >= 0n) {
+    if (value > UINT64_MAX2)
+      throw new Error("msgpack: integer above uint64");
+    if (value < 0x80n)
+      out.push(Number(value));
+    else if (value <= 0xffn) {
+      out.push(204);
+      pushUint2(out, value, 1);
+    } else if (value <= 0xffffn) {
+      out.push(205);
+      pushUint2(out, value, 2);
+    } else if (value <= 0xffffffffn) {
+      out.push(206);
+      pushUint2(out, value, 4);
+    } else {
+      out.push(207);
+      pushUint2(out, value, 8);
+    }
+    return;
+  }
+  if (value < INT64_MIN2)
+    throw new Error("msgpack: integer below int64");
+  if (value >= -32n)
+    out.push(Number(value & 0xffn));
+  else if (value >= -128n) {
+    out.push(208);
+    pushUint2(out, value & 0xffn, 1);
+  } else if (value >= -32768n) {
+    out.push(209);
+    pushUint2(out, value & 0xffffn, 2);
+  } else if (value >= -2147483648n) {
+    out.push(210);
+    pushUint2(out, value & 0xffffffffn, 4);
+  } else {
+    out.push(211);
+    pushUint2(out, value & UINT64_MAX2, 8);
+  }
+}
+function packHeader2(out, length, fixBase, fixMax, codes) {
+  if (length <= fixMax) {
+    out.push(fixBase | length);
+    return;
+  }
+  const [c8, c16, c32] = codes;
+  if (c8 !== undefined && c8 !== 0 && length <= 255) {
+    out.push(c8);
+    pushUint2(out, BigInt(length), 1);
+  } else if (length <= 65535) {
+    out.push(c16);
+    pushUint2(out, BigInt(length), 2);
+  } else {
+    out.push(c32);
+    pushUint2(out, BigInt(length), 4);
+  }
+}
+function packValue2(out, value) {
+  if (value === null)
+    out.push(192);
+  else if (value === false)
+    out.push(194);
+  else if (value === true)
+    out.push(195);
+  else if (typeof value === "bigint")
+    packInteger2(out, value);
+  else if (typeof value === "number") {
+    if (!Number.isSafeInteger(value))
+      throw new Error(`msgpack: ${value} is not a safe integer`);
+    packInteger2(out, BigInt(value));
+  } else if (typeof value === "string") {
+    const bytes = new TextEncoder().encode(value);
+    packHeader2(out, bytes.length, 160, 31, [217, 218, 219]);
+    for (const b of bytes)
+      out.push(b);
+  } else if (Array.isArray(value)) {
+    packHeader2(out, value.length, 144, 15, [0, 220, 221]);
+    for (const item of value)
+      packValue2(out, item);
+  } else if (typeof value === "object") {
+    const entries = Object.entries(value).filter(([, v]) => v !== undefined);
+    for (const [key] of entries) {
+      if (/^(0|[1-9][0-9]*)$/.test(key))
+        throw new Error(`msgpack: integer-like key "${key}"`);
+    }
+    packHeader2(out, entries.length, 128, 15, [0, 222, 223]);
+    for (const [key, item] of entries) {
+      packValue2(out, key);
+      packValue2(out, item);
+    }
+  } else {
+    throw new Error(`msgpack: cannot encode a ${typeof value}`);
+  }
+}
+function msgpackEncode2(value) {
+  const out = [];
+  packValue2(out, value);
+  return Uint8Array.from(out);
+}
+function toHex2(bytes) {
+  let out = "";
+  for (const b of bytes)
+    out += b.toString(16).padStart(2, "0");
+  return out;
+}
+function hyperliquidActionHash2(action, nonce) {
+  const n = BigInt(nonce);
+  if (n < 0n || n > UINT64_MAX2)
+    throw new Error("hyperliquidActionHash: nonce out of range");
+  const out = Array.from(msgpackEncode2(action));
+  pushUint2(out, n, 8);
+  out.push(0);
+  return `0x${toHex2(keccak_256(Uint8Array.from(out)))}`;
+}
+function hyperliquidL1TypedData2(connectionId, network2) {
+  return {
+    domain: { name: "Exchange", version: "1", chainId: 1337, verifyingContract: ZERO_ADDRESS2 },
+    types: {
+      Agent: [
+        { name: "source", type: "string" },
+        { name: "connectionId", type: "bytes32" }
+      ]
+    },
+    primary_type: "Agent",
+    message: { source: network2 === "mainnet" ? "a" : "b", connectionId }
+  };
+}
+function hyperliquidApproveBuilderFeeTypedData2(builder, nonce) {
+  return {
+    domain: { name: "HyperliquidSignTransaction", version: "1", chainId: 42161, verifyingContract: ZERO_ADDRESS2 },
+    types: {
+      "HyperliquidTransaction:ApproveBuilderFee": [
+        { name: "hyperliquidChain", type: "string" },
+        { name: "maxFeeRate", type: "string" },
+        { name: "builder", type: "address" },
+        { name: "nonce", type: "uint64" }
+      ]
+    },
+    primary_type: "HyperliquidTransaction:ApproveBuilderFee",
+    message: {
+      hyperliquidChain: "Mainnet",
+      maxFeeRate: HYPERLIQUID_MAX_BUILDER_FEE_RATE2,
+      builder: builder.toLowerCase(),
+      nonce
+    }
+  };
+}
+function hyperliquidCanonicalJson2(value) {
+  return canonical2(value);
+}
+function canonical2(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value);
+  if (Array.isArray(value))
+    return `[${value.map(canonical2).join(",")}]`;
+  const record2 = value;
+  return `{${Object.keys(record2).sort().map((key) => `${JSON.stringify(key)}:${canonical2(record2[key])}`).join(",")}}`;
+}
+function sameValue2(a, b) {
+  return canonical2(a) === canonical2(b);
+}
+function checkBuilderField2(action, builder) {
+  if (!("builder" in action) || action.builder === undefined)
+    return null;
+  const field = action.builder;
+  if (typeof field !== "object" || field === null)
+    return "builder field is not an object";
+  if (typeof field.b !== "string" || field.b.toLowerCase() !== builder.toLowerCase()) {
+    return "the order names a builder that is not Candle's";
+  }
+  if (typeof field.f !== "number" || !Number.isInteger(field.f) || field.f <= 0 || field.f > HYPERLIQUID_MAX_BUILDER_FEE_TENTHS_BPS2) {
+    return "the builder fee is outside Candle's 0.1% maximum";
+  }
+  return null;
+}
+function decimal2(value) {
+  if (typeof value !== "string" || !/^-?(0|[1-9][0-9]*)(\.[0-9]{1,18})?$/.test(value))
+    return null;
+  const negative = value.startsWith("-");
+  const [whole = "0", frac = ""] = (negative ? value.slice(1) : value).split(".");
+  const n = BigInt(whole) * 10n ** 18n + BigInt(frac.padEnd(18, "0"));
+  return negative ? -n : n;
+}
+function checkActionIntent2(action, intent) {
+  const mainAsset = (a) => typeof a === "number" && Number.isInteger(a) && a >= 0 && a < 1e4;
+  const orderList = action.type === "order" ? action.orders : action.type === "modify" ? [action.order] : [];
+  if (!Array.isArray(orderList))
+    return "invalid orders";
+  for (const raw of orderList) {
+    if (!raw || typeof raw !== "object")
+      return "invalid order";
+    const o = raw;
+    if (!mainAsset(o.a))
+      return "order asset is outside the main perp universe";
+    if (typeof o.b !== "boolean" || typeof o.r !== "boolean" || (decimal2(o.s) ?? 0n) <= 0n || (decimal2(o.p) ?? 0n) <= 0n)
+      return "invalid order side, size, price or reduce-only flag";
+  }
+  if (action.type === "cancel") {
+    if (!Array.isArray(action.cancels) || action.cancels.length !== 1 || !mainAsset(action.cancels[0]?.a))
+      return "invalid cancel asset";
+  }
+  if ((action.type === "updateLeverage" || action.type === "updateIsolatedMargin") && !mainAsset(action.asset))
+    return "invalid action asset";
+  if (!intent)
+    return null;
+  const { method, params: p } = intent;
+  const types2 = {
+    setup: "approveBuilderFee",
+    open: "order",
+    close: "order",
+    cancel: "cancel",
+    modify: "modify",
+    leverage: "updateLeverage",
+    margin: "updateIsolatedMargin"
+  };
+  if (action.type !== types2[method])
+    return "action type does not match the requested method";
+  if (method === "leverage") {
+    if (action.leverage !== p.leverage || action.isCross !== (p.mode !== "isolated"))
+      return "leverage or mode does not match the request";
+  }
+  if (method === "margin") {
+    const amount = decimal2(p.amount);
+    if (amount === null || amount % 10n ** 12n !== 0n || !Number.isSafeInteger(action.ntli) || BigInt(action.ntli) !== amount / 10n ** 12n || action.isBuy !== true)
+      return "isolated margin amount does not match the request";
+  }
+  if (method === "open" || method === "close" || method === "modify") {
+    const list = orderList;
+    const first = list[0];
+    if (!first)
+      return "missing requested order";
+    const typ = first.t;
+    if (!typ?.limit)
+      return "requested order is not a limit/IOC order";
+    if (method === "open") {
+      const buy = p.side === "long" || p.side === "buy";
+      if (first.b !== buy || first.r !== false || decimal2(first.s) !== decimal2(p.size))
+        return "order side, size or reduce-only flag does not match the request";
+      const tif = (p.type ?? (p.price === undefined ? "market" : "limit")) === "market" ? "Ioc" : p.tif ?? "Gtc";
+      if (typ.limit.tif !== tif)
+        return "order time in force does not match the request";
+      const triggers = [
+        ["takeProfit", "tp"],
+        ["stopLoss", "sl"]
+      ].filter(([field]) => p[field] != null);
+      if (list.length !== 1 + triggers.length || action.grouping !== (triggers.length ? "normalTpsl" : "na"))
+        return "unexpected extra orders or grouping";
+      for (let i = 0;i < triggers.length; i++) {
+        const [field, kind] = triggers[i];
+        const leg = list[i + 1];
+        if (!leg)
+          return "missing trigger order";
+        const trigger = leg.t?.trigger;
+        if (leg.a !== first.a || leg.b !== !buy || leg.r !== true || decimal2(leg.s) !== decimal2(p.size) || trigger?.tpsl !== kind || trigger.isMarket !== true || decimal2(trigger.triggerPx) !== decimal2(p[field]))
+          return "trigger side, size, reduce-only flag or price does not match the request";
+      }
+    } else {
+      if (list.length !== 1)
+        return "unexpected extra orders";
+      if (method === "close" && (first.r !== true || typ.limit.tif !== "Ioc" || p.size != null && (decimal2(first.s) ?? 0n) > (decimal2(p.size) ?? 0n)))
+        return "close size or reduce-only flag does not match the request";
+      if (method === "modify" && p.size != null && decimal2(first.s) !== decimal2(p.size))
+        return "replacement size does not match the request";
+    }
+    if (p.price != null && decimal2(first.p) !== decimal2(p.price))
+      return "order price does not match the request";
+  }
+  return null;
+}
+async function hyperliquidCloseOrder2(fetcher, network2, address, params) {
+  const read = async (body) => {
+    const res = await fetcher(HYPERLIQUID_EXCHANGE_URLS2[network2].replace("/exchange", "/info"), {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok)
+      throw new Error("Cannot read the close position from Hyperliquid");
+    return JSON.parse(await res.text());
+  };
+  const [meta, state] = await Promise.all([read({ type: "meta" }), read({ type: "clearinghouseState", user: address })]);
+  const coin = String(params.coin).toUpperCase();
+  const asset = meta.universe.findIndex((m) => m.name.toUpperCase() === coin);
+  const szi = state.assetPositions.find((p) => p.position.coin.toUpperCase() === coin)?.position.szi;
+  const signed = decimal2(szi);
+  if (asset < 0 || asset >= 1e4 || signed === null || signed === 0n)
+    throw new Error("No main-universe position to close");
+  const held = signed < 0n ? -signed : signed;
+  const asked = params.size == null ? held : decimal2(params.size);
+  if (asked === null || asked <= 0n)
+    throw new Error("Invalid close size");
+  const size = asked < held ? String(params.size) : String(szi).replace(/^-/, "");
+  return { asset, isBuy: signed < 0n, size };
+}
+function verifyPerpsBuild2(build, opts) {
+  try {
+    const network2 = opts.network ?? "mainnet";
+    if (!EVM_ADDRESS_RE2.test(opts.builder))
+      return { ok: false, reason: "no valid Candle builder address to check against" };
+    if (build.network !== undefined && build.network !== network2) {
+      return { ok: false, reason: `the build is for ${build.network}, this client trades ${network2}` };
+    }
+    if (opts.address && build.address && build.address.toLowerCase() !== opts.address.toLowerCase()) {
+      return { ok: false, reason: "the build is for a different wallet" };
+    }
+    if (!Number.isSafeInteger(build.nonce) || build.nonce <= 0)
+      return { ok: false, reason: "invalid nonce" };
+    const typed = build.typedData;
+    if (!typed || typeof typed !== "object")
+      return { ok: false, reason: "no typed data" };
+    const action = build.action;
+    if (!action || typeof action !== "object")
+      return { ok: false, reason: "no action" };
+    const intentRefusal = checkActionIntent2(action, opts.intent);
+    if (intentRefusal)
+      return { ok: false, reason: intentRefusal };
+    if (opts.closeOrder) {
+      const order = action.orders[0];
+      if (!order || order.a !== opts.closeOrder.asset || order.b !== opts.closeOrder.isBuy || decimal2(order.s) !== decimal2(opts.closeOrder.size) || order.r !== true)
+        return { ok: false, reason: "close side, asset or size does not match the requested position" };
+    }
+    if (typed.primary_type === "Agent") {
+      const type = action.type;
+      if (typeof type !== "string" || !HYPERLIQUID_ALLOWED_ACTION_TYPES2.includes(type)) {
+        return { ok: false, reason: `action type ${String(type)} is not one Candle builds` };
+      }
+      if (type === "order") {
+        const refusal = checkBuilderField2(action, opts.builder);
+        if (refusal)
+          return { ok: false, reason: refusal };
+      } else if ("builder" in action) {
+        return { ok: false, reason: `a ${type} action carries no builder` };
+      }
+      if ("vaultAddress" in action)
+        return { ok: false, reason: "the action names a vault" };
+      const expected = hyperliquidL1TypedData2(hyperliquidActionHash2(action, build.nonce), network2);
+      if (!sameValue2(typed, expected)) {
+        return { ok: false, reason: "the typed data does not commit to this action and nonce" };
+      }
+      return { ok: true, kind: "l1" };
+    }
+    if (typed.primary_type === "HyperliquidTransaction:ApproveBuilderFee") {
+      const expected = hyperliquidApproveBuilderFeeTypedData2(opts.builder, build.nonce);
+      if (!sameValue2(typed, expected)) {
+        return { ok: false, reason: "the builder approval is not Candle's builder at 0.1% on Mainnet" };
+      }
+      const expectedAction = {
+        type: "approveBuilderFee",
+        hyperliquidChain: "Mainnet",
+        signatureChainId: HYPERLIQUID_SIGNATURE_CHAIN_ID2,
+        maxFeeRate: HYPERLIQUID_MAX_BUILDER_FEE_RATE2,
+        builder: opts.builder.toLowerCase(),
+        nonce: build.nonce
+      };
+      if (!sameValue2(action, expectedAction)) {
+        return { ok: false, reason: "the approval action does not match its typed data" };
+      }
+      return { ok: true, kind: "approveBuilderFee" };
+    }
+    return { ok: false, reason: `primary type ${String(typed.primary_type)} is not one the relay signs` };
+  } catch (err) {
+    return { ok: false, reason: err instanceof Error ? err.message : "unreadable build" };
+  }
+}
+function hyperliquidSplitSignature2(signature) {
+  if (!/^0x[0-9a-fA-F]{130}$/.test(signature))
+    throw new Error("Not a 65-byte signature");
+  let v = Number.parseInt(signature.slice(130, 132), 16);
+  if (v < 27)
+    v += 27;
+  return { r: `0x${signature.slice(2, 66)}`, s: `0x${signature.slice(66, 130)}`, v };
+}
+function hyperliquidExchangeBody2(action, nonce, signature) {
+  return { action, nonce, signature: hyperliquidSplitSignature2(signature), vaultAddress: null, expiresAfter: null };
+}
+function hyperliquidRelayBody2(typedData) {
+  return { method: "eth_signTypedData_v4", params: { typed_data: typedData } };
+}
+var HYPERLIQUID_ALLOWED_ACTION_TYPES2, HYPERLIQUID_EXCHANGE_URLS2, CANDLE_HYPERLIQUID_BUILDER_ADDRESS2 = null, HYPERLIQUID_MAX_BUILDER_FEE_TENTHS_BPS2 = 100, HYPERLIQUID_MAX_BUILDER_FEE_RATE2 = "0.1%", HYPERLIQUID_SIGNATURE_CHAIN_ID2 = "0xa4b1", ZERO_ADDRESS2 = "0x0000000000000000000000000000000000000000", UINT64_MAX2, INT64_MIN2, EVM_ADDRESS_RE2;
+var init_hyperliquid = __esm(() => {
+  init_sha3();
+  HYPERLIQUID_ALLOWED_ACTION_TYPES2 = [
+    "order",
+    "cancel",
+    "modify",
+    "updateLeverage",
+    "updateIsolatedMargin"
+  ];
+  HYPERLIQUID_EXCHANGE_URLS2 = {
+    mainnet: "https://api.hyperliquid.xyz/exchange",
+    testnet: "https://api.hyperliquid-testnet.xyz/exchange"
+  };
+  UINT64_MAX2 = (1n << 64n) - 1n;
+  INT64_MIN2 = -(1n << 63n);
+  EVM_ADDRESS_RE2 = /^0x[0-9a-fA-F]{40}$/;
+});
+
+// ../mcp/src/perps.ts
+import { createPrivateKey as createPrivateKey2, sign as sign5 } from "node:crypto";
+import { readFile as readFile9 } from "node:fs/promises";
+function fail3(code, message, extra = {}) {
+  return { text: JSON.stringify({ success: false, error: { code, message }, ...extra }), isError: true };
+}
+async function call(cfg, fetch2, method, path, body) {
+  const res = await fetch2(`${cfg.apiUrl.replace(/\/$/, "")}${path}`, {
+    method,
+    headers: { "Content-Type": "application/json", ...cfg.apiKey ? { "x-api-key": cfg.apiKey } : {} },
+    ...body !== undefined ? { body: JSON.stringify(body) } : {}
+  });
+  const text = await res.text();
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    parsed = text;
+  }
+  if (!res.ok) {
+    if (res.status === 404 && (typeof parsed !== "object" || parsed === null))
+      throw new Refusal(fail3("PERPS_NOT_ENABLED", "This Candle deployment does not serve perps routes."));
+    throw new Refusal({ text: typeof parsed === "string" ? parsed : JSON.stringify(parsed), isError: true });
+  }
+  if (typeof parsed !== "object" || parsed === null)
+    throw new Refusal(fail3("INVALID_RESPONSE", "Not a JSON object"));
+  return parsed;
+}
+async function walletFor(cfg, fetch2, name2, scope) {
+  const listed = await call(cfg, fetch2, "GET", "/api/v1/agent/wallets/trading");
+  if (scope && !(Array.isArray(listed.scopes) && listed.scopes.includes(scope)))
+    throw new Refusal(fail3("SCOPE_MISSING", `The key needs ${scope}.`));
+  const rows = Array.isArray(listed.page) ? listed.page : [];
+  const evm = rows.filter((row) => row.chain === "evm");
+  const matches2 = name2 === undefined ? evm : evm.filter((row) => row.id === name2 || row.label === name2 || row.address.toLowerCase() === name2.toLowerCase());
+  if (matches2.length !== 1)
+    throw new Refusal(fail3("TEE_WALLET_REQUIRED", evm.length === 0 ? "This key has no EVM TEE wallet bound to it." : `Name exactly one EVM TEE wallet: ${evm.map((row) => row.label ?? row.id).join(", ")}`));
+  return { row: matches2[0], appId: typeof listed.privyAppId === "string" ? listed.privyAppId : "" };
+}
+async function builderPin2(cfg, fetch2, env) {
+  const pinned = env.CANDLE_HYPERLIQUID_BUILDER?.trim() || CANDLE_HYPERLIQUID_BUILDER_ADDRESS2;
+  if (pinned)
+    return pinned.toLowerCase();
+  const config = await call(cfg, fetch2, "GET", "/api/v1/agent/perps/config");
+  if (typeof config.builder !== "string")
+    throw new Refusal(fail3("PERPS_NOT_CONFIGURED", "The server reports no Hyperliquid builder address."));
+  return config.builder.toLowerCase();
+}
+async function executePerps(tool, args, cfg, env, fetch2) {
+  if (!cfg.apiKey)
+    return fail3("MCP_VALIDATION", "CANDLE_AGENT_API_KEY is required for this tool.");
+  const network2 = env.CANDLE_HYPERLIQUID_NETWORK === "testnet" ? "testnet" : "mainnet";
+  const name2 = typeof args.wallet === "string" ? args.wallet : undefined;
+  try {
+    if (tool === "candle_perps_orders" || tool === "candle_perps_positions") {
+      const { row: row2 } = await walletFor(cfg, fetch2, name2);
+      const query = new URLSearchParams({ walletId: row2.id });
+      if (typeof args.limit === "number")
+        query.set("limit", String(args.limit));
+      return { text: JSON.stringify(await call(cfg, fetch2, "GET", `${PATHS[tool]}?${query}`)) };
+    }
+    const willSubmit = args.submit !== false;
+    const pemFile = env.CANDLE_KEY_SIGNER_PEM_FILE?.trim();
+    let signerPem = null;
+    if (willSubmit) {
+      if (!pemFile)
+        return fail3("SIGNER_UNAVAILABLE", "Set CANDLE_KEY_SIGNER_PEM_FILE to the key signer PEM (candle tee signer new --out <pem>) to sign perps actions.");
+      try {
+        signerPem = await readFile9(pemFile, "utf8");
+        createPrivateKey2(signerPem);
+      } catch {
+        return fail3("SIGNER_UNAVAILABLE", "CANDLE_KEY_SIGNER_PEM_FILE does not hold a readable private key PEM.");
+      }
+    }
+    const { row, appId } = await walletFor(cfg, fetch2, name2, "perps:write");
+    const builder = await builderPin2(cfg, fetch2, env);
+    const { wallet: _w, submit: _s, ...fields } = args;
+    const build = await call(cfg, fetch2, "POST", PATHS[tool], {
+      walletId: row.id,
+      ...fields,
+      ...tool === "candle_perps_open" ? { type: fields.price === undefined ? "market" : "limit" } : {}
+    });
+    if (build.ready === true)
+      return { text: JSON.stringify(build) };
+    const method = PATHS[tool].split("/").at(-1);
+    const check = verifyPerpsBuild2(build, {
+      builder,
+      network: network2,
+      address: row.address,
+      intent: { method, params: fields }
+    });
+    if (!check.ok)
+      return fail3("PERPS_BUILD_REFUSED", `Refused to sign this build: ${check.reason}. Nothing was signed.`);
+    if (method === "close") {
+      const closeOrder = await hyperliquidCloseOrder2(fetch2, network2, row.address, fields);
+      const closeCheck = verifyPerpsBuild2(build, {
+        builder,
+        network: network2,
+        address: row.address,
+        intent: { method, params: fields },
+        closeOrder
+      });
+      if (!closeCheck.ok)
+        return fail3("PERPS_BUILD_REFUSED", `Refused to sign this build: ${closeCheck.reason}. Nothing was signed.`);
+    }
+    if (!willSubmit || signerPem === null)
+      return { text: JSON.stringify({ ...build, signed: false, submitted: false }) };
+    if (!appId || !row.privyWalletId)
+      return fail3("SIGNER_UNAVAILABLE", "The server did not return its relay identifiers.");
+    const body = hyperliquidRelayBody2(build.typedData);
+    const payload = hyperliquidCanonicalJson2({
+      body,
+      headers: { "privy-app-id": appId },
+      method: "POST",
+      url: `https://api.privy.io/v1/wallets/${row.privyWalletId}/rpc`,
+      version: 1
+    });
+    const authorizationSignature2 = sign5("sha256", Buffer.from(payload), signerPem).toString("base64");
+    const relay = await call(cfg, fetch2, "POST", `/api/v1/agent/wallets/${encodeURIComponent(row.id)}/sign`, {
+      authorizationSignature: authorizationSignature2,
+      body
+    });
+    const signature = relay.signature;
+    if (typeof signature !== "string" || !/^0x[0-9a-fA-F]{130}$/.test(signature))
+      return fail3("INVALID_RESPONSE", "The relay did not return a signature.");
+    const exchangeBody = hyperliquidExchangeBody2(build.action, build.nonce, signature);
+    let exchange;
+    try {
+      const res = await fetch2(HYPERLIQUID_EXCHANGE_URLS2[network2], {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(exchangeBody)
+      });
+      const text = await res.text();
+      if (!res.ok)
+        throw new Error(`HTTP ${res.status}`);
+      exchange = JSON.parse(text);
+    } catch (error) {
+      return fail3("PERPS_SUBMIT_FAILED", `Signed, but the submit to Hyperliquid failed (${error instanceof Error ? error.message : "unknown"}). POST exchangeBody to Hyperliquid's /exchange to resubmit.`, { perpOrderId: build.perpOrderId, exchangeBody });
+    }
+    const accepted = typeof exchange === "object" && exchange !== null && exchange.status === "ok" && !(exchange.response?.data?.statuses ?? []).some((status) => typeof status === "object" && status !== null && ("error" in status));
+    return {
+      text: JSON.stringify({
+        success: accepted,
+        perpOrderId: build.perpOrderId,
+        kind: build.kind,
+        network: build.network,
+        address: row.address,
+        ...build.cloid ? { cloid: build.cloid } : {},
+        ...build.childCloids ? { childCloids: build.childCloids } : {},
+        nonce: build.nonce,
+        signature,
+        exchange
+      }),
+      ...accepted ? {} : { isError: true }
+    };
+  } catch (error) {
+    if (error instanceof Refusal)
+      return error.tool;
+    return fail3("MCP_TRANSPORT", error instanceof Error ? error.message : "The perps call failed.");
+  }
+}
+function rawUnits(amount, decimals) {
+  const [whole = "", fraction = ""] = amount.split(".");
+  if (fraction.length > decimals)
+    return null;
+  const raw = BigInt(whole + fraction.padEnd(decimals, "0"));
+  return raw > 0n ? raw.toString() : null;
+}
+function pickWallet(rows, chain2, name2, what) {
+  const onChain = rows.filter((row) => row.chain === chain2);
+  const matches2 = name2 === undefined ? onChain : onChain.filter((row) => row.id === name2 || row.label === name2 || row.address.toLowerCase() === name2.toLowerCase());
+  if (matches2.length !== 1)
+    throw new Refusal(fail3("TEE_WALLET_REQUIRED", onChain.length === 0 ? `This key has no ${what} bound to it.` : `Name exactly one ${what}: ${onChain.map((row) => row.label ?? row.id).join(", ")}`));
+  return matches2[0];
+}
+function depositProblem(build, expect) {
+  const destination = build.destination ?? {};
+  const fee = build.fee ?? {};
+  const same = (a, b) => typeof a === "string" && a.toLowerCase() === b.toLowerCase();
+  if (build.walletId !== expect.walletId)
+    return "the build names another paying wallet";
+  if (build.asset !== expect.asset || build.amountRaw !== expect.amountRaw)
+    return "the build is for another amount";
+  if (destination.chainId !== HYPERLIQUID_RELAY_CHAIN_ID2)
+    return "the build does not land on Hyperliquid";
+  if (destination.currency !== HYPERLIQUID_RELAY_USDC2)
+    return "the build does not deliver Hyperliquid USDC";
+  if (!same(destination.address, expect.account))
+    return "the build lands on another account";
+  if (fee.bps !== 0 || fee.feeRaw !== "0")
+    return "the build carries a Candle fee";
+  if (expect.hood !== (build.chain === "hood"))
+    return "the build pays from the wrong chain";
+  if (!expect.hood && !(Array.isArray(build.transactionsBase64) && build.transactionsBase64.length === 1))
+    return "the build is not one Solana deposit";
+  return null;
+}
+async function executePerpsDeposit(args, cfg, env, fetch2) {
+  if (!cfg.apiKey)
+    return fail3("MCP_VALIDATION", "CANDLE_AGENT_API_KEY is required for this tool.");
+  const asset = args.asset;
+  const spec = DEPOSIT_ASSETS[asset];
+  if (!spec)
+    return fail3("MCP_VALIDATION", "asset must be SOL, USDC, ETH or USDG.");
+  const amountRaw = typeof args.amount === "string" ? rawUnits(args.amount, spec.decimals) : null;
+  if (!amountRaw)
+    return fail3("MCP_VALIDATION", `amount must be a positive ${asset} amount with at most ${spec.decimals} decimals.`);
+  const hood = spec.chain === "evm";
+  const clientDepositId = typeof args.clientDepositId === "string" ? args.clientDepositId : `deposit-${crypto.randomUUID()}`;
+  const willSubmit = args.submit !== false;
+  let signerPem = null;
+  if (willSubmit) {
+    const pemFile = env.CANDLE_KEY_SIGNER_PEM_FILE?.trim();
+    if (!pemFile)
+      return fail3("SIGNER_UNAVAILABLE", "Set CANDLE_KEY_SIGNER_PEM_FILE to the key signer PEM (candle tee signer new --out <pem>) to sign a deposit.");
+    try {
+      signerPem = await readFile9(pemFile, "utf8");
+      createPrivateKey2(signerPem);
+    } catch {
+      return fail3("SIGNER_UNAVAILABLE", "CANDLE_KEY_SIGNER_PEM_FILE does not hold a readable private key PEM.");
+    }
+  }
+  try {
+    const listed = await call(cfg, fetch2, "GET", "/api/v1/agent/wallets/trading");
+    if (!(Array.isArray(listed.scopes) && listed.scopes.includes("swap:write")))
+      throw new Refusal(fail3("SCOPE_MISSING", "A deposit needs swap:write on the key."));
+    const rows = Array.isArray(listed.page) ? listed.page : [];
+    const appId = typeof listed.privyAppId === "string" ? listed.privyAppId : "";
+    const name2 = typeof args.wallet === "string" ? args.wallet : undefined;
+    const source = pickWallet(rows, spec.chain, name2, `${hood ? "Hood" : "Solana"} TEE wallet`);
+    if (hood && args.perpsWallet !== undefined)
+      return fail3("MCP_VALIDATION", "From a Hood TEE wallet the deposit lands on that wallet's own account; omit perpsWallet.");
+    const account = hood ? source : pickWallet(rows, "evm", typeof args.perpsWallet === "string" ? args.perpsWallet : undefined, "EVM TEE wallet");
+    const build = await call(cfg, fetch2, "POST", "/api/v1/agent/perps/deposit", {
+      clientDepositId,
+      walletId: source.id,
+      asset,
+      amountRaw,
+      ...typeof args.maxSlippageBps === "number" ? { maxSlippageBps: args.maxSlippageBps } : {},
+      ...hood ? {} : { perpsWalletId: account.id }
+    });
+    if (build.job !== undefined)
+      return { text: JSON.stringify(build) };
+    const problem = depositProblem(build, { walletId: source.id, asset, amountRaw, account: account.address, hood });
+    if (problem)
+      return fail3("PERPS_BUILD_REFUSED", `Refused to sign this deposit: ${problem}. Nothing was signed.`);
+    if (!willSubmit || signerPem === null)
+      return { text: JSON.stringify({ ...build, signed: false, submitted: false }) };
+    if (!appId || !source.privyWalletId)
+      return fail3("SIGNER_UNAVAILABLE", "The server did not return its relay identifiers.");
+    const pem = signerPem;
+    const relaySign2 = async (body2) => {
+      const payload = hyperliquidCanonicalJson2({
+        body: body2,
+        headers: { "privy-app-id": appId },
+        method: "POST",
+        url: `https://api.privy.io/v1/wallets/${source.privyWalletId}/rpc`,
+        version: 1
+      });
+      const authorizationSignature2 = sign5("sha256", Buffer.from(payload), pem).toString("base64");
+      const relay = await call(cfg, fetch2, "POST", `/api/v1/agent/wallets/${encodeURIComponent(source.id)}/sign`, {
+        authorizationSignature: authorizationSignature2,
+        body: body2
+      });
+      if (typeof relay.signedTransaction !== "string")
+        throw new Refusal(fail3("INVALID_RESPONSE", "The relay did not return a signed transaction."));
+      return relay.signedTransaction;
+    };
+    const ids = { clientDepositId, depositId: build.depositId };
+    const submitPath = "/api/v1/agent/perps/deposit/submit";
+    if (!hood) {
+      const transaction = build.transactionsBase64[0];
+      const signed = await relaySign2({ method: "signTransaction", params: { encoding: "base64", transaction } });
+      return {
+        text: JSON.stringify(await call(cfg, fetch2, "POST", submitPath, { ...ids, signedTransactionsBase64: [signed] }))
+      };
+    }
+    const allowed = asset === "USDG" ? ["approval", "bridgeDeposit"] : ["bridgeDeposit"];
+    const planned = build.plannedLegCount;
+    const hex4 = (value) => `0x${BigInt(String(value)).toString(16)}`;
+    const signedKinds = new Set;
+    let body = build;
+    while (body.mode === "sequenced") {
+      const leg = body.nextLeg;
+      const kind = String(body.legKind);
+      if (!leg || body.operationId !== build.operationId || body.plannedLegCount !== planned || typeof planned !== "number" || planned > allowed.length || !allowed.includes(kind) || signedKinds.has(kind) || leg.chainId !== 4663)
+        return fail3("PERPS_BUILD_REFUSED", `Refused to sign deposit leg ${kind}: it is not the plan this deposit was built with.`, { clientDepositId, operationId: build.operationId });
+      signedKinds.add(kind);
+      const signed = await relaySign2({
+        method: "eth_signTransaction",
+        params: {
+          transaction: {
+            chain_id: leg.chainId,
+            data: leg.data,
+            from: source.address,
+            gas_limit: hex4(leg.gas),
+            max_fee_per_gas: hex4(leg.maxFeePerGas),
+            max_priority_fee_per_gas: hex4(leg.maxPriorityFeePerGas),
+            nonce: leg.nonce,
+            to: leg.to,
+            type: 2,
+            value: hex4(leg.value)
+          }
+        }
+      });
+      body = await call(cfg, fetch2, "POST", submitPath, {
+        ...ids,
+        operationId: build.operationId,
+        signedTransaction: signed
+      });
+    }
+    return { text: JSON.stringify({ ...body, clientDepositId }) };
+  } catch (error) {
+    if (error instanceof Refusal)
+      return error.tool;
+    return fail3("MCP_TRANSPORT", error instanceof Error ? error.message : "The deposit call failed.");
+  }
+}
+var decimal3, wallet, submit, perpsShapes, PATHS, Refusal, HYPERLIQUID_RELAY_CHAIN_ID2 = 1337, HYPERLIQUID_RELAY_USDC2 = "0x00000000000000000000000000000000", DEPOSIT_ASSETS, perpsDepositShape;
+var init_perps = __esm(() => {
+  init_zod();
+  init_hyperliquid();
+  decimal3 = exports_external.string().regex(/^(0|[1-9][0-9]*)(\.[0-9]+)?$/, "a plain decimal string");
+  wallet = exports_external.string().optional().describe("The EVM TEE wallet by id, address or label. Omit when the key has exactly one.");
+  submit = exports_external.boolean().optional().describe("false: build and check only, sign and submit nothing. Default true.");
+  perpsShapes = {
+    candle_perps_setup: { wallet, submit },
+    candle_perps_open: {
+      coin: exports_external.string().describe("A market on Hyperliquid's main perp exchange, e.g. BTC"),
+      side: exports_external.enum(["long", "short"]),
+      size: decimal3.describe('Size in the coin, decimal (e.g. "0.01")'),
+      price: decimal3.optional().describe("Limit price. Omit for a market order (IOC within slippageBps of the mid)."),
+      tif: exports_external.enum(["Gtc", "Alo", "Ioc"]).optional().describe("With price: time in force (default Gtc)"),
+      slippageBps: exports_external.number().int().min(1).optional(),
+      takeProfit: decimal3.optional().describe("Reduce-only take-profit trigger price"),
+      stopLoss: decimal3.optional().describe("Reduce-only stop-loss trigger price"),
+      wallet,
+      submit
+    },
+    candle_perps_close: {
+      coin: exports_external.string(),
+      size: decimal3.optional().describe("Part of the position to close; the whole position when omitted"),
+      slippageBps: exports_external.number().int().min(1).optional(),
+      wallet,
+      submit
+    },
+    candle_perps_cancel: {
+      cloid: exports_external.string().regex(/^0x[0-9a-fA-F]{32}$/).describe("The cloid of an order Candle built (an open, or one of its take-profit / stop-loss legs)"),
+      wallet,
+      submit
+    },
+    candle_perps_orders: { wallet, limit: exports_external.number().int().min(1).max(200).optional() },
+    candle_perps_positions: { wallet },
+    candle_perps_leverage: {
+      coin: exports_external.string(),
+      leverage: exports_external.number().int().min(1),
+      mode: exports_external.enum(["cross", "isolated"]).optional(),
+      wallet,
+      submit
+    }
+  };
+  PATHS = {
+    candle_perps_setup: "/api/v1/agent/perps/setup",
+    candle_perps_open: "/api/v1/agent/perps/open",
+    candle_perps_close: "/api/v1/agent/perps/close",
+    candle_perps_cancel: "/api/v1/agent/perps/cancel",
+    candle_perps_orders: "/api/v1/agent/perps/orders",
+    candle_perps_positions: "/api/v1/agent/perps/positions",
+    candle_perps_leverage: "/api/v1/agent/perps/leverage"
+  };
+  Refusal = class Refusal extends Error {
+    tool;
+    constructor(tool) {
+      super("refused");
+      this.tool = tool;
+    }
+  };
+  DEPOSIT_ASSETS = {
+    SOL: { chain: "solana", decimals: 9 },
+    USDC: { chain: "solana", decimals: 6 },
+    ETH: { chain: "evm", decimals: 18 },
+    USDG: { chain: "evm", decimals: 6 }
+  };
+  perpsDepositShape = {
+    asset: exports_external.enum(["SOL", "USDC", "ETH", "USDG"]).describe("What to deposit. SOL or USDC pay from the key's Solana TEE wallet; ETH or USDG from its Hood one."),
+    amount: decimal3.describe('Amount of the asset, decimal (e.g. "25")'),
+    wallet: exports_external.string().optional().describe("The paying TEE wallet by id, address or label. Omit when the key has exactly one on that chain."),
+    perpsWallet: exports_external.string().optional().describe("From Solana only: the EVM TEE wallet whose Hyperliquid account receives it. Omit when the key has one."),
+    clientDepositId: exports_external.string().regex(/^[A-Za-z0-9._:-]{1,128}$/).optional().describe("Idempotency id; the same id answers the deposit it already built. Default: a new one."),
+    maxSlippageBps: exports_external.number().int().min(1).max(1000).optional().describe("Relay slippage (default 100)"),
+    submit
+  };
+});
+
+// ../mcp/src/plans.ts
+function planLabel2(plan) {
+  return Object.hasOwn(PLAN_LABELS2, plan) ? PLAN_LABELS2[plan] : plan;
+}
+function formatPlanBps2(bps) {
+  return bps === 0 ? "none" : `${Number((bps / 100).toFixed(4))}%`;
+}
+function count2(n) {
+  return n.toLocaleString("en-US");
+}
+function priceCell2(entry) {
+  if (entry.price)
+    return `$${count2(entry.price.pricePerMonthUsd)} a month`;
+  return entry.plan === "free" ? "free" : "not sold";
+}
+function planTableRows2(table) {
+  const plans2 = table.plans;
+  const row = (label, cell) => [label, ...plans2.map(cell)];
+  const rows = [
+    row("Price", priceCell2),
+    row("Agent trade fee", (e) => formatPlanBps2(e.feeBps)),
+    row("Perps builder fee", (e) => formatPlanBps2(e.perpFeeBps)),
+    row("Requests per minute", (e) => count2(e.limits.rateLimitPerMin)),
+    row("Launches per day", (e) => count2(e.limits.dailyLaunchCap)),
+    row("Uploads per minute", (e) => count2(e.limits.uploadsPerMin)),
+    row("Linked wallets", (e) => count2(e.limits.linkedWallets))
+  ];
+  const known = Object.keys(PLAN_CAPABILITY_LABELS2);
+  const served = new Set;
+  for (const entry of plans2)
+    for (const key of Object.keys(entry.capabilities ?? {}))
+      served.add(key);
+  const keys = [
+    ...known.filter((k) => served.has(k)),
+    ...[...served].filter((k) => !Object.hasOwn(PLAN_CAPABILITY_LABELS2, k))
+  ];
+  for (const key of keys) {
+    const label = Object.hasOwn(PLAN_CAPABILITY_LABELS2, key) ? PLAN_CAPABILITY_LABELS2[key] : key;
+    rows.push(row(label, (e) => {
+      const value = e.capabilities?.[key];
+      return value === true ? "yes" : value === false ? "no" : "-";
+    }));
+  }
+  return { headers: ["", ...plans2.map((e) => planLabel2(e.plan))], rows };
+}
+function planPromotionLine2(table) {
+  if (!(table.promoMaxDays > 0))
+    return null;
+  const days = table.promoMaxDays === 1 ? "1 day" : `${table.promoMaxDays} days`;
+  return `A first Pro purchase includes Max for its first ${days}, then continues on Pro.`;
+}
+function planTableMarkdown(table) {
+  const { headers: headers2, rows } = planTableRows2(table);
+  const line = (cells) => `| ${cells.map((c) => c.replace(/\|/g, "\\|")).join(" | ")} |`;
+  return [line(headers2), line(headers2.map(() => "---")), ...rows.map(line)].join(`
+`);
+}
+var PLAN_CAPABILITY_NOTE2 = "A capability marked yes is what the plan allows. It is subject to the deployment's own switches (perps and own-wallet bridges each have one) and to the wallet, scopes and setup the feature needs.", PLAN_CAPABILITY_LABELS2, PLAN_LABELS2;
+var init_plans = __esm(() => {
+  PLAN_CAPABILITY_LABELS2 = {
+    tradeCandleTokens: "Trade Candle-launched tokens",
+    tradeBaseAssets: "Trade base assets",
+    freeBaseTransfers: "Base-pair swaps and own-wallet bridges (when enabled), no Candle fee",
+    sellExternalTokens: "Sell tokens not launched on Candle",
+    buyExternalTokens: "Buy tokens not launched on Candle",
+    hyperliquidPerps: "Hyperliquid perps (when enabled)",
+    selfLaunch: "Self-launch from a linked wallet",
+    atomicLaunch: "Atomic launch with first buys",
+    createLinkedWallets: "Create linked wallets",
+    importLinkedWallets: "Import linked wallets",
+    limitOrders: "Limit orders",
+    quant: "Quant on Telegram"
+  };
+  PLAN_LABELS2 = { free: "Free", believer: "Believer", pro: "Pro", max: "Max" };
+});
+
 // ../mcp/src/tools.ts
 function resolveToolAllowlist(env) {
   const raw = env.CANDLE_MCP_TOOLS?.trim();
@@ -50038,6 +51267,9 @@ function buildRequest(name2, args, cfg) {
         init: { method: "GET", headers: jsonHeaders() }
       };
     }
+    case "candle_get_plans": {
+      return { url: `${base2}/api/v1/agent/plans`, init: { method: "GET", headers: jsonHeaders() } };
+    }
     case "candle_swap": {
       const apiKey = requireApiKey2(cfg);
       return {
@@ -50107,6 +51339,22 @@ function buildRequest(name2, args, cfg) {
     }
   }
 }
+function plansMarkdown(body) {
+  try {
+    const table = JSON.parse(body);
+    if (!Array.isArray(table.plans))
+      return "";
+    const promotion = planPromotionLine2(table);
+    const markdown = `${planTableMarkdown(table)}
+
+${PLAN_CAPABILITY_NOTE2}`;
+    return promotion ? `${markdown}
+
+${promotion}` : markdown;
+  } catch {
+    return "";
+  }
+}
 async function callAndRelay(name2, args, cfg) {
   const { url, init } = buildRequest(name2, args, cfg);
   const res = await fetch(url, init);
@@ -50161,6 +51409,24 @@ MARKET_NOT_FOUND means Candle has no market for that token and this could not ru
     description: "Read a Candle user's public agent profile: whether agent features are enabled and launch counts.",
     inputSchema: getAgentProfileShape
   }, async (args) => callAndRelay("candle_get_agent_profile", args, cfg));
+  register("candle_get_plans", {
+    title: "Plans: prices, fees, limits and what each can do",
+    description: "The plan table this Candle deployment serves (GET /api/v1/agent/plans). No key needed. Reads only. For " + "each plan: price (null when not sold), feeBps (the agent fee charged on top of every trade or dev buy the " + "API builds), perpFeeBps (the Hyperliquid builder fee), limits for a new key (requests per minute, launches " + "per day, uploads per minute, linked wallets) and capabilities: buyExternalTokens, sellExternalTokens, " + "tradeBaseAssets, tradeCandleTokens, selfLaunch, atomicLaunch, createLinkedWallets, importLinkedWallets, " + "hyperliquidPerps, limitOrders, quant, freeBaseTransfers. promoMaxDays is the days of Max a first Pro " + "purchase includes (0: no promotion). Quote prices and fees from here, never from memory: they differ by " + "deployment and change at the three-plan launch (Free, Pro, Max). The account's own plan and fee are in " + "candle_execution_status's tier. A TIER_REQUIRED refusal names a capability this table shows the account's " + "plan lacks. A capability true here is plan eligibility, not deployment availability: perps and own-wallet bridges " + "are each behind a deployment switch and need their wallet, scopes and setup. Returns the server's JSON, then the same table as Markdown.",
+    inputSchema: {}
+  }, async () => {
+    const { url, init } = buildRequest("candle_get_plans", {}, cfg);
+    const res = await fetch(url, init);
+    noteVersionHeaders(res);
+    const text = await res.text();
+    if (!res.ok)
+      return { content: [{ type: "text", text }], isError: true };
+    return {
+      content: [
+        { type: "text", text },
+        { type: "text", text: plansMarkdown(text) }
+      ]
+    };
+  });
   register("candle_get_operation", {
     title: "What happened to a write",
     description: "Look up a trade or launch by the id its write used, and find out whether it landed. " + `Reads only; moves nothing.
@@ -50191,7 +51457,7 @@ MARKET_NOT_FOUND means Candle has no market for that token and this could not ru
   }, async (args) => callAndRelay("candle_set_profile_wallets", args, cfg));
   register("candle_get_profile_pnl", {
     title: "Read an agent profile's P&L",
-    description: "Realized profit for this profile's own fills, the Candle fees charged against it, and the " + "positions it still holds with their cost basis, each MARKED at Candle's current price where one " + "exists: `markPriceUsd`, `marketValueUsd` and `unrealizedUsd` per position, and `unrealizedUsd` " + "overall. A position with no price is counted in `unmarkedPositions` and left out of unrealized, " + "never valued at zero; `oldestMarkAt` says how old the marks are. Deposits, withdrawals and " + "transfers are excluded: funding a wallet is not profit. Check `unvalued` and `truncated` before " + "quoting the number; they mean the total is partial. `pnl.byWallet` splits the same fills by the " + "wallet that paid for each trade (main or linked, with the linked wallet's label), one row per " + "wallet with the same figures, for tracking one strategy per wallet. Each row is an independent " + "average-cost pool over its own fills, so the rows need not sum to the total (a token moved " + "between wallets, or two wallets holding one token at different costs); the total stays correct. " + "Every open position and every `byWallet` row (and its positions) carries `chain` ('solana' or " + "'hood'), and `pnl.byChain` has the total's figures over each chain's fills alone, both chains " + "always present, with `openPositions` there a count (the positions are in `pnl.openPositions`, by " + "`chain`). Each chain is its own average-cost pool, so the two need not sum exactly to the total. A " + "server that predates per-chain P&L omits `chain` and `byChain`. Reads only.",
+    description: "This profile's share of the account's P&L: realized profit on the sales it made, the Candle fees " + "charged against it, and the positions that belong to it (the wallet's bound key, else the key " + "whose buy opened them) with their cost basis, each MARKED at Candle's current price where one " + "exists: `markPriceUsd`, `marketValueUsd` and `unrealizedUsd` per position, and `unrealizedUsd` " + "overall. A position with no price is counted in `unmarkedPositions` and left out of unrealized, " + "never valued at zero; `oldestMarkAt` says how old the marks are. Deposits and withdrawals are " + "excluded: funding a wallet is not profit. Check `unvalued` and `truncated` before quoting the " + "number; they mean the total is partial. The figures come from the account's one P&L read, the " + "same as the console's, to the cent: `pnl.totalUsd` (realized net plus unrealized) is the " + "console's P&L. Positions live in wallets: each wallet is its own average-cost pool, the total " + "is the sum of `pnl.byWallet` (one row per wallet, main or linked, with the linked wallet's " + "label; `unknown:solana` or `unknown:hood` is the row for fills no record places in a wallet), " + "and one token held in two wallets is two positions, each with its `wallet`. A recorded move " + "between the account's wallets carries its cost and realizes nothing. Each position carries " + "`agent` (the key it belongs to) and `dust` when it is worth under one cent; dust stays listed " + "and counted, and `openPositionsExDust` leaves it out. `closed` gives the closed positions as " + "`madeUsd` + `lostUsd` + `partialSellsUsd` = `realizedNetUsd`, with `wins` and `losses`. " + "`lookback` and `truncated` are the account's activity bound, and `tradesConsidered` counts this " + "key's ledger fills. Since 2026-10-02 the total is the sum of wallets rather than one pool across " + "them, so realized figures can differ from earlier reads; a server that predates it omits " + "`totalUsd`, `closed`, `openPositionsExDust`, `wallet`, `agent` and `dust`. " + "Every open position and every `byWallet` row (and its positions) carries `chain` ('solana' or " + "'hood'), and `pnl.byChain` has the total's figures over each chain's fills alone, both chains " + "always present, with `openPositions` there a count (the positions are in `pnl.openPositions`, by " + "`chain`). The two chains sum to the total. A " + "server that predates per-chain P&L omits `chain` and `byChain`. While Hyperliquid is enabled, " + "`hyperliquid` separately reports main-perp realized gross, signed funding, fees (inclusive of builder fees), " + "and net = gross + funding - fees, for currently bound EVM TEE wallets since the current TEE binding. " + "Check `read` and `truncated`; historical bindings and unrealized perps are excluded. Reads only.",
     inputSchema: profilePnlShape
   }, async (args) => callAndRelay("candle_get_profile_pnl", args, cfg));
   register("candle_get_profile_trades", {
@@ -50261,6 +51527,8 @@ MARKET_NOT_FOUND means Candle has no market for that token and this could not ru
 
 ` + "Arguments: `mint` and `side` are required. Amounts are DECIMAL, never raw base units " + '(amount: "0.5", not lamports). Omitting the amount on a sell sells the whole ' + `position.
 
+` + "Plans: every plan can buy and sell Candle-launched tokens and base assets, and SELL a token it holds that " + "Candle did not launch. BUYING such a token needs Pro or Max (TIER_REQUIRED otherwise). Each trade pays the " + `plan's agent fee on top (feeBps in candle_get_plans).
+
 ` + "Pass `paper: true` to rehearse: every admission rule runs and the quote is recorded, but " + "nothing broadcasts and no funds move. A paper buy credits this key's paper inventory, " + "including for external Solana mints routed through Jupiter. A later sell by amount or " + "percent closes that book without reading the live wallet and without MARKET_NOT_FOUND " + "-- including when `paper` is omitted on the exit, as long as the paper position exists. " + "Do this before the first live trade of a new strategy, and whenever you are unsure a " + `trade would be admitted at all.
 
 ` + `After the call:
@@ -50279,12 +51547,62 @@ MARKET_NOT_FOUND means Candle has no market for that token and this could not ru
     const result = await executeLaunchAndSeed(args, cfg, fetch);
     return { content: [{ type: "text", text: result.text }], ...result.isError ? { isError: true } : {} };
   });
+  const perpsTool = (tool) => async (args) => {
+    const result = await executePerps(tool, args, cfg, env, fetch);
+    return { content: [{ type: "text", text: result.text }], ...result.isError ? { isError: true } : {} };
+  };
+  const perpsWrite = " MOVES REAL FUNDS on Hyperliquid unless submit is false. Candle builds the action within this key's limits " + "(USD window, maximum leverage, maximum position, slippage and price bands, main-exchange markets only); this " + "server recomputes its hash and checks the action type and Candle's builder before signing, then submits it to " + "Hyperliquid itself. Needs perps:write on the key and CANDLE_KEY_SIGNER_PEM_FILE. A refusal names the limit " + "that refused it (error.limit).";
+  register("candle_perps_setup", {
+    title: "Set up Hyperliquid perps",
+    description: "Approve Candle's Hyperliquid builder fee (0.1%) once for the key's EVM TEE wallet, and report the " + "account's mode and balance. Idempotent: nothing is signed when the approval is already on Hyperliquid." + perpsWrite,
+    inputSchema: perpsShapes.candle_perps_setup
+  }, perpsTool("candle_perps_setup"));
+  register("candle_perps_open", {
+    title: "Open a perps position",
+    description: "Open or add to a perpetual position on Hyperliquid's main perp exchange: a market order (IOC within " + "slippageBps of the mid) without `price`, a limit order with it, and optional reduce-only takeProfit and " + "stopLoss triggers. Every plan except Max pays Candle a builder fee on each order (0.1% today; perpFeeBps in " + "candle_get_plans); Max pays none." + perpsWrite,
+    inputSchema: perpsShapes.candle_perps_open
+  }, perpsTool("candle_perps_open"));
+  register("candle_perps_close", {
+    title: "Close a perps position",
+    description: "Close all or part of a position with a reduce-only IOC order. It reserves nothing, so a key at its USD " + "cap can still close." + perpsWrite,
+    inputSchema: perpsShapes.candle_perps_close
+  }, perpsTool("candle_perps_close"));
+  register("candle_perps_cancel", {
+    title: "Cancel a perps order",
+    description: "Cancel an order Candle built, by its cloid (from candle_perps_open or candle_perps_orders)." + perpsWrite,
+    inputSchema: perpsShapes.candle_perps_cancel
+  }, perpsTool("candle_perps_cancel"));
+  register("candle_perps_orders", {
+    title: "Perps orders",
+    description: "Open orders on Hyperliquid for the key's EVM TEE wallet, and every action Candle built for it with what " + "the venue shows. Reads only; moves nothing.",
+    inputSchema: perpsShapes.candle_perps_orders
+  }, perpsTool("candle_perps_orders"));
+  register("candle_perps_positions", {
+    title: "Perps positions",
+    description: "Positions, account value and withdrawable balance on Hyperliquid for the key's EVM TEE wallet, read " + "live by its address. Reads only; moves nothing.",
+    inputSchema: perpsShapes.candle_perps_positions
+  }, perpsTool("candle_perps_positions"));
+  register("candle_perps_leverage", {
+    title: "Set perps leverage",
+    description: "Set a market's leverage and margin mode (cross or isolated) on the account, within the key's maximum leverage." + perpsWrite,
+    inputSchema: perpsShapes.candle_perps_leverage
+  }, perpsTool("candle_perps_leverage"));
+  register("candle_perps_deposit", {
+    title: "Deposit to Hyperliquid",
+    description: "MOVES REAL FUNDS unless submit is false. Deposit onto the key's Hyperliquid account through Relay: SOL or " + "USDC from its Solana TEE wallet, or ETH or USDG from its Hood TEE wallet, credited as Hyperliquid perps " + "USDC at the key's EVM TEE wallet's own address (Candle resolves it; no recipient is taken). Refused below a " + "floor that covers Hyperliquid's 1 USDC first-deposit charge. No Candle fee. Needs swap:write and a raw cap " + "on the asset, and CANDLE_KEY_SIGNER_PEM_FILE to sign. There is no withdrawal from Hyperliquid yet.",
+    inputSchema: perpsDepositShape
+  }, async (args) => {
+    const result = await executePerpsDeposit(args, cfg, env, fetch);
+    return { content: [{ type: "text", text: result.text }], ...result.isError ? { isError: true } : {} };
+  });
 }
 var TOOL_NAMES, launchTokenShape, getMarketShape, tokenForensicsShape, getFeedShape, reportActivityShape, getAgentProfileShape, getOperationShape, resolveTokenShape, profileWalletsShape, profilePnlShape, profileTradesShape, setProfileWalletsShape, swapShape, tradeShape, _rawBuyAmount, seedableLaunchShape, launchAndSeedShape, transferShape, sweepShape;
 var init_tools = __esm(() => {
   init_zod();
   init_convert();
   init_orchestrate();
+  init_perps();
+  init_plans();
   init_update_notice();
   TOOL_NAMES = [
     "candle_launch_token",
@@ -50293,6 +51611,7 @@ var init_tools = __esm(() => {
     "candle_token_forensics",
     "candle_report_activity",
     "candle_get_agent_profile",
+    "candle_get_plans",
     "candle_trade",
     "candle_launch_and_seed",
     "candle_swap",
@@ -50306,7 +51625,15 @@ var init_tools = __esm(() => {
     "candle_get_portfolio",
     "candle_resolve_token",
     "candle_execution_status",
-    "candle_get_operation"
+    "candle_get_operation",
+    "candle_perps_setup",
+    "candle_perps_open",
+    "candle_perps_close",
+    "candle_perps_cancel",
+    "candle_perps_orders",
+    "candle_perps_positions",
+    "candle_perps_leverage",
+    "candle_perps_deposit"
   ];
   launchTokenShape = {
     clientLaunchId: exports_external.string().describe("Caller-chosen idempotency key, unique per account"),
@@ -50382,7 +51709,7 @@ var init_tools = __esm(() => {
     side: exports_external.enum(["buy", "sell"]),
     amount: exports_external.string().optional().describe("Decimal amount. Buys: how much of THIS TOKEN'S OWN quote asset to spend (SOL for a " + 'SOL-launched token, USDC for a USDC-quoted one, and so on: e.g. "0.5"). Sells: how many ' + "TOKENS to sell. Pass exactly one of amount or percent."),
     percent: exports_external.number().optional().describe("Sells only: sell this percent (integer 1-100) of the holding. Live trades size against the " + "embedded wallet. Paper trades (`paper: true`) size against this key's paper inventory -- " + "the position a previous paper buy credited -- because paper never moves the live wallet."),
-    quoteAsset: exports_external.string().optional().describe('What the wallet spends on a buy or receives on a sell: "sol", "usdc" or "cndl" on Solana, ' + '"eth" or "usdg" on Hood. Safe to pass through from candle_quote. On Solana it applies only ' + "to an arbitrary mint Candle never launched (Pro/Max) and is ignored for a Candle token, " + "whose quote comes from the token itself. On Hood it is the settlement asset of a DEX " + "trade; a USDG buy adds an approval transaction an ETH buy does not. It is not the route: " + "the cheapest path to the asset is chosen separately. Defaults to sol / ETH settlement."),
+    quoteAsset: exports_external.string().optional().describe('What the wallet spends on a buy or receives on a sell: "sol", "usdc" or "cndl" on Solana, ' + '"eth" or "usdg" on Hood. Echoing the `quoteAsset` a quote (POST /api/v1/trade/agent/quote) returned is safe. On Solana it applies only ' + "to an arbitrary mint Candle never launched (a buy needs Pro or Max; a sell works on any plan) and is ignored for a Candle token, " + "whose quote comes from the token itself. On Hood it is the settlement asset of a DEX " + "trade; a USDG buy adds an approval transaction an ETH buy does not. It is not the route: " + "the cheapest path to the asset is chosen separately. Defaults to sol / ETH settlement."),
     maxSlippageBps: exports_external.number().optional().describe("Max slippage in basis points; API default applies when omitted"),
     clientTradeId: exports_external.string().optional().describe("Idempotency key. Auto-generated when omitted and echoed in the result. Retrying with the " + "SAME id is safe (idempotent replay); a new id is a SECOND trade."),
     paper: exports_external.preprocess((value) => value === "true" || value === 1 || value === "1" ? true : value === "false" || value === 0 || value === "0" ? false : value, exports_external.boolean().optional().describe("Rehearse instead of trading. The request passes every admission rule a live trade passes " + "-- the same planner, spend gate, key cap and loss limits -- and records the quote, but " + "nothing is ever broadcast and no funds move. Use it to check that a strategy is admitted " + "before risking anything on it. A paper fill is optimistic by construction: it books the " + "quoted price, so the gap between a paper arm and a live one IS the execution cost. " + "A sell of a mint this key already paper-bought also closes that paper book when the " + "live wallet is empty, even if this flag is omitted."))
@@ -50432,12 +51759,13 @@ async function runStdioServer(env = process.env, transport = new StdioServerTran
 }
 var INSTRUCTIONS = `Candle is a trading and token-launch rail for agents. You hold a scoped API key, never a private key; signing and funding stay with the key owner's wallet.
 
-START HERE — five tools need NO credential. Call these first to confirm the server is wired before asking anyone for anything:
+START HERE — six tools need NO credential. Call these first to confirm the server is wired before asking anyone for anything:
   candle_get_market       price, market cap, volume, curve state for one token
   candle_get_feed         the roster: hot streak, new pairs, graduated, blue chip
   candle_resolve_token    a ticker or partial name -> mint address + chain
   candle_token_forensics  call this before quoting or buying. Returns the on-chain developer (never a launchpad shared authority; deployer.attribution names the launchpad or issuer when no developer is on chain), their went-to-zero rate and last coins, who bought in the deploy window (strangers in the same slot are the bundle signal), same-funder insider share, same-funder cluster, and safety.summary with six sourced flags. Refuse an unprompted buy when flagged; incomplete or unknown is not clearance. launch.deployerLaunches is an inclusive informational count, never a warning
   candle_get_agent_profile  your own tier, caps and verified activity
+  candle_get_plans        every plan's price, fees, limits and what it can do; quote these, never from memory
 
 COVERAGE — read this before you treat an error as a broken server.
 candle_get_feed indexes the wider market (pump.fun, pons.family and other external launchpads).
@@ -50481,7 +51809,7 @@ var init_server2 = __esm(() => {
 // src/index.ts
 import { spawn as spawn3 } from "node:child_process";
 import { realpathSync } from "node:fs";
-import { chmod as chmod8, readFile as readFile9, realpath, rename as rename6, unlink, writeFile as writeFile7 } from "node:fs/promises";
+import { chmod as chmod8, readFile as readFile10, realpath, rename as rename6, unlink, writeFile as writeFile7 } from "node:fs/promises";
 import { homedir as homedir6, hostname } from "node:os";
 import { pathToFileURL } from "node:url";
 
@@ -50529,7 +51857,7 @@ init_render();
 init_secret_store();
 
 // src/version.ts
-var CLI_VERSION = "0.11.13";
+var CLI_VERSION = "0.11.15";
 
 // src/commands/auth.ts
 init_keys_embedded_wallet();
@@ -50945,6 +52273,11 @@ var ENVIRONMENT = [
     name: "CANDLE_ENCLAVE_HELPER",
     description: "Path to the signed candle-enclave.app helper (macOS)"
   },
+  {
+    name: "CANDLE_HYPERLIQUID_BUILDER",
+    description: "candle perps: Candle's Hyperliquid builder address, pinned for the check every build passes before it is signed; without it the release's, else the one the server reports"
+  },
+  { name: "CANDLE_HYPERLIQUID_NETWORK", description: "candle perps: set to testnet to trade Hyperliquid testnet" },
   { name: "CANDLE_NO_UPDATE_NOTIFIER", description: "Set to 1 to silence the update notice" },
   {
     name: "CANDLE_KEYSTORE_PASSPHRASE",
@@ -51017,7 +52350,7 @@ var HELP = {
   doctor: {
     group: "Start here",
     summary: "Diagnose CLI setup: credentials, storage backend, API reachability, security key helper",
-    description: "One PASS/FAIL/SKIP table over the runtime, the storage backend, both credentials, API reachability, wallet delegation, the install method and whether the security key helper (candle-fido2) is beside the binary. Its output is meant to be pasted into a bug report. Exits nonzero on any FAIL.",
+    description: "One PASS/FAIL/SKIP table over the runtime, the storage backend, both credentials, API reachability, wallet delegation, the install method, the account's plan and its trade fee, and whether the security key helper (candle-fido2) is beside the binary. Its output is meant to be pasted into a bug report. Exits nonzero on any FAIL.",
     usage: ["candle doctor [--role owner|bot|auto]"],
     rows: [],
     examples: ["candle doctor", "candle doctor --json"],
@@ -51026,7 +52359,7 @@ var HELP = {
   swap: {
     group: "Trade",
     summary: "Quote, confirm and swap on Solana or Hood, bridge between them; read an operation by id",
-    description: "Swaps run through a TEE wallet's bound key: the quote is shown and confirmed before anything is sent, and the first buy after a launch is this command rather than part of the launch. The assets decide the chain (ETH, USDG or a 0x token is Hood; SOL, USDC, CNDL or a mint is Solana) and a named wallet must be on it. A Hood TEE wallet signs one leg at a time: approve, Permit2, trade, then the fee, each only after the one before it landed. SOL or USDC to ETH or USDG, or back, is a bridge through Relay from a TEE wallet into this key's own TEE wallet on the other chain (--to names it when there are several); Candle charges no fee, the key needs a raw cap on the origin asset, and this machine checks Relay's deposit before it is signed. The bridge prints its deposit and returns while Relay fills; --wait follows it for up to ten minutes. While it is open, a sweep of either wallet refuses BRIDGE_IN_FLIGHT for two hours. Vault to vault: fund the Solana TEE wallet from the vault, bridge, then disable and sweep the Hood TEE wallet into its vault.",
+    description: "Swaps run through a TEE wallet's bound key: the quote is shown and confirmed before anything is sent, and the first buy after a launch is this command rather than part of the launch. The assets decide the chain (ETH, USDG or a 0x token is Hood; SOL, USDC, CNDL or a mint is Solana) and a named wallet must be on it. A Hood TEE wallet signs one leg at a time: approve, Permit2, trade, then the fee, each only after the one before it landed. SOL or USDC to ETH or USDG, or back, is a bridge through Relay from a TEE wallet into this key's own TEE wallet on the other chain (--to names it when there are several); Candle charges no fee, the key needs a raw cap on the origin asset, and this machine checks Relay's deposit before it is signed. The bridge prints its deposit and returns while Relay fills; --wait follows it for up to ten minutes. While it is open, a sweep of either wallet refuses BRIDGE_IN_FLIGHT for two hours. Vault to vault: fund the Solana TEE wallet from the vault, bridge, then disable and sweep the Hood TEE wallet into its vault. Every plan can trade Candle-launched tokens and base assets, and sell a token it holds that was not launched on Candle; buying such a token needs Pro or Max (TIER_REQUIRED otherwise). Each trade pays the plan's agent fee on top; a base-pair swap or a bridge between this key's own wallets pays none. candle plans shows the fees in force.",
     usage: ["candle swap <from> <to> [flags]", "candle swap status <id>"],
     rows: [
       {
@@ -51090,6 +52423,64 @@ var HELP = {
     ],
     env: ENV_API
   },
+  perps: {
+    group: "Trade",
+    summary: "Hyperliquid perpetuals from your EVM TEE wallet: setup, deposit, open, close, cancel, orders, positions, leverage",
+    description: "Trade perpetuals on Hyperliquid's main perp exchange from the EVM TEE wallet bound to this key (scope perps:write, opt-in). Candle builds each action within the key's limits; this machine recomputes its hash and checks the action type and Candle's builder before anything is signed, then Candle's relay signs and this machine submits to Hyperliquid. Every plan is eligible for perps, once the deployment has perps enabled. Every plan except Max pays Candle a builder fee on each order (0.1% today); Max pays none. candle plans shows the rate in force. Deposits move SOL, USDC, ETH or USDG onto the Hyperliquid account through Relay, and the account's P&L (candle pnl) carries a Hyperliquid section.",
+    usage: ["candle perps <subcommand> [flags]"],
+    rows: [
+      {
+        invocation: "setup [--wallet <tee>]",
+        description: "Approve Candle's builder fee once; shows the account's mode and balance"
+      },
+      {
+        invocation: "deposit <amount> <SOL|USDC|ETH|USDG> [--wallet <tee>] [--to <evm tee>] | deposit status <id>",
+        description: "Move funds onto the Hyperliquid account through Relay, from the key's Solana or Hood TEE wallet (swap:write); status reads one"
+      },
+      {
+        invocation: "open <coin> <long|short> <size> [--price <px>]",
+        description: "Market (IOC) without --price, limit with it; optional --tp and --sl"
+      },
+      { invocation: "close <coin> [--size <n>]", description: "Reduce-only IOC close of all or part of a position" },
+      { invocation: "cancel <cloid>", description: "Cancel an order Candle built, by its cloid" },
+      {
+        invocation: "orders [--wallet <tee>]",
+        description: "Open orders on Hyperliquid, and every action Candle built"
+      },
+      { invocation: "positions [--wallet <tee>]", description: "Positions and account value, read live" },
+      { invocation: "leverage <coin> <x> [--isolated]", description: "Set a market's leverage and margin mode" }
+    ],
+    flags: [
+      {
+        invocation: "--wallet <tee>",
+        description: "The EVM TEE wallet by id, address or unique label (default: the only one); for deposit, the paying TEE wallet"
+      },
+      { invocation: "--tif <Gtc|Alo|Ioc>", description: "open with --price: time in force (default Gtc)" },
+      {
+        invocation: "--slippage-bps <n>",
+        description: "open at market and close: the bound against the mid; deposit: Relay's slippage (default 100)"
+      },
+      { invocation: "--tp <px> / --sl <px>", description: "open: reduce-only take-profit and stop-loss triggers" },
+      {
+        invocation: "--to <evm tee>",
+        description: "deposit from Solana: the EVM TEE wallet whose account receives it"
+      },
+      { invocation: "--id <clientDepositId>", description: "deposit: the idempotency id (default: a new one)" },
+      { invocation: "--rpc-url <url>", description: "deposit from Solana: the RPC the deposit check reads" },
+      { invocation: "--no-submit", description: "Build and check only; sign and submit nothing" },
+      { invocation: "--sign-only", description: "Build, check and sign through the relay; submit nothing" },
+      { invocation: "--yes", description: "Skip the confirmation prompt" }
+    ],
+    examples: [
+      "candle perps setup",
+      "candle perps deposit 25 USDC",
+      "candle perps open BTC long 0.01",
+      "candle perps open ETH short 0.5 --price 3200 --tp 2900 --sl 3400",
+      "candle perps close BTC",
+      "candle perps leverage BTC 5 --isolated"
+    ],
+    env: [...ENV_API, "CANDLE_HYPERLIQUID_BUILDER", "CANDLE_HYPERLIQUID_NETWORK"]
+  },
   transfer: {
     group: "Trade",
     summary: "Move funds out of a TEE wallet to your own wallets or its vault, through its bound key",
@@ -51127,7 +52518,7 @@ var HELP = {
   launch: {
     group: "Trade",
     summary: "Create a token on Solana or Hood (the first buy is a separate swap)",
-    description: "Creates a token with no first buy, so the launch and the position are two decisions rather than one. Needs the launch:write scope and an operator-enabled allowLaunch. The wallet decides the chain: a Hood TEE wallet launches on Hood, needs --dex-version, and signs one leg at a time (the curve, then the fee), each only after the one before it landed.",
+    description: "Creates a token with no first buy, so the launch and the position are two decisions rather than one. Needs the launch:write scope and an operator-enabled allowLaunch. The wallet decides the chain: a Hood TEE wallet launches on Hood, needs --dex-version, and signs one leg at a time (the curve, then the fee), each only after the one before it landed. Launching from a TEE wallet needs Pro or Max (TIER_REQUIRED otherwise; candle plans).",
     usage: [
       "candle launch --name <name> --symbol <symbol> --image-url <url> --wallet <tee> [--quote-asset <asset>] [--dex-version v3|v4]"
     ],
@@ -51151,29 +52542,47 @@ var HELP = {
   },
   portfolio: {
     group: "Account",
-    summary: "Every wallet's holdings, prices and value in one table (vault read over your own RPC)",
-    description: "Vault, TEE and embedded wallets, each token with amount, price and value, then a total. TEE and embedded balances come from Candle; vault and external wallets are read over your own RPC, and Candle is sent only the mints they hold, for prices. Unpriced tokens are shown as unpriced and left out of the total. Where Candle serves LP, each TEE wallet's DAMM v2 positions follow the tokens (share of the pool plus unclaimed fees, valued by Candle at the same marks) and count in the total; a position whose pool could not be read is shown as not read and the total says it is partial.",
-    usage: ["candle portfolio [--rpc-url <url>] [--json]"],
+    summary: "Every wallet's holdings, prices and value on Solana and Hood (vault read over your own RPCs)",
+    description: "Vault, TEE and embedded wallets on Solana and Hood, each token with its chain, amount, price and value, then subtotals per group and per chain and one total. TEE and embedded balances, on both chains, come from Candle. Solana vault and external wallets are read over your own Solana RPC, and Candle is sent only the mints they hold, for prices. EVM vault keys are read over your own EVM RPC for ETH and USDG only (the CLI cannot list other tokens), which must be Hood's (chain id 4663); any other chain is refused. Their prices come from Candle by asset (ETH, USDG), never by address. Unpriced tokens are shown as unpriced with the reason (no-market-row, stale-mark, unusable-price, source-unavailable) and left out of the total. A wallet that could not be read in full is marked not read, the footer names its chain, and the exit is 3. Where Candle serves LP, each Solana TEE wallet's DAMM v2 positions follow the tokens (share of the pool plus unclaimed fees, valued by Candle at the same marks) and count in the total; a position whose pool could not be read is shown as not read and the total says it is partial. A bridge moves value between the chain subtotals; it is not a trade.",
+    usage: ["candle portfolio [--chain solana|hood] [--rpc-url <url>] [--evm-rpc-url <url>] [--json]"],
     rows: [],
     flags: [
+      { invocation: "--chain solana|hood", description: "Show one chain, and read nothing on the other" },
       {
         invocation: "--rpc-url <url>",
         description: "Your Solana RPC, for the vault. Without one: CANDLE_SOLANA_RPC_URL, then the profile's, then the public endpoint"
       },
+      {
+        invocation: "--evm-rpc-url <url>",
+        description: "Your Hood RPC, for EVM vault keys. Without one: CANDLE_EVM_RPC_URL, then the built-in Hood RPC"
+      },
       KEYSTORE_FLAG
     ],
-    examples: ["candle portfolio", "candle portfolio --rpc-url https://your-rpc.example --json"],
+    examples: [
+      "candle portfolio",
+      "candle portfolio --chain hood",
+      "candle portfolio --rpc-url https://your-rpc.example --evm-rpc-url https://your-hood-rpc.example --json"
+    ],
     env: [...ENV_API, ...ENV_LOCAL_SIGNING]
   },
   pnl: {
     group: "Account",
-    summary: "P&L: realized, fees, unrealized and open positions (--profile for one key's own)",
-    description: "Without --profile, the account's books: every profile, the web app and the CLI, one ledger, the same figures the web P&L chart shows. Needs a key with the Read scope (account:read). With --profile <name>, that profile's key reads its own P&L. Unpriced positions are shown as unpriced and never valued at zero. Where Candle serves LP, DAMM v2 positions are included: realized (withdrawals against the cost basis at the add, plus claimed fees), unrealized (open positions at their share of the pool plus unclaimed fees, against that basis), and vs holding (what the deposited tokens would be worth held); the total then covers tokens and LP.",
+    summary: "P&L per chain and combined: realized, fees, unrealized and open positions (--profile for one key's share)",
+    description: "Without --profile, the account's books: every profile, the web app and the CLI, one ledger, the same figures the console shows, to the cent for the same moment. Needs a key with the Read scope (account:read). With --profile <name>, that profile's key reads its share of the same P&L: realized on the sales it made, and the open positions that belong to it (the wallet's bound key, else the key whose buy opened them), with a row per wallet that sums to the total. Positions live in wallets: each wallet is its own average-cost pool, the account is the sum of its wallets, and a recorded move between two of the account's wallets carries its cost and realizes nothing. Both show a Solana block, a Hood block, then the combined figure, the closed positions as money made, minus money lost, plus partial sells, and a CHAIN column (and WALLET, where the API names it) on positions. The account's books add a By agent table (each key, then Manual for web-app trades, then the account total). Unpriced positions are shown as unpriced and never valued at zero; a position worth under one cent is marked dust and still counted. A bridge between Solana and Hood is not a trade: it opens and closes nothing, and bridge and Relay costs are not netted from P&L. Where Candle serves LP, DAMM v2 positions are included: realized (withdrawals against the cost basis at the add, plus claimed fees), unrealized (open positions at their share of the pool plus unclaimed fees, against that basis), and vs holding (what the deposited tokens would be worth held); Total stays the console's token figure, and Total with LP covers tokens and LP.",
     usage: ["candle pnl [--profile <name>] [--json]"],
     rows: [],
     examples: ["candle pnl", "candle pnl --profile scalper --json"],
     env: ENV_API
   },
+  plans: {
+    group: "Account",
+    summary: "The plans this API serves: prices, fees, limits and what each can do",
+    description: "The plan table in force on the API this profile points at (GET /api/v1/agent/plans): each plan's monthly price, the agent trade fee, the Hyperliquid perps builder fee, the limits a new key gets, and one row per capability (buying and selling tokens not launched on Candle, self-launch, atomic launch, linked wallets, perps, limit orders). Every number is the server's; the CLI bundles none. Needs no key and sends none. Which plan this account is on is candle doctor's Plan row.",
+    usage: ["candle plans [--json]"],
+    rows: [],
+    examples: ["candle plans", "candle plans --json", "candle plans --api-url https://staging.api.candle.tv"],
+    env: ["CANDLE_API_URL"]
+  },
   keys: {
     group: "Account",
     summary: "API keys, and the wallets each key may use",
@@ -51583,9 +52992,16 @@ var HELP = {
     group: "Maintain",
     summary: "Verify a release asset's Sigstore bundle",
     description: "Verifies a release asset against the trusted root compiled into this binary. No network, no credentials, and nothing else installed: the bundle carries the certificate and the transparency-log entry.",
-    usage: ["candle verify <file> --bundle <path>"],
+    usage: ["candle verify <file> --bundle <path> [--identity <uri>] [--issuer <url>]"],
     rows: [],
-    flags: [{ invocation: "--bundle <path>", description: "The .sigstore.json bundle beside the asset" }],
+    flags: [
+      { invocation: "--bundle <path>", description: "The .sigstore.json bundle beside the asset" },
+      {
+        invocation: "--identity <uri>",
+        description: "The signing identity to require; defaults to the release identity for the version in a latest.json beside the bundle"
+      },
+      { invocation: "--issuer <url>", description: "The certificate issuer to require; defaults to GitHub Actions'" }
+    ],
     examples: ["candle verify ./candle-darwin-arm64 --bundle ./candle-darwin-arm64.sigstore.json"]
   },
   completion: {
@@ -58957,6 +60373,7 @@ var MCP_TOOL_NAMES = [
   "candle_get_feed",
   "candle_token_forensics",
   "candle_get_agent_profile",
+  "candle_get_plans",
   "candle_report_activity",
   "candle_trade",
   "candle_swap",
@@ -58970,14 +60387,23 @@ var MCP_TOOL_NAMES = [
   "candle_get_portfolio",
   "candle_resolve_token",
   "candle_execution_status",
-  "candle_get_operation"
+  "candle_get_operation",
+  "candle_perps_setup",
+  "candle_perps_open",
+  "candle_perps_close",
+  "candle_perps_cancel",
+  "candle_perps_orders",
+  "candle_perps_positions",
+  "candle_perps_leverage",
+  "candle_perps_deposit"
 ];
 var READ_ONLY_TOOL_NAMES = [
   "candle_get_market",
   "candle_get_feed",
   "candle_token_forensics",
   "candle_get_agent_profile",
-  "candle_resolve_token"
+  "candle_resolve_token",
+  "candle_get_plans"
 ];
 var CREDENTIAL_ENV_NAMES = [
   "CANDLE_API_KEY",
@@ -59078,6 +60504,1141 @@ async function mcp(args, ctx) {
   }
 }
 
+// src/commands/perps.ts
+init_args();
+init_bridge();
+init_evm_lite();
+import { randomUUID as randomUUID4, sign as sign3 } from "node:crypto";
+
+// src/hyperliquid.ts
+init_sha3();
+var HYPERLIQUID_ALLOWED_ACTION_TYPES = [
+  "order",
+  "cancel",
+  "modify",
+  "updateLeverage",
+  "updateIsolatedMargin"
+];
+var HYPERLIQUID_EXCHANGE_URLS = {
+  mainnet: "https://api.hyperliquid.xyz/exchange",
+  testnet: "https://api.hyperliquid-testnet.xyz/exchange"
+};
+var CANDLE_HYPERLIQUID_BUILDER_ADDRESS = null;
+var HYPERLIQUID_MAX_BUILDER_FEE_TENTHS_BPS = 100;
+var HYPERLIQUID_MAX_BUILDER_FEE_RATE = "0.1%";
+var HYPERLIQUID_SIGNATURE_CHAIN_ID = "0xa4b1";
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var UINT64_MAX = (1n << 64n) - 1n;
+var INT64_MIN = -(1n << 63n);
+function pushUint(out, value, width) {
+  for (let i = width - 1;i >= 0; i--)
+    out.push(Number(value >> BigInt(i * 8) & 0xffn));
+}
+function packInteger(out, value) {
+  if (value >= 0n) {
+    if (value > UINT64_MAX)
+      throw new Error("msgpack: integer above uint64");
+    if (value < 0x80n)
+      out.push(Number(value));
+    else if (value <= 0xffn) {
+      out.push(204);
+      pushUint(out, value, 1);
+    } else if (value <= 0xffffn) {
+      out.push(205);
+      pushUint(out, value, 2);
+    } else if (value <= 0xffffffffn) {
+      out.push(206);
+      pushUint(out, value, 4);
+    } else {
+      out.push(207);
+      pushUint(out, value, 8);
+    }
+    return;
+  }
+  if (value < INT64_MIN)
+    throw new Error("msgpack: integer below int64");
+  if (value >= -32n)
+    out.push(Number(value & 0xffn));
+  else if (value >= -128n) {
+    out.push(208);
+    pushUint(out, value & 0xffn, 1);
+  } else if (value >= -32768n) {
+    out.push(209);
+    pushUint(out, value & 0xffffn, 2);
+  } else if (value >= -2147483648n) {
+    out.push(210);
+    pushUint(out, value & 0xffffffffn, 4);
+  } else {
+    out.push(211);
+    pushUint(out, value & UINT64_MAX, 8);
+  }
+}
+function packHeader(out, length, fixBase, fixMax, codes) {
+  if (length <= fixMax) {
+    out.push(fixBase | length);
+    return;
+  }
+  const [c8, c16, c32] = codes;
+  if (c8 !== undefined && c8 !== 0 && length <= 255) {
+    out.push(c8);
+    pushUint(out, BigInt(length), 1);
+  } else if (length <= 65535) {
+    out.push(c16);
+    pushUint(out, BigInt(length), 2);
+  } else {
+    out.push(c32);
+    pushUint(out, BigInt(length), 4);
+  }
+}
+function packValue(out, value) {
+  if (value === null)
+    out.push(192);
+  else if (value === false)
+    out.push(194);
+  else if (value === true)
+    out.push(195);
+  else if (typeof value === "bigint")
+    packInteger(out, value);
+  else if (typeof value === "number") {
+    if (!Number.isSafeInteger(value))
+      throw new Error(`msgpack: ${value} is not a safe integer`);
+    packInteger(out, BigInt(value));
+  } else if (typeof value === "string") {
+    const bytes = new TextEncoder().encode(value);
+    packHeader(out, bytes.length, 160, 31, [217, 218, 219]);
+    for (const b of bytes)
+      out.push(b);
+  } else if (Array.isArray(value)) {
+    packHeader(out, value.length, 144, 15, [0, 220, 221]);
+    for (const item of value)
+      packValue(out, item);
+  } else if (typeof value === "object") {
+    const entries = Object.entries(value).filter(([, v]) => v !== undefined);
+    for (const [key] of entries) {
+      if (/^(0|[1-9][0-9]*)$/.test(key))
+        throw new Error(`msgpack: integer-like key "${key}"`);
+    }
+    packHeader(out, entries.length, 128, 15, [0, 222, 223]);
+    for (const [key, item] of entries) {
+      packValue(out, key);
+      packValue(out, item);
+    }
+  } else {
+    throw new Error(`msgpack: cannot encode a ${typeof value}`);
+  }
+}
+function msgpackEncode(value) {
+  const out = [];
+  packValue(out, value);
+  return Uint8Array.from(out);
+}
+function toHex(bytes) {
+  let out = "";
+  for (const b of bytes)
+    out += b.toString(16).padStart(2, "0");
+  return out;
+}
+function hyperliquidActionHash(action, nonce) {
+  const n = BigInt(nonce);
+  if (n < 0n || n > UINT64_MAX)
+    throw new Error("hyperliquidActionHash: nonce out of range");
+  const out = Array.from(msgpackEncode(action));
+  pushUint(out, n, 8);
+  out.push(0);
+  return `0x${toHex(keccak_256(Uint8Array.from(out)))}`;
+}
+function hyperliquidL1TypedData(connectionId, network) {
+  return {
+    domain: { name: "Exchange", version: "1", chainId: 1337, verifyingContract: ZERO_ADDRESS },
+    types: {
+      Agent: [
+        { name: "source", type: "string" },
+        { name: "connectionId", type: "bytes32" }
+      ]
+    },
+    primary_type: "Agent",
+    message: { source: network === "mainnet" ? "a" : "b", connectionId }
+  };
+}
+function hyperliquidApproveBuilderFeeTypedData(builder, nonce) {
+  return {
+    domain: { name: "HyperliquidSignTransaction", version: "1", chainId: 42161, verifyingContract: ZERO_ADDRESS },
+    types: {
+      "HyperliquidTransaction:ApproveBuilderFee": [
+        { name: "hyperliquidChain", type: "string" },
+        { name: "maxFeeRate", type: "string" },
+        { name: "builder", type: "address" },
+        { name: "nonce", type: "uint64" }
+      ]
+    },
+    primary_type: "HyperliquidTransaction:ApproveBuilderFee",
+    message: {
+      hyperliquidChain: "Mainnet",
+      maxFeeRate: HYPERLIQUID_MAX_BUILDER_FEE_RATE,
+      builder: builder.toLowerCase(),
+      nonce
+    }
+  };
+}
+function hyperliquidCanonicalJson(value) {
+  return canonical(value);
+}
+function canonical(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value);
+  if (Array.isArray(value))
+    return `[${value.map(canonical).join(",")}]`;
+  const record = value;
+  return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonical(record[key])}`).join(",")}}`;
+}
+function sameValue(a, b) {
+  return canonical(a) === canonical(b);
+}
+var EVM_ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
+function checkBuilderField(action, builder) {
+  if (!("builder" in action) || action.builder === undefined)
+    return null;
+  const field = action.builder;
+  if (typeof field !== "object" || field === null)
+    return "builder field is not an object";
+  if (typeof field.b !== "string" || field.b.toLowerCase() !== builder.toLowerCase()) {
+    return "the order names a builder that is not Candle's";
+  }
+  if (typeof field.f !== "number" || !Number.isInteger(field.f) || field.f <= 0 || field.f > HYPERLIQUID_MAX_BUILDER_FEE_TENTHS_BPS) {
+    return "the builder fee is outside Candle's 0.1% maximum";
+  }
+  return null;
+}
+function decimal(value) {
+  if (typeof value !== "string" || !/^-?(0|[1-9][0-9]*)(\.[0-9]{1,18})?$/.test(value))
+    return null;
+  const negative = value.startsWith("-");
+  const [whole = "0", frac = ""] = (negative ? value.slice(1) : value).split(".");
+  const n = BigInt(whole) * 10n ** 18n + BigInt(frac.padEnd(18, "0"));
+  return negative ? -n : n;
+}
+function checkActionIntent(action, intent) {
+  const mainAsset = (a) => typeof a === "number" && Number.isInteger(a) && a >= 0 && a < 1e4;
+  const orderList = action.type === "order" ? action.orders : action.type === "modify" ? [action.order] : [];
+  if (!Array.isArray(orderList))
+    return "invalid orders";
+  for (const raw of orderList) {
+    if (!raw || typeof raw !== "object")
+      return "invalid order";
+    const o = raw;
+    if (!mainAsset(o.a))
+      return "order asset is outside the main perp universe";
+    if (typeof o.b !== "boolean" || typeof o.r !== "boolean" || (decimal(o.s) ?? 0n) <= 0n || (decimal(o.p) ?? 0n) <= 0n)
+      return "invalid order side, size, price or reduce-only flag";
+  }
+  if (action.type === "cancel") {
+    if (!Array.isArray(action.cancels) || action.cancels.length !== 1 || !mainAsset(action.cancels[0]?.a))
+      return "invalid cancel asset";
+  }
+  if ((action.type === "updateLeverage" || action.type === "updateIsolatedMargin") && !mainAsset(action.asset))
+    return "invalid action asset";
+  if (!intent)
+    return null;
+  const { method, params: p } = intent;
+  const types2 = {
+    setup: "approveBuilderFee",
+    open: "order",
+    close: "order",
+    cancel: "cancel",
+    modify: "modify",
+    leverage: "updateLeverage",
+    margin: "updateIsolatedMargin"
+  };
+  if (action.type !== types2[method])
+    return "action type does not match the requested method";
+  if (method === "leverage") {
+    if (action.leverage !== p.leverage || action.isCross !== (p.mode !== "isolated"))
+      return "leverage or mode does not match the request";
+  }
+  if (method === "margin") {
+    const amount = decimal(p.amount);
+    if (amount === null || amount % 10n ** 12n !== 0n || !Number.isSafeInteger(action.ntli) || BigInt(action.ntli) !== amount / 10n ** 12n || action.isBuy !== true)
+      return "isolated margin amount does not match the request";
+  }
+  if (method === "open" || method === "close" || method === "modify") {
+    const list = orderList;
+    const first = list[0];
+    if (!first)
+      return "missing requested order";
+    const typ = first.t;
+    if (!typ?.limit)
+      return "requested order is not a limit/IOC order";
+    if (method === "open") {
+      const buy = p.side === "long" || p.side === "buy";
+      if (first.b !== buy || first.r !== false || decimal(first.s) !== decimal(p.size))
+        return "order side, size or reduce-only flag does not match the request";
+      const tif = (p.type ?? (p.price === undefined ? "market" : "limit")) === "market" ? "Ioc" : p.tif ?? "Gtc";
+      if (typ.limit.tif !== tif)
+        return "order time in force does not match the request";
+      const triggers = [
+        ["takeProfit", "tp"],
+        ["stopLoss", "sl"]
+      ].filter(([field]) => p[field] != null);
+      if (list.length !== 1 + triggers.length || action.grouping !== (triggers.length ? "normalTpsl" : "na"))
+        return "unexpected extra orders or grouping";
+      for (let i = 0;i < triggers.length; i++) {
+        const [field, kind] = triggers[i];
+        const leg = list[i + 1];
+        if (!leg)
+          return "missing trigger order";
+        const trigger = leg.t?.trigger;
+        if (leg.a !== first.a || leg.b !== !buy || leg.r !== true || decimal(leg.s) !== decimal(p.size) || trigger?.tpsl !== kind || trigger.isMarket !== true || decimal(trigger.triggerPx) !== decimal(p[field]))
+          return "trigger side, size, reduce-only flag or price does not match the request";
+      }
+    } else {
+      if (list.length !== 1)
+        return "unexpected extra orders";
+      if (method === "close" && (first.r !== true || typ.limit.tif !== "Ioc" || p.size != null && (decimal(first.s) ?? 0n) > (decimal(p.size) ?? 0n)))
+        return "close size or reduce-only flag does not match the request";
+      if (method === "modify" && p.size != null && decimal(first.s) !== decimal(p.size))
+        return "replacement size does not match the request";
+    }
+    if (p.price != null && decimal(first.p) !== decimal(p.price))
+      return "order price does not match the request";
+  }
+  return null;
+}
+async function hyperliquidCloseOrder(fetcher, network, address, params) {
+  const read = async (body) => {
+    const res = await fetcher(HYPERLIQUID_EXCHANGE_URLS[network].replace("/exchange", "/info"), {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok)
+      throw new Error("Cannot read the close position from Hyperliquid");
+    return JSON.parse(await res.text());
+  };
+  const [meta, state] = await Promise.all([read({ type: "meta" }), read({ type: "clearinghouseState", user: address })]);
+  const coin = String(params.coin).toUpperCase();
+  const asset = meta.universe.findIndex((m) => m.name.toUpperCase() === coin);
+  const szi = state.assetPositions.find((p) => p.position.coin.toUpperCase() === coin)?.position.szi;
+  const signed = decimal(szi);
+  if (asset < 0 || asset >= 1e4 || signed === null || signed === 0n)
+    throw new Error("No main-universe position to close");
+  const held = signed < 0n ? -signed : signed;
+  const asked = params.size == null ? held : decimal(params.size);
+  if (asked === null || asked <= 0n)
+    throw new Error("Invalid close size");
+  const size = asked < held ? String(params.size) : String(szi).replace(/^-/, "");
+  return { asset, isBuy: signed < 0n, size };
+}
+function verifyPerpsBuild(build, opts) {
+  try {
+    const network = opts.network ?? "mainnet";
+    if (!EVM_ADDRESS_RE.test(opts.builder))
+      return { ok: false, reason: "no valid Candle builder address to check against" };
+    if (build.network !== undefined && build.network !== network) {
+      return { ok: false, reason: `the build is for ${build.network}, this client trades ${network}` };
+    }
+    if (opts.address && build.address && build.address.toLowerCase() !== opts.address.toLowerCase()) {
+      return { ok: false, reason: "the build is for a different wallet" };
+    }
+    if (!Number.isSafeInteger(build.nonce) || build.nonce <= 0)
+      return { ok: false, reason: "invalid nonce" };
+    const typed = build.typedData;
+    if (!typed || typeof typed !== "object")
+      return { ok: false, reason: "no typed data" };
+    const action = build.action;
+    if (!action || typeof action !== "object")
+      return { ok: false, reason: "no action" };
+    const intentRefusal = checkActionIntent(action, opts.intent);
+    if (intentRefusal)
+      return { ok: false, reason: intentRefusal };
+    if (opts.closeOrder) {
+      const order = action.orders[0];
+      if (!order || order.a !== opts.closeOrder.asset || order.b !== opts.closeOrder.isBuy || decimal(order.s) !== decimal(opts.closeOrder.size) || order.r !== true)
+        return { ok: false, reason: "close side, asset or size does not match the requested position" };
+    }
+    if (typed.primary_type === "Agent") {
+      const type = action.type;
+      if (typeof type !== "string" || !HYPERLIQUID_ALLOWED_ACTION_TYPES.includes(type)) {
+        return { ok: false, reason: `action type ${String(type)} is not one Candle builds` };
+      }
+      if (type === "order") {
+        const refusal = checkBuilderField(action, opts.builder);
+        if (refusal)
+          return { ok: false, reason: refusal };
+      } else if ("builder" in action) {
+        return { ok: false, reason: `a ${type} action carries no builder` };
+      }
+      if ("vaultAddress" in action)
+        return { ok: false, reason: "the action names a vault" };
+      const expected = hyperliquidL1TypedData(hyperliquidActionHash(action, build.nonce), network);
+      if (!sameValue(typed, expected)) {
+        return { ok: false, reason: "the typed data does not commit to this action and nonce" };
+      }
+      return { ok: true, kind: "l1" };
+    }
+    if (typed.primary_type === "HyperliquidTransaction:ApproveBuilderFee") {
+      const expected = hyperliquidApproveBuilderFeeTypedData(opts.builder, build.nonce);
+      if (!sameValue(typed, expected)) {
+        return { ok: false, reason: "the builder approval is not Candle's builder at 0.1% on Mainnet" };
+      }
+      const expectedAction = {
+        type: "approveBuilderFee",
+        hyperliquidChain: "Mainnet",
+        signatureChainId: HYPERLIQUID_SIGNATURE_CHAIN_ID,
+        maxFeeRate: HYPERLIQUID_MAX_BUILDER_FEE_RATE,
+        builder: opts.builder.toLowerCase(),
+        nonce: build.nonce
+      };
+      if (!sameValue(action, expectedAction)) {
+        return { ok: false, reason: "the approval action does not match its typed data" };
+      }
+      return { ok: true, kind: "approveBuilderFee" };
+    }
+    return { ok: false, reason: `primary type ${String(typed.primary_type)} is not one the relay signs` };
+  } catch (err) {
+    return { ok: false, reason: err instanceof Error ? err.message : "unreadable build" };
+  }
+}
+function hyperliquidSplitSignature(signature) {
+  if (!/^0x[0-9a-fA-F]{130}$/.test(signature))
+    throw new Error("Not a 65-byte signature");
+  let v = Number.parseInt(signature.slice(130, 132), 16);
+  if (v < 27)
+    v += 27;
+  return { r: `0x${signature.slice(2, 66)}`, s: `0x${signature.slice(66, 130)}`, v };
+}
+function hyperliquidExchangeBody(action, nonce, signature) {
+  return { action, nonce, signature: hyperliquidSplitSignature(signature), vaultAddress: null, expiresAfter: null };
+}
+function hyperliquidRelayBody(typedData) {
+  return { method: "eth_signTypedData_v4", params: { typed_data: typedData } };
+}
+
+// src/commands/perps.ts
+init_render();
+init_trading();
+var PERPS_SCOPE = "perps:write";
+var DEC_RE = /^(0|[1-9][0-9]*)(\.[0-9]+)?$/;
+var CLOID_RE = /^0x[0-9a-fA-F]{32}$/;
+function usage4(ctx, line) {
+  writeUsageFailure(ctx.deps, line, ctx.json);
+  return 2;
+}
+async function perpsRequest(ctx, key, path, body) {
+  const result = await apiRequest(path, {
+    apiUrl: ctx.apiUrl,
+    credentials: { apiKey: key },
+    auth: "key",
+    method: body ? "POST" : "GET",
+    body,
+    fetch: ctx.deps.fetch,
+    env: ctx.deps.env
+  });
+  if (!result.ok) {
+    if (result.status === 404 && !result.code)
+      throw new TradingError("PERPS_NOT_ENABLED", "This Candle deployment does not serve perps routes (HYPERLIQUID_ENABLED is off there, or the API predates them).");
+    throw new TradingError(result.code ?? "REQUEST_FAILED", result.message);
+  }
+  if (!result.body || typeof result.body !== "object")
+    throw new TradingError("INVALID_RESPONSE", "Candle returned an invalid response.");
+  return result.body;
+}
+function network(ctx) {
+  return ctx.deps.env.CANDLE_HYPERLIQUID_NETWORK === "testnet" ? "testnet" : "mainnet";
+}
+async function builderPin(ctx, key) {
+  const pinned = ctx.deps.env.CANDLE_HYPERLIQUID_BUILDER ?? CANDLE_HYPERLIQUID_BUILDER_ADDRESS;
+  if (pinned) {
+    if (!/^0x[0-9a-fA-F]{40}$/.test(pinned))
+      throw new TradingError("INVALID_ADDRESS", "CANDLE_HYPERLIQUID_BUILDER must be an EVM address.");
+    return pinned.toLowerCase();
+  }
+  const config = await perpsRequest(ctx, key, "/api/v1/agent/perps/config");
+  if (typeof config.builder !== "string")
+    throw new TradingError("PERPS_NOT_CONFIGURED", "The server reports no Hyperliquid builder address.");
+  return config.builder.toLowerCase();
+}
+async function perpsWallet(ctx, key, name2, scope) {
+  const { rows, appId, keyPrefix } = await listTradingWallets(ctx, key, scope);
+  const evm = rows.filter((row2) => row2.chain === "evm");
+  const matches = name2 === undefined ? evm : evm.filter((row2) => matchesName(row2, name2));
+  if (matches.length !== 1) {
+    throw new TradingError("TEE_WALLET_REQUIRED", evm.length === 0 ? "This key has no EVM TEE wallet bound to it. Hyperliquid perps sign only from one." : matches.length === 0 ? `No EVM TEE wallet on this key is called "${name2}". Bound to this key: ${evm.map(describeWallet).join("; ")}.` : `Name one EVM TEE wallet with --wallet: ${matches.map(describeWallet).join("; ")}.`);
+  }
+  const row = matches[0];
+  if (scope === undefined)
+    return { row };
+  const wallet = await completeTradingWallet(ctx, row, appId, scope, "hood", {
+    apiKey: key,
+    ...keyPrefix !== undefined ? { keyPrefix } : {}
+  });
+  return { row, wallet };
+}
+function typedDataAuthorization(wallet, typedData) {
+  const body = hyperliquidRelayBody(typedData);
+  const payload = hyperliquidCanonicalJson({
+    body,
+    headers: { "privy-app-id": wallet.appId },
+    method: "POST",
+    url: `https://api.privy.io/v1/wallets/${wallet.privyWalletId}/rpc`,
+    version: 1
+  });
+  return { body, authorizationSignature: sign3("sha256", Buffer.from(payload), wallet.signer).toString("base64") };
+}
+function previewLines(build) {
+  const action = build.action;
+  if (action.type === "approveBuilderFee")
+    return [`Approve Candle's builder ${safeText(action.builder)} at ${safeText(action.maxFeeRate)} (once).`];
+  if (action.type === "cancel")
+    return action.cancels.map((o) => `Cancel asset ${o.a} order ${o.o}.`);
+  if (action.type === "updateLeverage")
+    return [
+      `Set asset ${safeText(action.asset)} to ${safeText(action.leverage)}x ${action.isCross ? "cross" : "isolated"}.`
+    ];
+  const orders = action.type === "modify" ? [action.order] : action.orders;
+  const lines = orders.map((o) => {
+    const type = o.t;
+    return `${action.type === "modify" ? "Modify to" : o.r ? "Close" : "Open"} ${o.b ? "buy" : "sell"} ${safeText(o.s)} asset ${safeText(o.a)} at ${safeText(o.p)}${type.limit ? ` (${safeText(type.limit.tif)})` : ` (${safeText(type.trigger?.tpsl)} trigger ${safeText(type.trigger?.triggerPx)})`}${o.r ? ", reduce-only" : ""}.`;
+  });
+  const builder = action.builder;
+  lines.push(builder ? `Candle builder ${safeText(builder.b)} fee: ${builder.f / 10} bps.` : "Candle builder fee: none.");
+  return lines;
+}
+async function confirm(ctx, build, address, yes) {
+  const output = ctx.json ? ctx.deps.stderr : ctx.deps.stdout;
+  output.write(`Hyperliquid account: ${safeText(address)} (${safeText(build.network)})
+`);
+  for (const line of previewLines(build))
+    output.write(`${line}
+`);
+  if (yes)
+    return true;
+  if (!ctx.deps.isTTY.stdin)
+    throw new TradingError("CONFIRMATION_REQUIRED", "Run interactively to confirm, or use --yes.");
+  return (await ctx.deps.promptLine("Sign and submit? [y/N] ")).trim().toLowerCase() === "y";
+}
+function venueRefusal(exchange) {
+  if (!exchange || typeof exchange !== "object")
+    return "Hyperliquid returned no answer.";
+  const answer = exchange;
+  if (answer.status !== "ok")
+    return `Hyperliquid refused it: ${safeText(JSON.stringify(answer.response ?? answer))}`;
+  const statuses = answer.response?.data?.statuses;
+  for (const status of statuses ?? []) {
+    if (status && typeof status === "object" && "error" in status)
+      return `Hyperliquid refused the order: ${safeText(status.error)}`;
+  }
+  return null;
+}
+async function runPerpsWrite(ctx, opts) {
+  const key = await tradingKey(ctx);
+  const { wallet } = await perpsWallet(ctx, key, opts.wallet, PERPS_SCOPE);
+  if (!wallet)
+    throw new TradingError("TEE_WALLET_REQUIRED", "No EVM TEE wallet resolved.");
+  const builder = await builderPin(ctx, key);
+  const build = await perpsRequest(ctx, key, opts.path, { walletId: wallet.id, ...opts.body });
+  if (build.ready === true)
+    return printTradingResult(ctx, build);
+  const net = network(ctx);
+  const method = opts.path.split("/").at(-1);
+  const check = verifyPerpsBuild(build, {
+    builder,
+    network: net,
+    address: wallet.address,
+    intent: { method, params: opts.body }
+  });
+  if (!check.ok)
+    throw new TradingError("PERPS_BUILD_REFUSED", `Refused to sign this build: ${check.reason}. Nothing was signed.`);
+  if (method === "close") {
+    const closeOrder = await hyperliquidCloseOrder(ctx.deps.fetch, net, wallet.address, opts.body);
+    const closeCheck = verifyPerpsBuild(build, {
+      builder,
+      network: net,
+      address: wallet.address,
+      intent: { method, params: opts.body },
+      closeOrder
+    });
+    if (!closeCheck.ok)
+      throw new TradingError("PERPS_BUILD_REFUSED", `Refused to sign this build: ${closeCheck.reason}. Nothing was signed.`);
+  }
+  if (!opts.submit)
+    return printTradingResult(ctx, { ...build, signed: false, submitted: false });
+  if (!await confirm(ctx, build, wallet.address, opts.yes)) {
+    throw new TradingError("CANCELLED", "Nothing was signed.");
+  }
+  const relay = await perpsRequest(ctx, key, `/api/v1/agent/wallets/${encodeURIComponent(wallet.id)}/sign`, typedDataAuthorization(wallet, build.typedData));
+  const signature = relay.signature;
+  if (typeof signature !== "string" || !/^0x[0-9a-fA-F]{130}$/.test(signature))
+    throw new TradingError("INVALID_RESPONSE", "The relay did not return a signature.");
+  const exchangeBody = hyperliquidExchangeBody(build.action, build.nonce, signature);
+  if (opts.signOnly)
+    return printTradingResult(ctx, {
+      success: true,
+      perpOrderId: build.perpOrderId,
+      kind: build.kind,
+      network: build.network,
+      address: wallet.address,
+      nonce: build.nonce,
+      signature,
+      submitted: false,
+      exchangeBody
+    });
+  let exchange;
+  try {
+    const res = await ctx.deps.fetch(HYPERLIQUID_EXCHANGE_URLS[net], {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(exchangeBody)
+    });
+    const text = await res.text();
+    if (!res.ok)
+      throw new Error(`HTTP ${res.status}`);
+    exchange = JSON.parse(text);
+  } catch (error) {
+    throw new TradingError("PERPS_SUBMIT_FAILED", `Signed, but the submit to Hyperliquid failed (${error instanceof Error ? error.message : "unknown"}). The signed action is in details.exchangeBody; nothing was lost.`, { exitCode: 3, details: { perpOrderId: build.perpOrderId, exchangeBody } });
+  }
+  const refusal = venueRefusal(exchange);
+  if (refusal)
+    throw new TradingError("PERPS_VENUE_REFUSED", refusal, {
+      details: { perpOrderId: build.perpOrderId, exchange }
+    });
+  return printTradingResult(ctx, {
+    success: true,
+    perpOrderId: build.perpOrderId,
+    kind: build.kind,
+    network: build.network,
+    address: wallet.address,
+    ...build.cloid ? { cloid: build.cloid } : {},
+    ...build.childCloids ? { childCloids: build.childCloids } : {},
+    nonce: build.nonce,
+    signature,
+    exchange
+  });
+}
+var WRITE_FLAGS = { valueFlags: ["--wallet"], booleanFlags: ["--yes", "--no-submit", "--sign-only"] };
+function sharedWrite(values, booleans) {
+  return {
+    ...values["--wallet"] !== undefined ? { wallet: values["--wallet"] } : {},
+    yes: booleans.has("--yes"),
+    submit: !booleans.has("--no-submit"),
+    signOnly: booleans.has("--sign-only")
+  };
+}
+function slippage(value) {
+  if (value === undefined)
+    return;
+  const n = Number(value);
+  return Number.isInteger(n) && n >= 1 ? n : null;
+}
+async function perpsSetup(args, ctx) {
+  const parsed = parseArgs(args, WRITE_FLAGS);
+  if ("error" in parsed)
+    return usage4(ctx, parsed.error);
+  if (parsed.positionals.length !== 0)
+    return usage4(ctx, "Usage: candle perps setup [--wallet <tee>] [--yes]");
+  try {
+    return await runPerpsWrite(ctx, {
+      path: "/api/v1/agent/perps/setup",
+      body: {},
+      ...sharedWrite(parsed.values, parsed.booleans)
+    });
+  } catch (error) {
+    return tradingFailure(ctx, error);
+  }
+}
+var OPEN_USAGE = "Usage: candle perps open <coin> <long|short> <size> [--price <px>] [--tif Gtc|Alo|Ioc] [--slippage-bps <n>] [--tp <px>] [--sl <px>] [--wallet <tee>] [--yes]";
+async function perpsOpen(args, ctx) {
+  const parsed = parseArgs(args, {
+    valueFlags: ["--wallet", "--price", "--tif", "--slippage-bps", "--tp", "--sl"],
+    booleanFlags: ["--yes", "--no-submit", "--sign-only"]
+  });
+  if ("error" in parsed)
+    return usage4(ctx, parsed.error);
+  const [coin, side, size] = parsed.positionals;
+  if (parsed.positionals.length !== 3 || !coin || !side || !size)
+    return usage4(ctx, OPEN_USAGE);
+  if (side !== "long" && side !== "short")
+    return usage4(ctx, OPEN_USAGE);
+  if (!DEC_RE.test(size))
+    return usage4(ctx, "The size must be a plain decimal, e.g. 0.01.");
+  const { values } = parsed;
+  for (const flag of ["--price", "--tp", "--sl"]) {
+    const value = values[flag];
+    if (value !== undefined && !DEC_RE.test(value))
+      return usage4(ctx, `${flag} must be a plain decimal.`);
+  }
+  const tif = values["--tif"];
+  if (tif !== undefined && !["Gtc", "Alo", "Ioc"].includes(tif))
+    return usage4(ctx, "--tif must be Gtc, Alo or Ioc.");
+  if (tif !== undefined && tif !== "Ioc" && values["--price"] === undefined)
+    return usage4(ctx, "--tif Gtc or Alo needs --price.");
+  const slippageBps = slippage(values["--slippage-bps"]);
+  if (slippageBps === null)
+    return usage4(ctx, "--slippage-bps must be a whole number of at least 1.");
+  const body = {
+    coin,
+    side,
+    size,
+    type: values["--price"] === undefined ? "market" : "limit",
+    ...values["--price"] !== undefined ? { price: values["--price"] } : {},
+    ...tif !== undefined && values["--price"] !== undefined ? { tif } : {},
+    ...slippageBps !== undefined ? { slippageBps } : {},
+    ...values["--tp"] !== undefined ? { takeProfit: values["--tp"] } : {},
+    ...values["--sl"] !== undefined ? { stopLoss: values["--sl"] } : {}
+  };
+  try {
+    return await runPerpsWrite(ctx, { path: "/api/v1/agent/perps/open", body, ...sharedWrite(values, parsed.booleans) });
+  } catch (error) {
+    return tradingFailure(ctx, error);
+  }
+}
+async function perpsClose(args, ctx) {
+  const parsed = parseArgs(args, {
+    valueFlags: ["--wallet", "--size", "--slippage-bps"],
+    booleanFlags: ["--yes", "--no-submit", "--sign-only"]
+  });
+  if ("error" in parsed)
+    return usage4(ctx, parsed.error);
+  const [coin] = parsed.positionals;
+  if (parsed.positionals.length !== 1 || !coin)
+    return usage4(ctx, "Usage: candle perps close <coin> [--size <n>] [--slippage-bps <n>] [--wallet <tee>] [--yes]");
+  const size = parsed.values["--size"];
+  if (size !== undefined && !DEC_RE.test(size))
+    return usage4(ctx, "--size must be a plain decimal.");
+  const slippageBps = slippage(parsed.values["--slippage-bps"]);
+  if (slippageBps === null)
+    return usage4(ctx, "--slippage-bps must be a whole number of at least 1.");
+  const body = {
+    coin,
+    ...size !== undefined ? { size } : {},
+    ...slippageBps !== undefined ? { slippageBps } : {}
+  };
+  try {
+    return await runPerpsWrite(ctx, {
+      path: "/api/v1/agent/perps/close",
+      body,
+      ...sharedWrite(parsed.values, parsed.booleans)
+    });
+  } catch (error) {
+    return tradingFailure(ctx, error);
+  }
+}
+async function perpsCancel(args, ctx) {
+  const parsed = parseArgs(args, WRITE_FLAGS);
+  if ("error" in parsed)
+    return usage4(ctx, parsed.error);
+  const [cloid] = parsed.positionals;
+  if (parsed.positionals.length !== 1 || !cloid || !CLOID_RE.test(cloid))
+    return usage4(ctx, "Usage: candle perps cancel <cloid> [--wallet <tee>] [--yes]  (cloid: 0x + 32 hex)");
+  try {
+    return await runPerpsWrite(ctx, {
+      path: "/api/v1/agent/perps/cancel",
+      body: { cloid: cloid.toLowerCase() },
+      ...sharedWrite(parsed.values, parsed.booleans)
+    });
+  } catch (error) {
+    return tradingFailure(ctx, error);
+  }
+}
+async function perpsLeverage(args, ctx) {
+  const parsed = parseArgs(args, {
+    valueFlags: ["--wallet"],
+    booleanFlags: ["--yes", "--no-submit", "--sign-only", "--isolated"]
+  });
+  if ("error" in parsed)
+    return usage4(ctx, parsed.error);
+  const [coin, leverage] = parsed.positionals;
+  const n = Number(leverage);
+  if (parsed.positionals.length !== 2 || !coin || !Number.isInteger(n) || n < 1)
+    return usage4(ctx, "Usage: candle perps leverage <coin> <x> [--isolated] [--wallet <tee>] [--yes]");
+  try {
+    return await runPerpsWrite(ctx, {
+      path: "/api/v1/agent/perps/leverage",
+      body: { coin, leverage: n, mode: parsed.booleans.has("--isolated") ? "isolated" : "cross" },
+      ...sharedWrite(parsed.values, parsed.booleans)
+    });
+  } catch (error) {
+    return tradingFailure(ctx, error);
+  }
+}
+async function perpsPositions(args, ctx) {
+  const parsed = parseArgs(args, { valueFlags: ["--wallet"] });
+  if ("error" in parsed)
+    return usage4(ctx, parsed.error);
+  if (parsed.positionals.length !== 0)
+    return usage4(ctx, "Usage: candle perps positions [--wallet <tee>]");
+  try {
+    const key = await tradingKey(ctx);
+    const { row } = await perpsWallet(ctx, key, parsed.values["--wallet"]);
+    const result = await perpsRequest(ctx, key, `/api/v1/agent/perps/positions?walletId=${encodeURIComponent(row.id)}`);
+    if (ctx.json)
+      return printTradingResult(ctx, result);
+    const out = ctx.deps.stdout;
+    const account = result.account ?? {};
+    out.write(`${safeText(result.address)} (${safeText(result.network)}, ${safeText(result.mode)} mode): account value ${safeText(account.accountValue)} USD, withdrawable ${safeText(result.withdrawable)} USD
+`);
+    const positions = result.positions ?? [];
+    if (positions.length === 0)
+      out.write(`No open positions.
+`);
+    for (const p of positions) {
+      const leverage = p.leverage ?? {};
+      out.write(`  ${safeText(p.coin)} ${safeText(p.szi)} at ${safeText(p.entryPx)}, value ${safeText(p.positionValue)}, uPnL ${safeText(p.unrealizedPnl)}, ${safeText(leverage.value)}x ${safeText(leverage.type)}, liq ${safeText(p.liquidationPx ?? "none")}
+`);
+    }
+    return 0;
+  } catch (error) {
+    return tradingFailure(ctx, error);
+  }
+}
+async function perpsOrders(args, ctx) {
+  const parsed = parseArgs(args, { valueFlags: ["--wallet", "--limit"] });
+  if ("error" in parsed)
+    return usage4(ctx, parsed.error);
+  const limit = parsed.values["--limit"];
+  if (parsed.positionals.length !== 0 || limit !== undefined && !/^[1-9][0-9]{0,2}$/.test(limit))
+    return usage4(ctx, "Usage: candle perps orders [--wallet <tee>] [--limit <n>]");
+  try {
+    const key = await tradingKey(ctx);
+    const { row } = await perpsWallet(ctx, key, parsed.values["--wallet"]);
+    const query = new URLSearchParams({ walletId: row.id });
+    if (limit !== undefined)
+      query.set("limit", limit);
+    const result = await perpsRequest(ctx, key, `/api/v1/agent/perps/orders?${query}`);
+    if (ctx.json)
+      return printTradingResult(ctx, result);
+    const out = ctx.deps.stdout;
+    const open4 = result.open ?? [];
+    out.write(`Open on Hyperliquid (${open4.length}):
+`);
+    for (const o of open4) {
+      out.write(`  ${safeText(o.coin)} ${o.side === "B" ? "buy" : "sell"} ${safeText(o.sz)} at ${safeText(o.limitPx)}${o.reduceOnly ? " reduce-only" : ""}${o.isTrigger ? ` trigger ${safeText(o.triggerPx)}` : ""}, cloid ${safeText(o.cloid ?? "none")}
+`);
+    }
+    const recorded = result.recorded ?? [];
+    out.write(`Built by Candle (${recorded.length}, newest first):
+`);
+    for (const r of recorded) {
+      out.write(`  ${safeText(r.kind)} ${safeText(r.coin ?? "")} ${safeText(r.status)}${r.venueStatus ? ` (${safeText(r.venueStatus)})` : ""}${r.cloid ? `, cloid ${safeText(r.cloid)}` : ""}${r.targetCloid ? `, target ${safeText(r.targetCloid)}` : ""}
+`);
+    }
+    return 0;
+  } catch (error) {
+    return tradingFailure(ctx, error);
+  }
+}
+var HYPERLIQUID_RELAY_CHAIN_ID = 1337;
+var HYPERLIQUID_RELAY_USDC = "0x00000000000000000000000000000000";
+var DEPOSIT_ID_RE = /^[A-Za-z0-9._:-]{1,128}$/;
+var DEPOSIT_USAGE = "Usage: candle perps deposit <amount> <SOL|USDC|ETH|USDG> [--wallet <tee>] [--to <evm tee>] [--id <clientDepositId>] [--slippage-bps <n>] [--rpc-url <url>] [--yes] [--no-submit] | candle perps deposit status <clientDepositId>";
+function isDepositAsset(value) {
+  return value !== undefined && Object.hasOwn(BRIDGE_ASSETS, value);
+}
+function depositBuildProblem(build, expect) {
+  const destination = build.destination ?? {};
+  if (build.walletId !== expect.walletId)
+    return "the build names another paying wallet";
+  if (build.asset !== expect.asset || build.amountRaw !== expect.amountRaw)
+    return "the build is for another amount";
+  if (destination.chainId !== HYPERLIQUID_RELAY_CHAIN_ID)
+    return `the build lands on chain ${safeText(destination.chainId)}`;
+  if (destination.currency !== HYPERLIQUID_RELAY_USDC)
+    return "the build does not deliver Hyperliquid USDC";
+  if (typeof destination.address !== "string" || !sameEvmAddress(destination.address, expect.destination))
+    return `the build lands on ${safeText(destination.address)}, not ${expect.destination}`;
+  const fee = build.fee ?? {};
+  if (fee.bps !== 0 || fee.feeRaw !== "0")
+    return "the build carries a Candle fee";
+  return null;
+}
+async function perpsDepositStatus(ctx, id) {
+  const key = await tradingKey(ctx);
+  const result = await perpsRequest(ctx, key, `/api/v1/agent/perps/deposit/${encodeURIComponent(id)}`);
+  if (ctx.json)
+    return printTradingResult(ctx, result);
+  const job = result.job ?? {};
+  const destination = job.destination ?? {};
+  const relay = job.relay;
+  ctx.deps.stdout.write(`Deposit ${safeText(id)}: ${safeText(job.status)}${job.signature ? ` (${safeText(job.signature)})` : ""}, ${safeText(job.amountRaw)} raw ${safeText(job.asset)} to ${safeText(destination.address)} on Hyperliquid. Relay: ${relay ? safeText(relay.status) : "not sent yet, or unknown"}.
+`);
+  return 0;
+}
+async function perpsDeposit(args, ctx) {
+  if (args[0] === "status") {
+    if (args.length !== 2 || !DEPOSIT_ID_RE.test(args[1]))
+      return usage4(ctx, DEPOSIT_USAGE);
+    try {
+      return await perpsDepositStatus(ctx, args[1]);
+    } catch (error) {
+      return tradingFailure(ctx, error);
+    }
+  }
+  const parsed = parseArgs(args, {
+    valueFlags: ["--wallet", "--to", "--id", "--slippage-bps", "--rpc-url"],
+    booleanFlags: ["--yes", "--no-submit"]
+  });
+  if ("error" in parsed)
+    return usage4(ctx, parsed.error);
+  const [amount, asset] = parsed.positionals;
+  if (parsed.positionals.length !== 2 || !amount || !DEC_RE.test(amount) || !isDepositAsset(asset))
+    return usage4(ctx, DEPOSIT_USAGE);
+  const { values } = parsed;
+  const id = values["--id"] ?? `deposit-${randomUUID4()}`;
+  if (!DEPOSIT_ID_RE.test(id))
+    return usage4(ctx, "--id must be 1 to 128 letters, digits, '.', '_', ':' or '-'.");
+  const slippageBps = Number(values["--slippage-bps"] ?? "100");
+  if (!Number.isInteger(slippageBps) || slippageBps < 1 || slippageBps > 1000)
+    return usage4(ctx, "--slippage-bps must be a whole number from 1 to 1000.");
+  const origin = BRIDGE_ASSETS[asset].chain;
+  try {
+    const key = await tradingKey(ctx);
+    const payer = await tradingPayer(ctx, key, values["--wallet"], "swap:write", origin);
+    if (payer.kind !== "tee")
+      throw new TradingError("TEE_WALLET_REQUIRED", `A Hyperliquid deposit pays only from this key's ${origin === "hood" ? "Hood" : "Solana"} TEE wallet, and ${safeText(payer.address)} is the embedded wallet. Name the TEE wallet with --wallet. Nothing was built.`);
+    const wallet = payer.wallet;
+    let destination;
+    if (origin === "hood") {
+      if (values["--to"] !== undefined)
+        throw new TradingError("BRIDGE_DESTINATION_MISSING", "From a Hood TEE wallet the deposit lands on that wallet's own Hyperliquid account; drop --to. Nothing was built.");
+      destination = { id: wallet.id, address: wallet.address };
+    } else {
+      destination = (await perpsWallet(ctx, key, values["--to"])).row;
+    }
+    const amountRaw = rawAmount(amount, BRIDGE_ASSETS[asset].decimals);
+    ctx.deps.stderr.write(`Deposit: ${id}
+`);
+    const build = await perpsRequest(ctx, key, "/api/v1/agent/perps/deposit", {
+      clientDepositId: id,
+      walletId: wallet.id,
+      asset,
+      amountRaw,
+      maxSlippageBps: slippageBps,
+      ...origin === "solana" ? { perpsWalletId: destination.id } : {}
+    });
+    if (build.job)
+      return printTradingResult(ctx, build);
+    const refused = (problem2) => new TradingError("PERPS_BUILD_REFUSED", `Refused to sign this deposit: ${problem2}. Nothing was signed.`);
+    const problem = depositBuildProblem(build, {
+      walletId: wallet.id,
+      asset,
+      amountRaw,
+      destination: destination.address
+    });
+    if (problem)
+      throw refused(problem);
+    let sequenced;
+    let transaction;
+    const hoodOrigin = asset === "ETH" || asset === "USDG" ? asset : undefined;
+    if (hoodOrigin) {
+      const parsedLeg = sequencedSchema.safeParse(build);
+      if (!parsedLeg.success)
+        throw refused("Candle did not answer with a sequenced Hood leg");
+      sequenced = parsedLeg.data;
+      const plan = plannedLegKinds(sequenced.legKind, sequenced.plannedLegCount, false, "bridgeDeposit");
+      if (!bridgePlanAdmitted(hoodOrigin, plan))
+        throw refused(`the plan is ${sequenced.plannedLegCount} leg(s) starting with ${sequenced.legKind}`);
+      const legProblem = relayHoodLegProblem(sequenced.legKind, sequenced.nextLeg, {
+        origin: hoodOrigin,
+        payer: wallet.address,
+        amountRaw
+      });
+      if (legProblem)
+        throw refused(legProblem);
+    } else {
+      const txs = Array.isArray(build.transactionsBase64) ? build.transactionsBase64 : [];
+      if (txs.length !== 1 || typeof txs[0] !== "string")
+        throw refused(`Candle returned ${txs.length} transactions, not one deposit`);
+      transaction = txs[0];
+      const reader = await lazySolanaClient(ctx, values["--rpc-url"])();
+      const solanaProblem = await tradingRead(ctx, reader, () => relaySolanaDepositProblem(transaction, wallet.address, reader.rpc));
+      if (solanaProblem)
+        throw refused(solanaProblem);
+    }
+    const decimals = Number(build.outDecimals);
+    const minimum = decimalAmount(String(build.minimumOutRaw), decimals);
+    const estimate2 = decimalAmount(String(build.expectedOutRaw), decimals);
+    const output = ctx.json ? ctx.deps.stderr : ctx.deps.stdout;
+    output.write(`Deposit ${amount} ${asset} from ${safeText(wallet.address)} (${origin === "hood" ? "Hood" : "Solana"} TEE wallet) to Hyperliquid account ${safeText(destination.address)} through Relay.
+`);
+    output.write(`Relay delivers at least ${minimum} USDC (estimate ${estimate2})${build.firstDeposit ? "; Hyperliquid keeps 1 USDC to activate this new account" : ""}. Candle fee: none.
+`);
+    output.write("There is no withdrawal from Hyperliquid in this release, and `candle tee disable` or `tee sweep` do not reach it.\n");
+    if (sequenced)
+      output.write(`Legs, signed one at a time: ${sequenced.plannedLegCount === 2 ? "approval, bridgeDeposit" : "bridgeDeposit"}
+`);
+    if (parsed.booleans.has("--no-submit"))
+      return printTradingResult(ctx, { ...build, signed: false, submitted: false });
+    if (!parsed.booleans.has("--yes")) {
+      if (!ctx.deps.isTTY.stdin)
+        throw new TradingError("CONFIRMATION_REQUIRED", "Run interactively to confirm, or use --yes.");
+      if ((await ctx.deps.promptLine("Sign and send? [y/N] ")).trim().toLowerCase() !== "y") {
+        if (sequenced)
+          ctx.deps.stderr.write(`Nothing was signed. Operation ${sequenced.operationId} holds this wallet until ${new Date(sequenced.expiresAt).toISOString()}.
+`);
+        throw new TradingError("CANCELLED", "Nothing was signed.");
+      }
+    }
+    if (typeof build.expiresAt !== "number" || build.expiresAt <= ctx.deps.now())
+      throw new TradingError("QUOTE_EXPIRED", "The deposit build expired before signing. Start again with a new --id.");
+    let result;
+    if (sequenced && hoodOrigin) {
+      const run2 = await runSequencedLegs(ctx, key, {
+        wallet,
+        first: sequenced,
+        submitPath: "/api/v1/agent/perps/deposit/submit",
+        submitFields: { clientDepositId: id, depositId: build.depositId },
+        unwrap: (answer) => answer,
+        primaryLeg: "bridgeDeposit",
+        allowedLegs: bridgeLegKinds(hoodOrigin),
+        checkLeg: (kind, leg) => relayHoodLegProblem(kind, leg, { origin: hoodOrigin, payer: wallet.address, amountRaw }) === null,
+        onLanded: async () => {}
+      });
+      result = { ...run2.final, landedLegs: run2.landed };
+    } else {
+      const signed = await relaySign(ctx, key, wallet, transaction);
+      result = await perpsRequest(ctx, key, "/api/v1/agent/perps/deposit/submit", {
+        clientDepositId: id,
+        depositId: build.depositId,
+        signedTransactionsBase64: [signed]
+      });
+    }
+    ctx.deps.stderr.write(`Deposit sent; Relay fills it on Hyperliquid. Check it with candle perps deposit status ${id}.
+`);
+    return printTradingResult(ctx, {
+      ...result,
+      clientDepositId: id,
+      expectedOutRaw: build.expectedOutRaw,
+      minimumOutRaw: build.minimumOutRaw,
+      outDecimals: build.outDecimals
+    });
+  } catch (error) {
+    return tradingFailure(ctx, error);
+  }
+}
+
+// src/commands/plans.ts
+init_args();
+
+// src/plans.ts
+var PLAN_CAPABILITY_NOTE = "A capability marked yes is what the plan allows. It is subject to the deployment's own switches (perps and own-wallet bridges each have one) and to the wallet, scopes and setup the feature needs.";
+var PLAN_CAPABILITY_LABELS = {
+  tradeCandleTokens: "Trade Candle-launched tokens",
+  tradeBaseAssets: "Trade base assets",
+  freeBaseTransfers: "Base-pair swaps and own-wallet bridges (when enabled), no Candle fee",
+  sellExternalTokens: "Sell tokens not launched on Candle",
+  buyExternalTokens: "Buy tokens not launched on Candle",
+  hyperliquidPerps: "Hyperliquid perps (when enabled)",
+  selfLaunch: "Self-launch from a linked wallet",
+  atomicLaunch: "Atomic launch with first buys",
+  createLinkedWallets: "Create linked wallets",
+  importLinkedWallets: "Import linked wallets",
+  limitOrders: "Limit orders",
+  quant: "Quant on Telegram"
+};
+var PLAN_LABELS = { free: "Free", believer: "Believer", pro: "Pro", max: "Max" };
+function planLabel(plan) {
+  return Object.hasOwn(PLAN_LABELS, plan) ? PLAN_LABELS[plan] : plan;
+}
+function formatPlanBps(bps) {
+  return bps === 0 ? "none" : `${Number((bps / 100).toFixed(4))}%`;
+}
+function count(n) {
+  return n.toLocaleString("en-US");
+}
+function priceCell(entry) {
+  if (entry.price)
+    return `$${count(entry.price.pricePerMonthUsd)} a month`;
+  return entry.plan === "free" ? "free" : "not sold";
+}
+function planTableRows(table) {
+  const plans = table.plans;
+  const row = (label, cell) => [label, ...plans.map(cell)];
+  const rows = [
+    row("Price", priceCell),
+    row("Agent trade fee", (e) => formatPlanBps(e.feeBps)),
+    row("Perps builder fee", (e) => formatPlanBps(e.perpFeeBps)),
+    row("Requests per minute", (e) => count(e.limits.rateLimitPerMin)),
+    row("Launches per day", (e) => count(e.limits.dailyLaunchCap)),
+    row("Uploads per minute", (e) => count(e.limits.uploadsPerMin)),
+    row("Linked wallets", (e) => count(e.limits.linkedWallets))
+  ];
+  const known = Object.keys(PLAN_CAPABILITY_LABELS);
+  const served = new Set;
+  for (const entry of plans)
+    for (const key of Object.keys(entry.capabilities ?? {}))
+      served.add(key);
+  const keys = [
+    ...known.filter((k) => served.has(k)),
+    ...[...served].filter((k) => !Object.hasOwn(PLAN_CAPABILITY_LABELS, k))
+  ];
+  for (const key of keys) {
+    const label = Object.hasOwn(PLAN_CAPABILITY_LABELS, key) ? PLAN_CAPABILITY_LABELS[key] : key;
+    rows.push(row(label, (e) => {
+      const value = e.capabilities?.[key];
+      return value === true ? "yes" : value === false ? "no" : "-";
+    }));
+  }
+  return { headers: ["", ...plans.map((e) => planLabel(e.plan))], rows };
+}
+function planPromotionLine(table) {
+  if (!(table.promoMaxDays > 0))
+    return null;
+  const days = table.promoMaxDays === 1 ? "1 day" : `${table.promoMaxDays} days`;
+  return `A first Pro purchase includes Max for its first ${days}, then continues on Pro.`;
+}
+
+// src/commands/plans.ts
+init_render();
+var USAGE3 = "Usage: candle plans";
+async function plans(args, ctx) {
+  const parsed = parseArgs(args, {});
+  if ("error" in parsed || parsed.positionals.length > 0) {
+    writeUsageFailure(ctx.deps, "error" in parsed ? `${parsed.error}
+${USAGE3}` : USAGE3, ctx.json);
+    return 2;
+  }
+  const result = await apiRequest("/api/v1/agent/plans", {
+    auth: "none",
+    credentials: {},
+    apiUrl: ctx.apiUrl,
+    fetch: ctx.deps.fetch,
+    env: ctx.deps.env
+  });
+  if (!result.ok) {
+    if (result.status === 404 && !ctx.json) {
+      ctx.deps.stderr.write(`${ctx.apiUrl} does not serve the plan table yet (GET /api/v1/agent/plans answered 404).
+`);
+      return 1;
+    }
+    writeFailure(ctx.deps, result, { apiUrl: ctx.apiUrl, authType: "none" }, ctx.json);
+    return 1;
+  }
+  const body = result.body;
+  if (ctx.json) {
+    ctx.deps.stdout.write(`${JSON.stringify(body)}
+`);
+    return 0;
+  }
+  const { headers, rows } = planTableRows(body);
+  const out = ctx.deps.stdout;
+  out.write(`Plans served by ${ctx.apiUrl}
+
+`);
+  out.write(`${renderTable(headers.map(terminalText), rows.map((row) => row.map(terminalText)))}
+`);
+  const promotion = planPromotionLine(body);
+  if (promotion)
+    out.write(`
+${promotion}
+`);
+  out.write(`
+${PLAN_CAPABILITY_NOTE}
+`);
+  out.write(`
+The agent trade fee is charged on top of each trade or dev buy the API builds. Your account's plan: candle doctor.
+`);
+  return 0;
+}
+
 // src/commands/plugins.ts
 init_args();
 
@@ -59271,20 +61832,20 @@ async function writeSecretNames(deps, profile, names) {
   else
     await deps.updateProfile(profile, { secretNames: sorted });
 }
-function usage4(ctx, line) {
+function usage5(ctx, line) {
   writeUsageFailure(ctx.deps, line, ctx.json);
   return 2;
 }
 async function secretsSet(args, ctx) {
   const parsed = parseArgs(args, {});
   if ("error" in parsed)
-    return usage4(ctx, parsed.error);
+    return usage5(ctx, parsed.error);
   const [raw, extra] = parsed.positionals;
   if (!raw || extra !== undefined)
-    return usage4(ctx, "Usage: candle secrets set <name>");
+    return usage5(ctx, "Usage: candle secrets set <name>");
   const name2 = canonicalSecretName(raw);
   if (name2 === undefined) {
-    return usage4(ctx, `A secret name is letters, digits and underscores, starting with a letter: ${raw}`);
+    return usage5(ctx, `A secret name is letters, digits and underscores, starting with a letter: ${raw}`);
   }
   if (!ctx.deps.isTTY.stdin || !ctx.deps.isTTY.stdout) {
     writeLocalFailure(ctx.deps, {
@@ -59296,7 +61857,7 @@ async function secretsSet(args, ctx) {
   }
   const value = await ctx.deps.promptSecret(`Value for ${name2} (input hidden): `);
   if (value.length === 0)
-    return usage4(ctx, "An empty value was typed; nothing was stored.");
+    return usage5(ctx, "An empty value was typed; nothing was stored.");
   try {
     await ctx.deps.secretsStore.set(secretRef(ctx.profile, name2), value);
   } catch (error) {
@@ -59316,9 +61877,9 @@ async function secretsSet(args, ctx) {
 async function secretsList(args, ctx) {
   const parsed = parseArgs(args, {});
   if ("error" in parsed)
-    return usage4(ctx, parsed.error);
+    return usage5(ctx, parsed.error);
   if (parsed.positionals.length > 0)
-    return usage4(ctx, `Unexpected argument: ${parsed.positionals[0]}`);
+    return usage5(ctx, `Unexpected argument: ${parsed.positionals[0]}`);
   const names = await storedSecretNames(ctx.deps, ctx.profile);
   if (ctx.json) {
     ctx.deps.stdout.write(`${JSON.stringify({ ok: true, names, backend: ctx.deps.backend })}
@@ -59337,13 +61898,13 @@ async function secretsList(args, ctx) {
 async function secretsRemove(args, ctx) {
   const parsed = parseArgs(args, {});
   if ("error" in parsed)
-    return usage4(ctx, parsed.error);
+    return usage5(ctx, parsed.error);
   const [raw, extra] = parsed.positionals;
   if (!raw || extra !== undefined)
-    return usage4(ctx, "Usage: candle secrets remove <name>");
+    return usage5(ctx, "Usage: candle secrets remove <name>");
   const name2 = canonicalSecretName(raw);
   if (name2 === undefined) {
-    return usage4(ctx, `A secret name is letters, digits and underscores, starting with a letter: ${raw}`);
+    return usage5(ctx, `A secret name is letters, digits and underscores, starting with a letter: ${raw}`);
   }
   await ctx.deps.secretsStore.delete(secretRef(ctx.profile, name2));
   const names = await storedSecretNames(ctx.deps, ctx.profile);
@@ -59469,11 +62030,11 @@ init_render();
 function formatUsd(value) {
   if (!Number.isFinite(value))
     return "?";
-  const sign3 = value < 0 ? "-" : "";
+  const sign4 = value < 0 ? "-" : "";
   const abs = Math.abs(value);
   if (abs > 0 && abs < 0.005)
-    return `${sign3}<$0.01`;
-  return `${sign3}$${abs.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+    return `${sign4}<$0.01`;
+  return `${sign4}$${abs.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
 }
 function formatPrice(value) {
   if (!Number.isFinite(value) || value <= 0)
@@ -59499,7 +62060,47 @@ function shortAddress2(address) {
   return address.length > 12 ? `${address.slice(0, 4)}…${address.slice(-4)}` : address;
 }
 
+// src/commands/pnl-hyperliquid.ts
+init_render();
+function writeHyperliquidPnl(ctx, section) {
+  if (!section)
+    return;
+  const out = ctx.deps.stdout;
+  out.write(`
+Hyperliquid
+`);
+  if (!section.read) {
+    out.write(`Unavailable: ${terminalText(section.reason)}
+`);
+    return;
+  }
+  out.write(`Network: ${section.network}
+`);
+  out.write(`Realized gross  ${formatUsd(section.realizedGrossUsd)}
+`);
+  out.write(`Funding         ${formatUsd(section.fundingUsd)} (received positive, paid negative)
+`);
+  out.write(`Fees            ${formatUsd(section.feesUsd)} (includes builder fees)
+`);
+  out.write(`Realized net    ${formatUsd(section.realizedNetUsd)} (gross + funding - fees)
+`);
+  out.write(`${section.fills} fills; ${section.fundingPayments} funding payments. Unrealized perps are excluded.
+`);
+  out.write(`Coverage: currently bound EVM TEE wallets since the current TEE binding; previous bindings excluded.
+`);
+  for (const wallet of section.byWallet) {
+    out.write(`${terminalText(wallet.address)} since ${new Date(wallet.startTime).toISOString()}
+`);
+  }
+  if (section.truncated) {
+    out.write(`History is truncated: at most ${section.fillsLimit} recent fills and ${section.fundingLimit} funding rows per wallet, ${section.walletsLimit} wallets. This is a partial figure.
+`);
+  }
+}
+
 // src/commands/pnl.ts
+var CHAINS = ["solana", "hood"];
+var CHAIN_TITLES = { solana: "Solana", hood: "Hood" };
 var NO_API_KEY4 = {
   code: "NO_API_KEY",
   message: "No API key for this profile.",
@@ -59563,10 +62164,14 @@ async function pnl(args, ctx) {
     return 0;
   }
   if (perProfile) {
-    const { pnl: p, lp } = body;
-    deps.stdout.write(`P&L for profile ${ctx.profileFlag} (key ${keyPrefix}): this key's own fills
+    const { pnl: p, lp, hyperliquid } = body;
+    const engine = typeof p.totalUsd === "number";
+    deps.stdout.write(engine ? `P&L for profile ${ctx.profileFlag} (key ${keyPrefix}): this key's share of the account's P&L
+
+` : `P&L for profile ${ctx.profileFlag} (key ${keyPrefix}): this key's own fills
 
 `);
+    writeChainBlocks(ctx, p.byChain);
     writeSummary(ctx, {
       realizedNetUsd: p.realizedNetUsd,
       realizedGrossUsd: p.realizedGrossUsd,
@@ -59575,21 +62180,27 @@ async function pnl(args, ctx) {
       unmarked: p.unmarkedPositions,
       unvalued: p.unvalued,
       counted: p.counted,
+      totalUsd: p.totalUsd,
+      openPositionsExDust: p.openPositionsExDust,
+      closed: p.closed,
       positions: p.openPositions.length,
       truncated: p.truncated,
       lookback: p.lookback,
-      lookbackUnit: "trades",
+      lookbackUnit: engine ? "of the account's ledger rows" : "trades",
       oldestMarkAt: p.oldestMarkAt,
       lp
     });
     writePositions(ctx, p.openPositions, false);
+    writeWallets(ctx, p.byWallet, engine);
     writeLpPositions(ctx, lp, false);
+    writeHyperliquidPnl(ctx, hyperliquid);
     return 0;
   }
   const books = body;
   deps.stdout.write(`P&L for the account: every profile, the web app and the CLI, one ledger
 
 `);
+  writeChainBlocks(ctx, { solana: books.solana, hood: books.hood });
   writeSummary(ctx, {
     ...books.all,
     positions: books.positions.length,
@@ -59599,10 +62210,81 @@ async function pnl(args, ctx) {
     oldestMarkAt: books.oldestMarkAt,
     lp: books.lp
   });
+  writeWalletEvents(ctx, books);
+  writeAgents(ctx, books.byAgent, books.all);
   writePositions(ctx, books.positions, true);
   writeLpPositions(ctx, books.lp, true);
   return 0;
 }
+function isChainSummary(value) {
+  return typeof value === "object" && value !== null && typeof value.realizedNetUsd === "number";
+}
+function writeChainBlocks(ctx, byChain) {
+  const blocks = CHAINS.flatMap((chain2) => {
+    const summary = byChain?.[chain2];
+    return isChainSummary(summary) ? [[chain2, summary]] : [];
+  });
+  if (blocks.length === 0)
+    return;
+  for (const [chain2, s] of blocks) {
+    const unmarked = s.unmarked ?? s.unmarkedPositions ?? 0;
+    const marked = s.openPositions - unmarked;
+    ctx.deps.stdout.write(`${CHAIN_TITLES[chain2]}
+`);
+    writeLines(ctx, [
+      [
+        "Realized net",
+        formatUsd(s.realizedNetUsd),
+        `gross ${formatUsd(s.realizedGrossUsd)}, fees ${formatUsd(s.feesUsd)}`
+      ],
+      [
+        "Unrealized",
+        formatUsd(s.unrealizedUsd),
+        `${marked} of ${s.openPositions} open ${s.openPositions === 1 ? "position" : "positions"} marked${unmarked > 0 ? `; ${unmarked} unpriced, not counted` : ""}`
+      ],
+      ["Total", formatUsd(totalOf(s)), "realized net plus unrealized"]
+    ]);
+    if (s.unvalued > 0) {
+      ctx.deps.stdout.write(`${s.unvalued} ${s.unvalued === 1 ? "fill" : "fills"} could not be valued and are not in these figures.
+`);
+    }
+    ctx.deps.stdout.write(`
+`);
+  }
+  ctx.deps.stdout.write(`All chains
+`);
+}
+function totalOf(s) {
+  return typeof s.totalUsd === "number" ? s.totalUsd : s.realizedNetUsd + s.unrealizedUsd;
+}
+function isUnplacedWallet(wallet) {
+  return wallet.startsWith("unknown:");
+}
+function writeLines(ctx, lines) {
+  const width = Math.max(...lines.map(([label]) => label.length));
+  const valueWidth = Math.max(...lines.map(([, value]) => value.length));
+  for (const [label, value, note] of lines) {
+    ctx.deps.stdout.write(`${label.padEnd(width)}  ${value.padStart(valueWidth)}  (${note})
+`);
+  }
+}
+function writeWallets(ctx, wallets2, engine) {
+  if (!wallets2 || wallets2.length === 0)
+    return;
+  const rows = wallets2.map((w) => [
+    isUnplacedWallet(w.wallet) ? "not placed in a wallet" : `${w.label?.trim() ? `${w.label.trim()} ` : w.payerType === "main" ? "main " : ""}(${shortAddress2(w.wallet)})`,
+    w.chain ?? "-",
+    String(w.tradesConsidered),
+    formatUsd(w.realizedNetUsd),
+    formatUsd(w.unrealizedUsd),
+    `${w.openPositions.length}${w.unmarkedPositions > 0 ? ` (${w.unmarkedPositions} unpriced)` : ""}`
+  ]);
+  const heading = engine ? "By wallet (each its own cost basis; the rows sum to the total)" : "By wallet (each its own cost basis, so the rows need not sum to the total)";
+  ctx.deps.stdout.write(`
+${heading}
+${renderTable(["WALLET", "CHAIN", "TRADES", "REALIZED NET", "UNREALIZED", "OPEN"], rows.map((row) => row.map(terminalText)))}
+`);
+}
 function writeSummary(ctx, s) {
   const marked = s.positions - s.unmarked;
   const lines = [
@@ -59617,6 +62299,7 @@ function writeSummary(ctx, s) {
       `${marked} of ${s.positions} open ${s.positions === 1 ? "position" : "positions"} marked${s.unmarked > 0 ? `; ${s.unmarked} unpriced, not counted` : ""}`
     ]
   ];
+  const total = totalOf(s);
   const lp = s.lp;
   if (lp?.read) {
     const plural2 = (n, one, many) => `${n} ${n === 1 ? one : many}`;
@@ -59632,20 +62315,22 @@ function writeSummary(ctx, s) {
       "LP vs holding",
       lp.vsHoldingPositions > 0 ? formatUsd(lp.vsHoldingUsd) : "-",
       lp.vsHoldingPositions > 0 ? `${lp.vsHoldingPositions} of ${lp.valued} valued, against holding the deposited tokens (now ${formatUsd(lp.holdValueUsd)})` : "no valued LP position with every deposit priced"
-    ], [
-      "Total",
-      formatUsd(s.realizedNetUsd + s.unrealizedUsd + lp.realizedUsd + lp.unrealizedUsd),
-      "realized net plus unrealized, tokens and LP"
+    ], ["Total", formatUsd(total), "realized net plus unrealized, tokens only, as the console shows it"], [
+      "Total with LP",
+      formatUsd(total + lp.realizedUsd + lp.unrealizedUsd),
+      "the total plus LP realized and unrealized"
     ]);
   } else if (lp) {
-    lines.push(["LP", "not read", `${terminalText(lp.reason)}; not in the total`], ["Total", formatUsd(s.realizedNetUsd + s.unrealizedUsd), "realized net plus unrealized, tokens only"]);
+    lines.push(["LP", "not read", `${terminalText(lp.reason)}; not in the total`], ["Total", formatUsd(total), "realized net plus unrealized, tokens only"]);
   } else {
-    lines.push(["Total", formatUsd(s.realizedNetUsd + s.unrealizedUsd), "realized net plus unrealized"]);
+    lines.push(["Total", formatUsd(total), "realized net plus unrealized"]);
   }
-  const width = Math.max(...lines.map(([label]) => label.length));
-  const valueWidth = Math.max(...lines.map(([, value]) => value.length));
-  for (const [label, value, note] of lines) {
-    ctx.deps.stdout.write(`${label.padEnd(width)}  ${value.padStart(valueWidth)}  (${note})
+  writeLines(ctx, lines);
+  if (s.closed)
+    writeClosed(ctx, s.closed);
+  const dust = s.openPositionsExDust !== undefined ? s.positions - s.openPositionsExDust : 0;
+  if (dust > 0) {
+    ctx.deps.stdout.write(`${dust} open ${dust === 1 ? "position is" : "positions are"} dust (worth under one cent): listed and marked, and counted in the figures.
 `);
   }
   if (s.oldestMarkAt !== undefined) {
@@ -59675,6 +62360,50 @@ function writeSummary(ctx, s) {
     }
   }
 }
+function writeClosed(ctx, c) {
+  const counts = [`${c.wins} won`, `${c.losses} lost`];
+  if (c.costUnknown > 0)
+    counts.push(`${c.costUnknown} with unknown cost`);
+  ctx.deps.stdout.write(`Closed: ${c.closed} ${c.closed === 1 ? "position" : "positions"} (${counts.join(", ")}). Money made ${formatUsd(c.madeUsd)}, money lost ${formatUsd(c.lostUsd)} and partial sells ${formatUsd(c.partialSellsUsd)} add up to the realized net.
+`);
+}
+function writeWalletEvents(ctx, books) {
+  const unknown = books.costUnknown?.length ?? 0;
+  if (unknown > 0) {
+    ctx.deps.stdout.write(`${unknown} ${unknown === 1 ? "arrival" : "arrivals"} of tokens came with no cost anyone can state: selling them realizes nothing (--json lists them).
+`);
+  }
+  const out = books.movedOutUntracked?.length ?? 0;
+  if (out > 0) {
+    ctx.deps.stdout.write(`${out} ${out === 1 ? "move" : "moves"} out of a wallet went where Candle does not follow: the tokens left at cost, not as a sale (--json lists them).
+`);
+  }
+}
+function writeAgents(ctx, agents, all) {
+  if (!agents || agents.length === 0)
+    return;
+  const open4 = (count2, unmarked) => `${count2}${unmarked > 0 ? ` (${unmarked} unpriced)` : ""}`;
+  const rows = agents.map((a) => [
+    a.keyPrefix === null ? "Manual (web app)" : a.label && a.label !== a.keyPrefix ? `${a.label} (${a.keyPrefix})` : a.keyPrefix,
+    formatUsd(a.realizedNetUsd),
+    formatUsd(a.unrealizedUsd),
+    formatUsd(totalOf(a)),
+    open4(a.openPositions, a.unmarked),
+    String(a.closedRounds)
+  ]);
+  rows.push([
+    "Account total",
+    formatUsd(all.realizedNetUsd),
+    formatUsd(all.unrealizedUsd),
+    formatUsd(totalOf(all)),
+    open4(all.openPositions, all.unmarked),
+    all.closedRounds !== undefined ? String(all.closedRounds) : "-"
+  ]);
+  ctx.deps.stdout.write(`
+By agent (each key, then Manual; the rows sum to the account total)
+${renderTable(["AGENT", "REALIZED NET", "UNREALIZED", "TOTAL", "OPEN", "CLOSED"], rows.map((row) => row.map(terminalText)))}
+`);
+}
 function writeLpPositions(ctx, lp, withBook) {
   if (!lp?.read || lp.positions.length === 0)
     return;
@@ -59708,12 +62437,16 @@ No open positions.
 `);
     return;
   }
-  const headers = ["TOKEN", "QUANTITY", "AVG ENTRY", "MARK", "UNREALIZED"];
+  const withWallet = positions.some((p) => p.wallet !== undefined);
+  const headers = ["TOKEN", "CHAIN", ...withWallet ? ["WALLET"] : [], "QUANTITY", "AVG ENTRY", "MARK", "UNREALIZED"];
   if (withBook)
     headers.push("BOOK");
+  const wallet = (w) => w === undefined || isUnplacedWallet(w) ? "-" : shortAddress2(w);
   const rows = positions.map((p) => {
     const row = [
-      p.symbol?.trim() || shortAddress2(p.mint),
+      `${p.symbol?.trim() || shortAddress2(p.mint)}${p.dust === true ? " (dust)" : ""}`,
+      p.chain ?? "-",
+      ...withWallet ? [wallet(p.wallet)] : [],
       formatQuantity(p.quantity),
       formatPrice(p.avgEntryUsd),
       p.markPriceUsd !== undefined ? formatPrice(p.markPriceUsd) : "unpriced",
@@ -59732,10 +62465,12 @@ ${renderTable(headers, rows.map((row) => row.map(terminalText)))}
 // src/commands/portfolio.ts
 init_args();
 init_deps();
+init_evm_lite();
 init_profiles();
 init_render();
 init_solana_endpoint();
 init_solana_lite();
+init_errors();
 init_store();
 init_vault_support();
 var SOL_MINT = "So11111111111111111111111111111111111111112";
@@ -59746,31 +62481,74 @@ var KNOWN_SYMBOLS = {
 };
 var CHUNK = 100;
 var TOKEN_READS_IN_FLIGHT = 8;
+var EVM_READS_IN_FLIGHT = 8;
+var CHAINS2 = ["solana", "hood"];
+var CHAIN_NAMES = { solana: "Solana", hood: "Hood" };
+var HOOD_NATIVE = "native";
+function hoodPriceKey(mint) {
+  return mint === HOOD_NATIVE ? "hood:native" : `hood:${mint.toLowerCase()}`;
+}
+var HOOD_USDG = toChecksumAddress(HOOD_USDG_ADDRESS);
+var UNREAD_LABELS = {
+  sol: "SOL",
+  tokens: "tokens",
+  eth: "ETH",
+  usdg: "USDG",
+  "hood-tokens": "tokens"
+};
 var NO_API_KEY5 = {
   code: "NO_API_KEY",
   message: "No API key for this profile.",
   suggestion: "Set CANDLE_API_KEY, or run `candle auth login` to store one."
 };
 async function portfolio(args, ctx) {
-  const parsed = parseArgs(args, { valueFlags: ["--rpc-url", "--keystore"], pathFlags: ["--keystore"] });
+  const parsed = parseArgs(args, {
+    valueFlags: ["--rpc-url", "--evm-rpc-url", "--keystore", "--chain"],
+    pathFlags: ["--keystore"]
+  });
   if ("error" in parsed)
     return usage(ctx, parsed.error);
   if (parsed.positionals.length > 0)
     return usage(ctx, `Unexpected argument: ${parsed.positionals[0]}`);
   const { deps } = ctx;
+  const chainFlag = parsed.values["--chain"];
+  if (chainFlag !== undefined && !CHAINS2.includes(chainFlag)) {
+    return usage(ctx, `--chain must be solana or hood, not ${chainFlag}.`);
+  }
+  const chains = chainFlag === undefined ? [...CHAINS2] : [chainFlag];
+  const showSolana = chains.includes("solana");
+  const showHood = chains.includes("hood");
+  if (!showSolana && parsed.values["--rpc-url"] !== undefined) {
+    return usage(ctx, "--rpc-url is the Solana RPC and has no effect with --chain hood; use --evm-rpc-url.");
+  }
+  if (!showHood && parsed.values["--evm-rpc-url"] !== undefined) {
+    return usage(ctx, "--evm-rpc-url is the Hood RPC and has no effect with --chain solana.");
+  }
   const apiKey = await resolveApiKey(deps, ctx.profile);
   if (!apiKey) {
     writeLocalFailure(deps, NO_API_KEY5, ctx.json);
     return 1;
   }
-  const solana = await openSolanaClient(ctx, parsed.values["--rpc-url"]);
-  if ("error" in solana)
-    return usage(ctx, solana.error);
+  let solana;
+  if (showSolana) {
+    const opened = await openSolanaClient(ctx, parsed.values["--rpc-url"]);
+    if ("error" in opened)
+      return usage(ctx, opened.error);
+    solana = opened;
+  }
+  let evmRpc;
+  if (showHood) {
+    const resolved = resolveEvmRpcUrl(parsed.values["--evm-rpc-url"], deps.env[EVM_RPC_URL_ENV], "--evm-rpc-url");
+    if ("error" in resolved)
+      return usage(ctx, resolved.error);
+    evmRpc = resolved;
+  }
   const resolvedVault = vaultPathFor(ctx, parsed);
   if ("error" in resolvedVault)
     return usage(ctx, resolvedVault.error);
   return runVaultCommand(ctx, async ({ hold }) => {
     let vaultEntries;
+    let evmEntries;
     let vaultReason;
     const raw = await readVaultRaw(resolvedVault.path);
     if (raw === null) {
@@ -59781,17 +62559,26 @@ async function portfolio(args, ctx) {
       if (!requirePromptStreams(ctx, "portfolio"))
         return 1;
       const vault = hold((await unlockInteractively(ctx, resolvedVault.path, raw)).vault);
-      vaultEntries = vault.index.entries.filter((entry) => entry.chain === "solana" && (entry.role === "vault" || entry.role === "external")).map((entry) => ({ address: entry.address, label: entry.label, role: entry.role }));
+      vaultEntries = showSolana ? vault.index.entries.filter((entry) => entry.chain === "solana" && (entry.role === "vault" || entry.role === "external")).map((entry) => ({ address: entry.address, label: entry.label, role: entry.role })) : [];
+      evmEntries = showHood ? vault.index.entries.filter((entry) => entry.chain === "evm" && entry.role === "vault").map((entry) => ({ address: entry.address, label: entry.label })) : [];
     }
     await printIdentity(ctx);
-    const rpcHost = solana.endpoint.host;
-    if (vaultEntries && vaultEntries.length > 0) {
+    const rpcHost = solana?.endpoint.host;
+    if (solana && vaultEntries && vaultEntries.length > 0) {
       await solana.disclose();
       const requests = Math.ceil(vaultEntries.length / CHUNK) + vaultEntries.length * 2;
       deps.stderr.write(`Reading ${vaultEntries.length} vault ${vaultEntries.length === 1 ? "address" : "addresses"} from ${rpcHost} in ${requests} requests. That endpoint sees them together; Candle sees none of them.
 `);
     }
-    const [candle, vaultRead] = await Promise.all([
+    let evmHost;
+    if (evmRpc && evmEntries && evmEntries.length > 0) {
+      evmHost = rpcHostOf2(evmRpc.url);
+      const n = evmEntries.length;
+      deps.stderr.write(`Reading ETH and USDG for ${n} EVM vault ${n === 1 ? "address" : "addresses"} from ${evmHost}${evmRpc.builtIn ? " (the built-in Hood RPC)" : ""} in ${1 + 2 * n} requests. That endpoint sees them together; Candle sees none of them.
+`);
+    }
+    const evmRead2 = evmRpc && evmEntries && evmEntries.length > 0 ? await startEvmRead(evmEntries.map((entry) => entry.address), evmRpc.url, deps.fetch) : undefined;
+    const [candle, vaultRead, evmBalances] = await Promise.all([
       apiRequest("/api/v1/agent/portfolio", {
         auth: "key",
         credentials: { apiKey },
@@ -59799,11 +62586,17 @@ async function portfolio(args, ctx) {
         fetch: deps.fetch,
         env: deps.env
       }),
-      vaultEntries ? readOwnRpc(vaultEntries.map((entry) => entry.address), solana, ctx) : Promise.resolve(undefined)
+      solana && vaultEntries && vaultEntries.length > 0 ? readOwnRpc(vaultEntries.map((entry) => entry.address), solana, ctx) : Promise.resolve(undefined),
+      evmRead2 ? evmRead2.balances() : Promise.resolve(undefined)
     ]);
     if (vaultRead?.failure !== undefined) {
       const n = vaultRead.unavailable.length;
       deps.stderr.write(`${n} vault ${n === 1 ? "address" : "addresses"} could not be read: ${vaultRead.failure}.
+`);
+    }
+    if (evmBalances?.failure !== undefined) {
+      const n = evmBalances.unavailable.length;
+      deps.stderr.write(`${n} EVM vault ${n === 1 ? "address" : "addresses"} on Hood could not be read in full: ${terminalText(evmBalances.failure)}.
 `);
     }
     if (!candle.ok) {
@@ -59812,6 +62605,7 @@ async function portfolio(args, ctx) {
     }
     const fromCandle = candle.body;
     const prices = { ...fromCandle.prices ?? {} };
+    const candleHood = showHood ? fromCandle.hood : undefined;
     let priceFailure;
     if (vaultRead) {
       const wanted = new Set;
@@ -59838,84 +62632,244 @@ async function portfolio(args, ctx) {
           priceFailure ??= priced.message;
       }
     }
+    if (evmBalances) {
+      const wanted = [];
+      const held = [...evmBalances.byAddress.values()];
+      if (held.some((b) => (b.wei ?? 0n) > 0n))
+        wanted.push(HOOD_NATIVE);
+      if (held.some((b) => (b.usdg ?? 0n) > 0n))
+        wanted.push(HOOD_USDG);
+      const missing = wanted.filter((asset) => prices[hoodPriceKey(asset)] === undefined);
+      if (missing.length > 0) {
+        const priced = await apiRequest("/api/v1/agent/prices", {
+          method: "POST",
+          body: { hood: missing },
+          auth: "key",
+          credentials: { apiKey },
+          apiUrl: ctx.apiUrl,
+          fetch: deps.fetch,
+          env: deps.env
+        });
+        if (priced.ok)
+          Object.assign(prices, priced.body.prices ?? {});
+        else
+          priceFailure ??= priced.message;
+      }
+    }
     if (priceFailure !== undefined) {
       deps.stderr.write(`Some vault holdings could not be priced: ${terminalText(priceFailure)}. They are shown as unpriced.
 `);
     }
+    const lpSection = showSolana ? fromCandle.lp : undefined;
     const lpByWallet = new Map;
     const lpOf = (address) => {
       const entry = lpByWallet.get(address) ?? { positions: [], unread: [] };
       lpByWallet.set(address, entry);
       return entry;
     };
-    for (const position of fromCandle.lp?.positions ?? [])
+    for (const position of lpSection?.positions ?? [])
       lpOf(position.wallet).positions.push(lpRow(position, prices));
-    for (const unread of fromCandle.lp?.unreadable ?? [])
+    for (const unread of lpSection?.unreadable ?? [])
       lpOf(unread.wallet).unread.push(unread.position);
-    const wallet = (address, read, extra) => {
-      const holdings = read === undefined ? null : valueHoldings(read, prices);
-      const unread = read === undefined ? [] : [...read.lamports === null ? ["sol"] : [], ...read.tokens === null ? ["tokens"] : []];
-      const lp2 = fromCandle.lp ? lpOf(address) : undefined;
+    const wallet = (chain2, address, read, extra) => {
+      const lp2 = chain2 === "solana" && lpSection ? lpOf(address) : undefined;
       return {
+        chain: chain2,
         address,
         ...extra,
-        holdings,
-        ...unread.length > 0 ? { unread } : {},
+        holdings: read.holdings,
+        ...read.unread.length > 0 ? { unread: read.unread } : {},
+        ...read.truncated ? { truncated: true } : {},
         ...lp2 ? { lpPositions: lp2.positions } : {},
         ...lp2 && lp2.unread.length > 0 ? { lpUnread: lp2.unread } : {},
-        valueUsd: (holdings ?? []).reduce((sum, h) => sum + (h.valueUsd ?? 0), 0) + (lp2?.positions ?? []).reduce((sum, p) => sum + (p.valueUsd ?? 0), 0),
-        unpriced: (holdings ?? []).filter((h) => h.priceUsd === null).length + (lp2?.positions ?? []).filter((p) => p.valueUsd === null).length
+        valueUsd: (read.holdings ?? []).reduce((sum, h) => sum + (h.valueUsd ?? 0), 0) + (lp2?.positions ?? []).reduce((sum, p) => sum + (p.valueUsd ?? 0), 0),
+        unpriced: (read.holdings ?? []).filter((h) => h.priceUsd === null).length + (lp2?.positions ?? []).filter((p) => p.valueUsd === null).length
       };
     };
+    const subtotals = (wallets2) => Object.fromEntries(chains.map((chain2) => {
+      const on = wallets2.filter((w) => w.chain === chain2);
+      return [
+        chain2,
+        {
+          valueUsd: on.reduce((sum, w) => sum + w.valueUsd, 0),
+          unpriced: on.reduce((sum, w) => sum + w.unpriced, 0)
+        }
+      ];
+    }));
     const group = (name2, wallets2, read, reason) => ({
       group: name2,
       read,
       ...reason !== undefined ? { reason } : {},
       wallets: wallets2,
       valueUsd: wallets2.reduce((sum, w) => sum + w.valueUsd, 0),
-      unpriced: wallets2.reduce((sum, w) => sum + w.unpriced, 0)
+      unpriced: wallets2.reduce((sum, w) => sum + w.unpriced, 0),
+      byChain: subtotals(wallets2)
     });
-    const orNull = (read) => read.lamports === null && read.tokens === null ? undefined : read;
+    const solanaRows = (rows) => showSolana ? rows ?? [] : [];
     const groups = [
-      group("vault", (vaultEntries ?? []).map((entry) => {
-        const read = vaultRead?.byAddress.get(entry.address);
-        return wallet(entry.address, read ? orNull(read) : undefined, { label: entry.label, role: entry.role });
-      }), vaultEntries !== undefined, vaultReason),
-      group("tee", (fromCandle.tee ?? []).map((row) => wallet(row.address, orNull(row), {
-        id: row.id,
-        ...row.label ? { label: row.label } : {},
-        active: row.active
-      })), true),
-      group("embedded", (fromCandle.embedded ?? []).map((row) => wallet(row.address, orNull(row), {})), true)
+      group("vault", [
+        ...(vaultEntries ?? []).map((entry) => wallet("solana", entry.address, solanaHoldings(vaultRead?.byAddress.get(entry.address), prices), {
+          label: entry.label,
+          role: entry.role
+        })),
+        ...(evmEntries ?? []).map((entry) => {
+          const read = evmBalances?.byAddress.get(entry.address);
+          return wallet("hood", entry.address, hoodHoldings(read && {
+            wei: read.wei === null ? null : read.wei.toString(),
+            tokens: read.usdg === null ? null : read.usdg > 0n ? [
+              {
+                mint: HOOD_USDG,
+                amountRaw: read.usdg.toString(),
+                decimals: HOOD_USDG_DECIMALS,
+                symbol: "USDG"
+              }
+            ] : []
+          }, prices, "usdg"), { label: entry.label, role: "vault" });
+        })
+      ], vaultEntries !== undefined, vaultReason),
+      group("tee", [
+        ...solanaRows(fromCandle.tee).map((row) => wallet("solana", row.address, solanaHoldings(row, prices), {
+          id: row.id,
+          ...row.label ? { label: row.label } : {},
+          active: row.active
+        })),
+        ...(candleHood?.tee ?? []).map((row) => wallet("hood", row.address, hoodHoldings(row, prices, "hood-tokens"), {
+          id: row.id,
+          ...row.label ? { label: row.label } : {},
+          active: row.active
+        }))
+      ], true),
+      group("embedded", [
+        ...solanaRows(fromCandle.embedded).map((row) => wallet("solana", row.address, solanaHoldings(row, prices), {})),
+        ...(candleHood?.embedded ?? []).map((row) => wallet("hood", row.address, hoodHoldings(row, prices, "hood-tokens"), {}))
+      ], true)
     ];
-    const unavailable = [...vaultRead?.unavailable ?? [], ...fromCandle.unavailable ?? []];
-    const lpUnread = (fromCandle.lp?.unreadable ?? []).length;
-    const complete = fromCandle.complete !== false && unavailable.length === 0 && lpUnread === 0;
+    const unavailableByChain = {
+      solana: showSolana ? [...vaultRead?.unavailable ?? [], ...fromCandle.unavailable ?? []] : [],
+      hood: [...evmBalances?.unavailable ?? [], ...candleHood?.unavailable ?? []]
+    };
+    const unavailable = chains.flatMap((chain2) => unavailableByChain[chain2]);
+    const lpUnread = (lpSection?.unreadable ?? []).length;
+    const candleExplained = (fromCandle.unavailable ?? []).length > 0 || (fromCandle.hood?.unavailable ?? []).length > 0 || (fromCandle.lp?.unreadable ?? []).length > 0;
+    const listCutOff = fromCandle.complete === false && !candleExplained;
+    const complete = !listCutOff && unavailable.length === 0 && lpUnread === 0;
     const totalUsd = groups.reduce((sum, g) => sum + g.valueUsd, 0);
     const unpriced = groups.reduce((sum, g) => sum + g.unpriced, 0);
-    const lp = fromCandle.lp ? {
-      positions: fromCandle.lp.positions.length,
-      unpriced: fromCandle.lp.positions.filter((p) => p.valueUsd === null).length,
+    const lp = lpSection ? {
+      positions: lpSection.positions.length,
+      unpriced: lpSection.positions.filter((p) => p.valueUsd === null).length,
       unreadable: lpUnread,
-      valueUsd: fromCandle.lp.positions.reduce((sum, p) => sum + (p.valueUsd ?? 0), 0)
+      valueUsd: lpSection.positions.reduce((sum, p) => sum + (p.valueUsd ?? 0), 0)
     } : undefined;
+    const all = groups.flatMap((g) => g.wallets);
+    const byChain = subtotals(all);
+    for (const chain2 of chains) {
+      const entry = byChain[chain2];
+      if (!entry)
+        continue;
+      entry.wallets = all.filter((w) => w.chain === chain2).length;
+      entry.unavailable = unavailableByChain[chain2].length;
+    }
+    const hoodTotals = byChain.hood;
+    if (hoodTotals) {
+      const reasons = { ...candleHood?.unpricedByReason ?? {} };
+      let vaultUnpriced = 0;
+      for (const w of groups[0]?.wallets ?? []) {
+        if (w.chain !== "hood")
+          continue;
+        for (const h of w.holdings ?? []) {
+          if (h.priceUsd !== null)
+            continue;
+          vaultUnpriced += 1;
+          const reason = h.unpricedReason ?? "source-unavailable";
+          reasons[reason] = (reasons[reason] ?? 0) + 1;
+        }
+      }
+      if (candleHood)
+        hoodTotals.unpriced = (candleHood.unpriced ?? 0) + vaultUnpriced;
+      hoodTotals.unpricedByReason = reasons;
+    }
     if (ctx.json) {
       writeJson(deps, {
         ok: true,
+        chains,
         totalUsd,
         unpriced,
         complete,
         unavailable,
-        rpcHost,
+        unavailableByChain: Object.fromEntries(chains.map((chain2) => [chain2, unavailableByChain[chain2]])),
+        rpcHost: rpcHost ?? null,
+        ...evmHost !== undefined ? { evmRpcHost: evmHost } : {},
         ...lp ? { lp } : {},
+        byChain,
         groups
       });
       return complete ? 0 : 3;
     }
-    writeTable(ctx, groups, { totalUsd, unpriced, unavailable: unavailable.length, lp });
+    writeTable(ctx, groups, {
+      totalUsd,
+      unpriced,
+      chains,
+      byChain,
+      unavailableByChain,
+      listCutOff,
+      lp
+    });
     return complete ? 0 : 3;
   });
 }
+async function startEvmRead(addresses, rpcUrl, fetchFn) {
+  const rpc = createEvmRpc(rpcUrl, fetchFn);
+  const host = rpcHostOf2(rpcUrl);
+  const unique = [...new Set(addresses)];
+  const message = (error) => error instanceof Error ? error.message : String(error);
+  let chainId;
+  try {
+    chainId = await rpc.chainId();
+  } catch (error) {
+    const failure = message(error);
+    return {
+      balances: async () => ({
+        byAddress: new Map(unique.map((address) => [address, { wei: null, usdg: null }])),
+        unavailable: unique,
+        failure
+      })
+    };
+  }
+  if (chainId !== BigInt(HOOD_CHAIN_ID)) {
+    throw new VaultError("EVM_CHAIN_MISMATCH", `${host} answered chain id ${chainId}; candle portfolio reads EVM vault keys on Hood, chain id ${HOOD_CHAIN_ID}, only.`, {
+      suggestion: "Nothing was read or priced. Point --evm-rpc-url (or CANDLE_EVM_RPC_URL) at a Hood RPC, or pass --chain solana."
+    });
+  }
+  return {
+    balances: async () => {
+      const byAddress = new Map;
+      let failure;
+      let next = 0;
+      await Promise.all(Array.from({ length: Math.min(EVM_READS_IN_FLIGHT, unique.length) }, async () => {
+        while (next < unique.length) {
+          const address = unique[next++];
+          const read = async (call) => {
+            try {
+              return await call();
+            } catch (error) {
+              failure ??= message(error);
+              return null;
+            }
+          };
+          const wei = await read(() => rpc.getBalance(address));
+          const usdg = await read(() => rpc.erc20BalanceOf(HOOD_USDG, address));
+          byAddress.set(address, { wei, usdg });
+        }
+      }));
+      const unavailable = unique.filter((address) => {
+        const read = byAddress.get(address);
+        return read === undefined || read.wei === null || read.usdg === null;
+      });
+      return { byAddress, unavailable, ...failure === undefined ? {} : { failure } };
+    }
+  };
+}
 async function readOwnRpc(addresses, solana, ctx) {
   const { rpc } = solana;
   const unique = [...new Set(addresses)];
@@ -59991,6 +62945,14 @@ async function readOwnRpc(addresses, solana, ctx) {
   }
   return { byAddress, unavailable, ...failure === undefined ? {} : { failure } };
 }
+function solanaHoldings(read, prices) {
+  if (read === undefined || read.lamports === null && read.tokens === null)
+    return { holdings: null, unread: [] };
+  return {
+    holdings: valueHoldings(read, prices),
+    unread: [...read.lamports === null ? ["sol"] : [], ...read.tokens === null ? ["tokens"] : []]
+  };
+}
 function valueHoldings(read, prices) {
   const raw = [];
   if (read.lamports !== null && BigInt(read.lamports) > 0n) {
@@ -60003,6 +62965,7 @@ function valueHoldings(read, prices) {
     const priceUsd = price?.priceUsd ?? null;
     const amount = formatAmount(h.amountRaw, h.decimals);
     return {
+      chain: "solana",
       ...h,
       symbol: KNOWN_SYMBOLS[h.mint] ?? price?.symbol ?? null,
       amount,
@@ -60012,6 +62975,46 @@ function valueHoldings(read, prices) {
     };
   });
 }
+function hoodHoldings(read, prices, tokensPart) {
+  if (read === undefined || read.wei === null && read.tokens === null)
+    return { holdings: null, unread: [] };
+  const raw = [];
+  if (read.wei !== null && BigInt(read.wei) > 0n) {
+    raw.push({ mint: HOOD_NATIVE, amountRaw: read.wei, decimals: NATIVE_DECIMALS, program: "native", symbol: "ETH" });
+  }
+  for (const token of read.tokens ?? []) {
+    if (!/^\d+$/.test(token.amountRaw) || BigInt(token.amountRaw) === 0n)
+      continue;
+    raw.push({
+      mint: token.mint,
+      amountRaw: token.amountRaw,
+      decimals: token.decimals,
+      program: "erc20",
+      ...token.symbol ? { symbol: token.symbol } : {}
+    });
+  }
+  const holdings = raw.map(({ symbol, ...h }) => {
+    const price = prices[hoodPriceKey(h.mint)];
+    const priceUsd = price?.priceUsd ?? null;
+    const amount = formatAmount(h.amountRaw, h.decimals);
+    const known = h.mint.toLowerCase() === HOOD_USDG_ADDRESS ? "USDG" : undefined;
+    return {
+      chain: "hood",
+      ...h,
+      symbol: known ?? symbol ?? price?.symbol ?? null,
+      amount,
+      priceUsd,
+      valueUsd: priceUsd === null ? null : Number(amount) * priceUsd,
+      priceSource: price?.source ?? null,
+      ...priceUsd === null ? { unpricedReason: price?.unpricedReason ?? "source-unavailable" } : {}
+    };
+  });
+  return {
+    holdings,
+    unread: [...read.wei === null ? ["eth"] : [], ...read.tokens === null ? [tokensPart] : []],
+    ...read.truncated ? { truncated: true } : {}
+  };
+}
 function lpRow(position, prices) {
   return {
     position: position.position,
@@ -60056,34 +63059,35 @@ function writeTable(ctx, groups, totals) {
         lpRows.push([g.group, name2, shortAddress2(position), "-", "not read", "-", "-"]);
       }
       if (w.holdings === null) {
-        rows.push([g.group, name2, "-", "not read", "-", "-"]);
+        rows.push([g.group, w.chain, name2, "-", "not read", "-", "-"]);
         continue;
       }
       const sorted = [...w.holdings].sort((a, b) => (b.valueUsd ?? -1) - (a.valueUsd ?? -1));
       for (const h of sorted) {
         rows.push([
           g.group,
+          w.chain,
           name2,
           h.symbol ?? shortAddress2(h.mint),
           h.amount,
           h.priceUsd === null ? "unpriced" : formatPrice(h.priceUsd),
-          h.valueUsd === null ? "-" : formatUsd(h.valueUsd)
+          h.valueUsd === null ? h.unpricedReason ?? "-" : formatUsd(h.valueUsd)
         ]);
       }
       for (const part of w.unread ?? [])
-        rows.push([g.group, name2, part === "sol" ? "SOL" : "tokens", "not read", "-", "-"]);
+        rows.push([g.group, w.chain, name2, UNREAD_LABELS[part], "not read", "-", "-"]);
     }
     const empty = g.wallets.length - shown.length;
-    const count = `${g.wallets.length} ${g.wallets.length === 1 ? "wallet" : "wallets"}`;
+    const count2 = `${g.wallets.length} ${g.wallets.length === 1 ? "wallet" : "wallets"}`;
     notes.push([
       g.group,
       g.read ? formatUsd(g.valueUsd) : "-",
-      g.read ? `${count}${empty > 0 ? `, ${empty} empty not shown` : ""}${lpCount > 0 ? `, ${lpCount} LP ${lpCount === 1 ? "position" : "positions"}` : ""}${lpUnread > 0 ? `, ${lpUnread} LP not read` : ""}${g.unpriced > 0 ? `, ${g.unpriced} unpriced` : ""}` : g.reason ?? "not read"
+      g.read ? `${count2}${empty > 0 ? `, ${empty} empty not shown` : ""}${lpCount > 0 ? `, ${lpCount} LP ${lpCount === 1 ? "position" : "positions"}` : ""}${lpUnread > 0 ? `, ${lpUnread} LP not read` : ""}${g.unpriced > 0 ? `, ${g.unpriced} unpriced` : ""}` : g.reason ?? "not read"
     ]);
   }
   if (rows.length > 0)
     deps.stdout.write(`
-${renderTable(["GROUP", "WALLET", "TOKEN", "AMOUNT", "PRICE", "VALUE"], rows.map((row) => row.map(terminalText)))}
+${renderTable(["GROUP", "CHAIN", "WALLET", "TOKEN", "AMOUNT", "PRICE", "VALUE"], rows.map((row) => row.map(terminalText)))}
 `);
   else
     deps.stdout.write(`
@@ -60094,6 +63098,17 @@ Nothing held in any wallet read.
 LP positions
 ${renderTable(["GROUP", "WALLET", "POSITION", "POOL", "HOLDINGS", "UNCLAIMED FEES", "VALUE"], lpRows.map((row) => row.map(terminalText)))}
 `);
+  for (const chain2 of totals.chains) {
+    const sub = totals.byChain[chain2];
+    if (!sub)
+      continue;
+    const reasons = Object.entries(sub.unpricedByReason ?? {}).filter(([, n]) => (n ?? 0) > 0).map(([reason, n]) => `${n} ${reason}`);
+    notes.push([
+      chain2,
+      formatUsd(sub.valueUsd),
+      `${sub.wallets} ${sub.wallets === 1 ? "wallet" : "wallets"}${sub.unpriced > 0 ? `, ${sub.unpriced} unpriced${reasons.length > 0 ? ` (${reasons.join(", ")})` : ""}` : ""}`
+    ]);
+  }
   notes.push([
     "total",
     formatUsd(totals.totalUsd),
@@ -60104,16 +63119,31 @@ ${renderTable(["GROUP", "WALLET", "POSITION", "POOL", "HOLDINGS", "UNCLAIMED FEE
   deps.stdout.write(`
 `);
   for (const [label, value, note] of notes) {
-    deps.stdout.write(`${label.padEnd(width)}  ${value.padStart(valueWidth)}  ${note}
+    deps.stdout.write(`${label.padEnd(width)}  ${value.padStart(valueWidth)}  ${terminalText(note)}
+`);
+  }
+  const unreadByChain = totals.chains.map((chain2) => [chain2, totals.unavailableByChain[chain2].length]).filter(([, n]) => n > 0);
+  const unavailable = unreadByChain.reduce((sum, [, n]) => sum + n, 0);
+  if (unavailable > 0) {
+    deps.stdout.write(`${unavailable} ${unavailable === 1 ? "wallet" : "wallets"} could not be read in full (${unreadByChain.map(([chain2, n]) => `${n} on ${CHAIN_NAMES[chain2]}`).join(", ")}). What was not read is marked "not read" and is not in the total.
+`);
+  }
+  if (totals.listCutOff) {
+    deps.stdout.write(`Candle listed only part of this account's wallets. The total is partial.
 `);
   }
-  if (totals.unavailable > 0) {
-    deps.stdout.write(`${totals.unavailable} ${totals.unavailable === 1 ? "wallet" : "wallets"} could not be read in full. What was not read is marked "not read" and is not in the total.
+  const truncated = groups.flatMap((g) => g.wallets).filter((w) => w.truncated).length;
+  if (truncated > 0) {
+    deps.stdout.write(`${truncated} Hood ${truncated === 1 ? "wallet holds" : "wallets hold"} more tokens than Candle lists. The rest are not shown and not in the total.
 `);
   }
   if ((totals.lp?.unreadable ?? 0) > 0) {
     const n = totals.lp?.unreadable ?? 0;
     deps.stdout.write(`${n} LP ${n === 1 ? "position" : "positions"} could not be read (the pool did not answer). ${n === 1 ? "It is" : "They are"} marked "not read" and not in the total.
+`);
+  }
+  if (groups.some((g) => g.group === "vault" && g.wallets.some((w) => w.chain === "hood"))) {
+    deps.stdout.write(`EVM vault keys are read for ETH and USDG only; other tokens they hold are not shown.
 `);
   }
 }
@@ -60641,7 +63671,7 @@ function displayLines(input) {
   lines.push("note        the simulation is evidence, not a guarantee: a program can behave differently once signed");
   return lines;
 }
-async function sign3(args, ctx) {
+async function sign4(args, ctx) {
   const lifted = takeRepeatedFlag(args, "--wallet");
   if ("error" in lifted)
     return usage(ctx, lifted.error);
@@ -60932,7 +63962,7 @@ init_evm_lite();
 init_profiles();
 init_render();
 init_trading();
-var USAGE3 = "Usage: candle transfer --to <address|wallet name|vault> --asset <SOL|USDC|CNDL|ETH|USDG>|--mint <mint>|--token <0x...> --amount <decimal|max> [--wallet <name>] [--rpc-url <url>] [--yes] [--json]";
+var USAGE4 = "Usage: candle transfer --to <address|wallet name|vault> --asset <SOL|USDC|CNDL|ETH|USDG>|--mint <mint>|--token <0x...> --amount <decimal|max> [--wallet <name>] [--rpc-url <url>] [--yes] [--json]";
 var TRANSFER_ASSETS = [...Object.keys(BASES), ...Object.keys(HOOD_BASES)];
 var BASE58_ADDRESS = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
 async function readLinkedWallets(ctx, key) {
@@ -61018,7 +64048,7 @@ async function transfer(args, ctx) {
   const flags = parsed.values;
   const asset = flags["--asset"]?.toUpperCase();
   if (parsed.positionals.length !== 0 || !flags["--to"] || !flags["--amount"] || [flags["--asset"], flags["--mint"], flags["--token"]].filter(Boolean).length !== 1 || asset !== undefined && !TRANSFER_ASSETS.includes(asset) || flags["--mint"] !== undefined && !BASE58_ADDRESS.test(flags["--mint"]) || flags["--token"] !== undefined && !checkEvmAddress(flags["--token"]).ok) {
-    writeUsageFailure(ctx.deps, USAGE3, ctx.json);
+    writeUsageFailure(ctx.deps, USAGE4, ctx.json);
     return 2;
   }
   const to = flags["--to"];
@@ -63660,11 +66690,11 @@ Anyone who reads them can move every derived key's funds.
 `);
   return 0;
 }
-function randomPositions(count, of = PHRASE_WORDS) {
+function randomPositions(count2, of = PHRASE_WORDS) {
   const chosen = new Set;
   const scratch = new Uint32Array(1);
   const limit = Math.floor(4294967296 / of) * of;
-  while (chosen.size < count) {
+  while (chosen.size < count2) {
     crypto.getRandomValues(scratch);
     const draw = scratch[0] ?? 0;
     if (draw >= limit)
@@ -64149,10 +67179,10 @@ init_solana_lite();
 init_token_2022();
 init_errors();
 var USDC_MINT2 = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
-function decimalToRaw2(decimal, decimals) {
-  if (!/^\d+(\.\d+)?$/.test(decimal))
+function decimalToRaw2(decimal2, decimals) {
+  if (!/^\d+(\.\d+)?$/.test(decimal2))
     return null;
-  const [whole, frac = ""] = decimal.split(".");
+  const [whole, frac = ""] = decimal2.split(".");
   if (frac.length > decimals)
     return null;
   return BigInt((whole ?? "0") + frac.padEnd(decimals, "0"));
@@ -64720,11 +67750,11 @@ function mapLegacyTeeEntry(entry, keyId, grant, createdAtFallback) {
 }
 function buildTeeMeta(entry, lifecycle, grant) {
   const source = entry.tee;
-  const network = source?.network ?? "solana-mainnet";
-  if (network !== "solana-mainnet") {
-    throw new VaultError("VAULT_INDEX_INVALID", `Legacy entry ${entry.address} names network ${String(network)}; only solana-mainnet migrates.`);
+  const network2 = source?.network ?? "solana-mainnet";
+  if (network2 !== "solana-mainnet") {
+    throw new VaultError("VAULT_INDEX_INVALID", `Legacy entry ${entry.address} names network ${String(network2)}; only solana-mainnet migrates.`);
   }
-  const meta = { network, lifecycle };
+  const meta = { network: network2, lifecycle };
   carryOptional(meta, source, [
     "vaultDestination",
     "boundKeyPrefix",
@@ -64736,7 +67766,7 @@ function buildTeeMeta(entry, lifecycle, grant) {
     "sweptAt"
   ]);
   if (lifecycle === "local-candidate") {
-    return { network, lifecycle };
+    return { network: network2, lifecycle };
   }
   if (lifecycle === "enabled") {
     if (meta.vaultDestination === undefined) {
@@ -65072,8 +68102,8 @@ async function readEvmBalances(addresses, rpcUrl, fetchFn) {
   }
   return read;
 }
-function evmRequestsPlanned(count) {
-  return `${1 + count} to ${1 + 2 * count}`;
+function evmRequestsPlanned(count2) {
+  return `${1 + count2} to ${1 + 2 * count2}`;
 }
 async function vaultList(args, ctx) {
   const parsed = parseArgs(args, {
@@ -67700,9 +70730,9 @@ function resolveTarget(index, old, id) {
     throw new VaultError("VAULT_LABEL_NOT_FOUND", id === undefined ? `No key in this vault is called ${old}, and no key has that address or id.` : `No key in this vault has the id ${id}.`, { suggestion: "List them with their labels: `candle vault status --unlock`" });
   }
   const candidates = match.candidates.map((entry) => `${entry.address} (${entry.id})`).join(", ");
-  const count = match.candidates.length;
+  const count2 = match.candidates.length;
   const first = match.candidates[0];
-  throw new VaultError("VAULT_LABEL_AMBIGUOUS", match.by === "label" ? `${count} keys in this vault are called ${old}, so this rename would not say which one it meant. Nothing was written.` : `${count} keys in this vault have the address ${old}, so this rename would not say which one it meant. Nothing was written.`, {
+  throw new VaultError("VAULT_LABEL_AMBIGUOUS", match.by === "label" ? `${count2} keys in this vault are called ${old}, so this rename would not say which one it meant. Nothing was written.` : `${count2} keys in this vault have the address ${old}, so this rename would not say which one it meant. Nothing was written.`, {
     suggestion: match.by === "label" ? `Name one by address or id. The candidates are ${candidates}.` : `Name one by id. The candidates are ${candidates}. Re-run: \`candle vault rename ${old} <new-label> --id ${first.id}\`.`
   });
 }
@@ -67866,7 +70896,7 @@ async function discardIncompleteRestore(ctx, path, sidecarExisted) {
   }
 }
 var RESTORED_BRANCHES = ["solanaVault", "solanaTee", "solanaExternal"];
-function parseCounts(count, teeCount, externalCount, rpcUrl, evmCount, evmTeeCount) {
+function parseCounts(count2, teeCount, externalCount, rpcUrl, evmCount, evmTeeCount) {
   const parse = (raw, flag) => {
     if (raw === undefined)
       return;
@@ -67875,7 +70905,7 @@ function parseCounts(count, teeCount, externalCount, rpcUrl, evmCount, evmTeeCou
       return { error: `${flag} must be a whole number, zero or greater.` };
     return value;
   };
-  const vaultCount = parse(count, "--count");
+  const vaultCount = parse(count2, "--count");
   if (typeof vaultCount === "object" && vaultCount !== null)
     return vaultCount;
   const teeParsed = parse(teeCount, "--tee-count");
@@ -68148,7 +71178,7 @@ async function writeRestoredIndex(ctx, vault, derived, matches2, counts) {
   await commitVault(vault, { index: { hd, entries }, addKeys: derived.entries.map((entry) => entry.blob) }, ctx.deps);
   return { entries, hd };
 }
-function teeFieldsFor(row, ctx, network = "solana-mainnet") {
+function teeFieldsFor(row, ctx, network2 = "solana-mainnet") {
   const remoteState = row.sweptAt !== undefined ? "swept" : row.revokedAt !== undefined ? "quarantined" : "enabled";
   const grantIdentity = {
     account: "",
@@ -68156,7 +71186,7 @@ function teeFieldsFor(row, ctx, network = "solana-mainnet") {
     source: "recorded-at-operation"
   };
   const common = {
-    network,
+    network: network2,
     ...row.vaultDestination !== undefined ? { vaultDestination: row.vaultDestination } : {},
     ...row.boundKeyPrefix !== undefined ? { boundKeyPrefix: row.boundKeyPrefix } : {},
     ...row.remoteAuthority !== undefined ? { remoteAuthority: row.remoteAuthority } : {},
@@ -69005,7 +72035,7 @@ init_args();
 init_release();
 import { dirname as dirname10, join as join11 } from "node:path";
 init_render();
-var USAGE4 = "Usage: candle verify <file> --bundle <path> [--identity <uri>] [--issuer <url>]";
+var USAGE5 = "Usage: candle verify <file> --bundle <path> [--identity <uri>] [--issuer <url>]";
 async function resolveIdentity(deps, bundlePath, flag) {
   if (flag)
     return { kind: "ok", uri: flag, provenance: "identity from --identity" };
@@ -69037,19 +72067,19 @@ async function verify(args, ctx) {
   });
   if ("error" in parsed) {
     writeUsageFailure(deps, `${parsed.error}
-${USAGE4}`, json);
+${USAGE5}`, json);
     return 2;
   }
   const file = parsed.positionals[0];
   if (parsed.positionals.length !== 1 || file === undefined) {
     writeUsageFailure(deps, `verify takes exactly one file.
-${USAGE4}`, json);
+${USAGE5}`, json);
     return 2;
   }
   const bundlePath = parsed.values["--bundle"];
   if (!bundlePath) {
     writeUsageFailure(deps, `--bundle is required.
-${USAGE4}`, json);
+${USAGE5}`, json);
     return 2;
   }
   const resolved = await resolveIdentity(deps, bundlePath, parsed.values["--identity"]);
@@ -69063,7 +72093,7 @@ ${USAGE4}`, json);
   }
   if (resolved.kind === "absent") {
     writeUsageFailure(deps, `--identity is required: there is no latest.json beside ${bundlePath} to take the release version from.
-${USAGE4}`, json);
+${USAGE5}`, json);
     return 2;
   }
   const identity = resolved.uri;
@@ -69111,8 +72141,8 @@ init_wallets();
 init_args();
 init_render();
 init_trading();
-import { randomUUID as randomUUID4 } from "node:crypto";
-var USAGE5 = "Usage: candle wallet close-empty [--wallet embedded] [--keep <mint>]... [--client-trade-id <id>] [--yes] [--json]";
+import { randomUUID as randomUUID5 } from "node:crypto";
+var USAGE6 = "Usage: candle wallet close-empty [--wallet embedded] [--keep <mint>]... [--client-trade-id <id>] [--yes] [--json]";
 var BASE58_ADDRESS2 = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
 var LISTED_ROWS = 50;
 function splitKeep(args) {
@@ -69143,7 +72173,7 @@ function solOf(lamports) {
   const digits = lamports.padStart(10, "0");
   return `${digits.slice(0, -9)}.${digits.slice(-9)}`.replace(/\.?0+$/, "");
 }
-function previewLines(preview) {
+function previewLines2(preview) {
   const lines = [
     `Close ${preview.accountCount} empty token account${preview.accountCount === 1 ? "" : "s"} on the embedded wallet ${safeText(preview.wallet)}`,
     `Rent returned to that same wallet: ${safeText(preview.totalSol)} SOL in ${preview.transactions} transaction${preview.transactions === 1 ? "" : "s"}, network fee about ${solOf(preview.estimatedFeeLamports)} SOL, net ${safeText(preview.netSol)} SOL`
@@ -69187,7 +72217,7 @@ async function embeddedSolana(ctx, key, wallet) {
 async function walletsCloseEmpty(args, ctx) {
   const lifted = splitKeep(args);
   if ("error" in lifted) {
-    writeUsageFailure(ctx.deps, `${lifted.error}. ${USAGE5}`, ctx.json);
+    writeUsageFailure(ctx.deps, `${lifted.error}. ${USAGE6}`, ctx.json);
     return 2;
   }
   const parsed = parseArgs(lifted.rest, { valueFlags: ["--wallet", "--client-trade-id"], booleanFlags: ["--yes"] });
@@ -69196,9 +72226,9 @@ async function walletsCloseEmpty(args, ctx) {
     return 2;
   }
   const named = parsed.values["--client-trade-id"];
-  const id = named ?? `close-${randomUUID4()}`;
+  const id = named ?? `close-${randomUUID5()}`;
   if (parsed.positionals.length !== 0 || !validClientId(id) || !lifted.keep.every((m) => BASE58_ADDRESS2.test(m))) {
-    writeUsageFailure(ctx.deps, USAGE5, ctx.json);
+    writeUsageFailure(ctx.deps, USAGE6, ctx.json);
     return 2;
   }
   const keep = lifted.keep;
@@ -69223,7 +72253,7 @@ async function walletsCloseEmpty(args, ctx) {
       const output = ctx.json ? ctx.deps.stderr : ctx.deps.stdout;
       output.write(`No empty token accounts to close on the embedded wallet ${safeText(wallet)}.
 `);
-      for (const line of previewLines(preview).slice(2))
+      for (const line of previewLines2(preview).slice(2))
         output.write(`${line}
 `);
       return printTradingResult(ctx, {
@@ -69233,7 +72263,7 @@ async function walletsCloseEmpty(args, ctx) {
         preview
       });
     }
-    const confirmed = await confirmClose(ctx, previewLines(preview), parsed.booleans.has("--yes"));
+    const confirmed = await confirmClose(ctx, previewLines2(preview), parsed.booleans.has("--yes"));
     if (!confirmed)
       return printTradingResult(ctx, {
         success: true,
@@ -69326,7 +72356,7 @@ function trustTable(rows) {
 }
 async function setTrust(args, ctx, trusted) {
   const { deps, apiUrl, json } = ctx;
-  const usage5 = trusted ? USAGE_TRUST : USAGE_UNTRUST;
+  const usage6 = trusted ? USAGE_TRUST : USAGE_UNTRUST;
   const command = trusted ? "wallets trust" : "wallets untrust";
   const parsed = parseArgs(args, trusted ? {} : { booleanFlags: ["--yes"] });
   if ("error" in parsed) {
@@ -69334,7 +72364,7 @@ async function setTrust(args, ctx, trusted) {
     return 2;
   }
   if (parsed.positionals.length === 0) {
-    writeUsageFailure(deps, `Name at least one wallet. ${usage5}`, json);
+    writeUsageFailure(deps, `Name at least one wallet. ${usage6}`, json);
     return 2;
   }
   const skipConfirm = !trusted && parsed.booleans.has("--yes");
@@ -69605,7 +72635,20 @@ var COMMANDS = {
   launch: { bare: launch },
   pnl: { bare: pnl },
   portfolio: { bare: portfolio },
+  plans: { bare: plans },
   lp: { subcommands: { pools: lpPools, add: lpAdd, positions: lpPositions, remove: lpRemove, claim: lpClaim } },
+  perps: {
+    subcommands: {
+      setup: perpsSetup,
+      deposit: perpsDeposit,
+      open: perpsOpen,
+      close: perpsClose,
+      cancel: perpsCancel,
+      orders: perpsOrders,
+      positions: perpsPositions,
+      leverage: perpsLeverage
+    }
+  },
   auth: { subcommands: { login: authLogin, status: authStatus, logout: authLogout } },
   keys: {
     subcommands: {
@@ -69677,7 +72720,7 @@ var COMMANDS = {
     }
   },
   external: { subcommands: { new: externalNew, list: externalList, sweep: externalSweep } },
-  sign: { subcommands: { message: signMessage2 }, bare: sign3 },
+  sign: { subcommands: { message: signMessage2 }, bare: sign4 },
   secrets: { subcommands: { set: secretsSet, list: secretsList, remove: secretsRemove } },
   plugins: { bare: plugins },
   doctor: { bare: doctor },
@@ -69719,6 +72762,7 @@ var NEVER_GUARDED = new Set([
   "profile",
   "doctor",
   "verify",
+  "plans",
   "update",
   "help",
   "completion",
@@ -69981,8 +73025,8 @@ async function buildRealDeps() {
       const { runStdioServer: runStdioServer2 } = await Promise.resolve().then(() => (init_server2(), exports_server));
       await runStdioServer2(env);
     },
-    readFile: (path) => readFile9(path, "utf8"),
-    readBytes: (path) => readFile9(path),
+    readFile: (path) => readFile10(path, "utf8"),
+    readBytes: (path) => readFile10(path),
     readStdin: () => new Promise((resolve4, reject) => {
       const chunks = [];
       process.stdin.on("data", (chunk) => chunks.push(chunk));