@candledottv/cli 0.11.13 → 0.11.14

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 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);
     };
-    const broadcast2 = (instructions, pending) => broadcastAndFinalize(rpc, ctx, secret, teePubkey, instructions, pending, recordPending, clearPending);
+    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.
@@ -49488,7 +49845,7 @@ var init_convert = __esm(() => {
 });
 
 // ../mcp/src/version.ts
-var SERVER_VERSION = "0.10.4";
+var SERVER_VERSION = "0.10.5";
 
 // ../mcp/src/update-notice.ts
 function newer(a, b) {
@@ -49940,6 +50297,630 @@ 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.");
+  }
+}
+var decimal3, wallet, submit, perpsShapes, PATHS, Refusal;
+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;
+    }
+  };
+});
+
 // ../mcp/src/tools.ts
 function resolveToolAllowlist(env) {
   const raw = env.CANDLE_MCP_TOOLS?.trim();
@@ -50279,12 +51260,53 @@ 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. Free, Believer and Pro pay a 0.1% builder fee; 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"));
 }
 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_update_notice();
   TOOL_NAMES = [
     "candle_launch_token",
@@ -50306,7 +51328,14 @@ 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"
   ];
   launchTokenShape = {
     clientLaunchId: exports_external.string().describe("Caller-chosen idempotency key, unique per account"),
@@ -50481,7 +51510,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 +51558,7 @@ init_render();
 init_secret_store();
 
 // src/version.ts
-var CLI_VERSION = "0.11.13";
+var CLI_VERSION = "0.11.14";
 
 // src/commands/auth.ts
 init_keys_embedded_wallet();
@@ -50945,6 +51974,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",
@@ -51090,6 +52124,53 @@ var HELP = {
     ],
     env: ENV_API
   },
+  perps: {
+    group: "Trade",
+    summary: "Hyperliquid perpetuals from your EVM TEE wallet: setup, 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. Free, Believer and Pro pay a 0.1% builder fee; Max pays none.",
+    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: "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)"
+      },
+      { 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 (default 100)"
+      },
+      { invocation: "--tp <px> / --sl <px>", description: "open: reduce-only take-profit and stop-loss triggers" },
+      { 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 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",
@@ -51151,24 +52232,33 @@ 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 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, with a row per paying wallet. Both show a Solana block, a Hood block, then the combined figure, and a CHAIN column on positions and wallet rows. Unpriced positions are shown as unpriced and never valued at zero. 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); the total then covers tokens and LP.",
     usage: ["candle pnl [--profile <name>] [--json]"],
     rows: [],
     examples: ["candle pnl", "candle pnl --profile scalper --json"],
@@ -58970,7 +60060,14 @@ 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"
 ];
 var READ_ONLY_TOOL_NAMES = [
   "candle_get_market",
@@ -59078,6 +60175,827 @@ async function mcp(args, ctx) {
   }
 }
 
+// src/commands/perps.ts
+init_args();
+import { 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);
+  }
+}
+
 // src/commands/plugins.ts
 init_args();
 
@@ -59271,20 +61189,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 +61214,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 +61234,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 +61255,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 +61387,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)
@@ -59500,6 +61418,8 @@ function shortAddress2(address) {
 }
 
 // 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.",
@@ -59567,6 +61487,7 @@ async function pnl(args, ctx) {
     deps.stdout.write(`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,
@@ -59583,6 +61504,7 @@ async function pnl(args, ctx) {
       lp
     });
     writePositions(ctx, p.openPositions, false);
+    writeWallets(ctx, p.byWallet);
     writeLpPositions(ctx, lp, false);
     return 0;
   }
@@ -59590,6 +61512,7 @@ async function pnl(args, ctx) {
   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,
@@ -59603,6 +61526,68 @@ async function pnl(args, ctx) {
   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(s.realizedNetUsd + s.unrealizedUsd), "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 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) {
+  if (!wallets2 || wallets2.length === 0)
+    return;
+  const rows = wallets2.map((w) => [
+    `${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)` : ""}`
+  ]);
+  ctx.deps.stdout.write(`
+By wallet (each its own cost basis, so the rows need not sum to the total)
+${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 = [
@@ -59642,12 +61627,7 @@ function writeSummary(ctx, s) {
   } else {
     lines.push(["Total", formatUsd(s.realizedNetUsd + s.unrealizedUsd), "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.oldestMarkAt !== undefined) {
     ctx.deps.stdout.write(`Marks as old as ${new Date(s.oldestMarkAt).toISOString()}.
 `);
@@ -59708,12 +61688,13 @@ No open positions.
 `);
     return;
   }
-  const headers = ["TOKEN", "QUANTITY", "AVG ENTRY", "MARK", "UNREALIZED"];
+  const headers = ["TOKEN", "CHAIN", "QUANTITY", "AVG ENTRY", "MARK", "UNREALIZED"];
   if (withBook)
     headers.push("BOOK");
   const rows = positions.map((p) => {
     const row = [
       p.symbol?.trim() || shortAddress2(p.mint),
+      p.chain ?? "-",
       formatQuantity(p.quantity),
       formatPrice(p.avgEntryUsd),
       p.markPriceUsd !== undefined ? formatPrice(p.markPriceUsd) : "unpriced",
@@ -59732,10 +61713,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 +61729,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 +61807,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 +61834,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 +61853,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 +61880,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 +62193,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 +62213,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 +62223,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,22 +62307,23 @@ 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"}`;
@@ -60083,7 +62335,7 @@ function writeTable(ctx, groups, totals) {
   }
   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 +62346,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 +62367,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.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.
+  if (totals.listCutOff) {
+    deps.stdout.write(`Candle listed only part of this account's wallets. The total is partial.
+`);
+  }
+  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 +62919,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);
@@ -64149,10 +66427,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 +66998,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 +67014,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) {
@@ -68148,7 +70426,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 +70434,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 } : {},
@@ -69143,7 +71421,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`
@@ -69223,7 +71501,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 +71511,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 +71604,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 +71612,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");
@@ -69606,6 +71884,17 @@ var COMMANDS = {
   pnl: { bare: pnl },
   portfolio: { bare: portfolio },
   lp: { subcommands: { pools: lpPools, add: lpAdd, positions: lpPositions, remove: lpRemove, claim: lpClaim } },
+  perps: {
+    subcommands: {
+      setup: perpsSetup,
+      open: perpsOpen,
+      close: perpsClose,
+      cancel: perpsCancel,
+      orders: perpsOrders,
+      positions: perpsPositions,
+      leverage: perpsLeverage
+    }
+  },
   auth: { subcommands: { login: authLogin, status: authStatus, logout: authLogout } },
   keys: {
     subcommands: {
@@ -69677,7 +71966,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 },
@@ -69981,8 +72270,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));