@kashdao/cli 0.1.0

package/dist/protocol-XEQXF2GW.js

@@ -0,0 +1,1572 @@
+#!/usr/bin/env node
+import {
+  loadRawPrivateKey,
+  resolveCliCustomChain
+} from "./chunk-YJX3JJ4M.js";
+import {
+  formatAddress,
+  formatBigDecimal,
+  formatGwei,
+  formatUsdcAtomic,
+  formatWad
+} from "./chunk-BRK7KJ4O.js";
+import {
+  readConfig
+} from "./chunk-KMBMQIZ7.js";
+import {
+  DEFAULT_SLIPPAGE_BPS,
+  HEX_HASH_REGEX,
+  MAX_UINT256,
+  decimalToAtomicUsdc,
+  decimalToAtomicWad,
+  extractPartialHash,
+  parseDeadlineSec,
+  parseOutcomeIndex,
+  parseSlippageBps,
+  parseUppercaseSide,
+  validateAddress,
+  validateAddressOptional
+} from "./chunk-YHCG2SUC.js";
+import {
+  parseOptionalPositiveFloat,
+  parseOptionalPositiveInt,
+  parsePositiveInt,
+  readGlobals
+} from "./chunk-LBIRQHX5.js";
+import {
+  isQuiet,
+  log,
+  print,
+  printJson,
+  style,
+  writeNdjson
+} from "./chunk-VIADBYFY.js";
+import "./chunk-MIXOZU2S.js";
+import {
+  CliError,
+  CliValidationError,
+  EXIT_CODES,
+  toCliError
+} from "./chunk-UZNSYATZ.js";
+
+// src/commands/protocol/index.ts
+import { Command as Command13 } from "commander";
+
+// src/commands/protocol/allowance.ts
+import { Command } from "commander";
+
+// src/utils/direct-client.ts
+async function buildDirectClient(opts) {
+  const globals = opts.globals;
+  const config = await readConfig({
+    ...globals?.profile === void 0 ? {} : { profile: globals.profile },
+    ...globals?.configPath === void 0 ? {} : { configPath: globals.configPath }
+  });
+  const rpc = globals?.baseUrl ?? config.rpcUrl;
+  if (!rpc) {
+    throw missingDirectConfig("rpcUrl", "--rpc-url or `kash config set rpcUrl <url>`");
+  }
+  if (!config.smartAccount) {
+    throw missingDirectConfig(
+      "smartAccount",
+      "`kash config set smartAccount 0x\u2026` (the ERC-4337 account address whose funds you trade with)"
+    );
+  }
+  const { createSmartAccountClient } = await import("@kashdao/protocol-sdk");
+  const signer = opts.requireSigner ? await loadSigner(config.signerKeyRef) : noopSigner();
+  const bundlerConfig = resolveBundlerConfig(config);
+  const customChain = await maybeBuildCustomChain(config, rpc);
+  if (customChain !== void 0 && customChain.smartAccount === void 0) {
+    throw missingDirectConfig(
+      "customChain.smartAccount",
+      "all three: `kash config set customChain.smartAccount.factoryAddress 0x\u2026`, `customChain.smartAccount.implementationAddress 0x\u2026`, `customChain.smartAccount.entryPointAddress 0x\u2026` (SA mode requires the local SimpleAccount factory + EntryPoint addresses on a custom chain \u2014 Anvil deploys these to addresses that differ from the canonical permissionless.js defaults)"
+    );
+  }
+  const client = createSmartAccountClient({
+    chainId: config.defaultChainId,
+    rpc,
+    signer,
+    ...bundlerConfig === void 0 ? {} : { bundler: bundlerConfig },
+    ...customChain === void 0 ? {} : { customChain }
+  });
+  return {
+    client,
+    chainId: config.defaultChainId,
+    smartAccount: config.smartAccount
+  };
+}
+function noopSigner() {
+  return {
+    ownerAddress: "0x0000000000000000000000000000000000000000",
+    async signUserOpHash() {
+      throw new CliError("CLI bug: read-only direct-mode command attempted to sign a UserOp.", {
+        code: "UNEXPECTED",
+        suggestion: "File an issue at https://github.com/KashDAO/cli/issues \u2014 this should not happen."
+      });
+    }
+  };
+}
+async function loadSigner(ref) {
+  const rawKey = await loadRawPrivateKey(ref);
+  const [{ privateKeyToAccount }, { viemAccountSigner }] = await Promise.all([
+    import("viem/accounts"),
+    import("@kashdao/protocol-sdk")
+  ]);
+  return viemAccountSigner(privateKeyToAccount(rawKey));
+}
+function resolveBundlerConfig(config) {
+  if (config.bundlerProvider === void 0 && config.bundlerUrl === void 0) {
+    return void 0;
+  }
+  if (config.bundlerProvider === void 0) {
+    return config.bundlerUrl;
+  }
+  if (config.bundlerUrl === void 0) {
+    throw new CliError(
+      `Direct-mode config: bundlerProvider="${config.bundlerProvider}" requires a bundlerUrl.`,
+      {
+        code: "DIRECT_CONFIG_MISSING",
+        suggestion: "`kash config set bundlerUrl <provider-rpc-url>` (e.g. https://api.pimlico.io/v2/8453/rpc?apikey=\u2026)"
+      }
+    );
+  }
+  return {
+    provider: config.bundlerProvider,
+    url: config.bundlerUrl
+  };
+}
+async function maybeBuildCustomChain(config, rpc) {
+  if (config.customChain === void 0) return void 0;
+  if (config.defaultChainId === void 0) {
+    throw missingDirectConfig(
+      "defaultChainId",
+      "`kash config set defaultChainId <id>` (required when customChain is set so the CLI can construct the viem chain)"
+    );
+  }
+  return resolveCliCustomChain({
+    customChain: config.customChain,
+    chainId: config.defaultChainId,
+    rpc
+  });
+}
+function missingDirectConfig(field, hint) {
+  return new CliError(`Direct-mode config missing: ${field}.`, {
+    code: "DIRECT_CONFIG_MISSING",
+    exitCode: EXIT_CODES.GENERIC,
+    suggestion: `Set ${field} via ${hint}.`,
+    actions: [
+      {
+        type: "check_input",
+        field,
+        description: hint
+      }
+    ]
+  });
+}
+
+// src/commands/protocol/allowance.ts
+var allowanceCommand = new Command("allowance").description("Read the on-chain USDC allowance from `account` to `spender`.").argument("<spender>", "spender contract address (e.g. a market) \u2014 0x-prefixed").argument("[account]", "owner address (default: profile's smartAccount)").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash protocol allowance 0xMarket...
+  $ kash protocol allowance 0xMarket... 0xOwner...
+  $ kash protocol allowance 0xMarket... --json --quiet | jq -r '.allowanceAtomic'
+
+Notes:
+  - The allowance is returned in USDC atomic units (6 decimals). A
+    value larger than the trade's atomic-USDC input means \`approve\`
+    can be skipped on the next trade.
+`
+).action(async (spender, account, _opts, cmd) => {
+  const globals = readGlobals(cmd);
+  const spenderAddress = validateAddress(spender, "spender");
+  const accountAddress = validateAddressOptional(account, "account");
+  try {
+    const resolved = await buildDirectClient({ globals });
+    const owner = accountAddress ?? resolved.smartAccount;
+    const allowance = await resolved.client.account.usdcAllowance(owner, spenderAddress);
+    const payload = {
+      owner,
+      spender: spenderAddress,
+      chainId: resolved.chainId,
+      allowanceAtomic: allowance.toString()
+    };
+    if (globals.json) {
+      printJson(payload);
+      return;
+    }
+    print("");
+    print(`  ${style.dim("Owner   ")} ${formatAddress(owner, 10, 8)}`);
+    print(`  ${style.dim("Spender ")} ${formatAddress(spenderAddress, 10, 8)}`);
+    print(
+      `  ${style.dim("Allowance")} ${formatUsdcAtomic(allowance.toString())} ${style.dim(`(${allowance.toString()} atomic)`)}`
+    );
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+});
+
+// src/commands/protocol/balance.ts
+import { Command as Command2 } from "commander";
+var balanceCommand = new Command2("balance").description("Read on-chain USDC + gas balance for a smart account (defaults to the profile's).").argument("[account]", "smart-account address (defaults to the active profile's smartAccount)").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash protocol balance
+  $ kash protocol balance 0xabc...
+  $ kash protocol balance --json --quiet | jq '.usdcAtomic'
+
+Direct-mode requires rpcUrl + smartAccount + signerKeyRef configured
+on the active profile (signer is loaded but never invoked for reads).
+`
+).action(async (account, _opts, cmd) => {
+  const globals = readGlobals(cmd);
+  const accountOverride = validateAddressOptional(account, "account");
+  let resolved;
+  try {
+    resolved = await buildDirectClient({ globals });
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+  const target = accountOverride ?? resolved.smartAccount;
+  let usdcAtomic;
+  let gasWei;
+  try {
+    [usdcAtomic, gasWei] = await Promise.all([
+      resolved.client.account.usdcBalance(target),
+      resolved.client.account.gasBalance(target)
+    ]);
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+  const payload = {
+    account: target,
+    chainId: resolved.chainId,
+    usdcAtomic: usdcAtomic.toString(),
+    gasWei: gasWei.toString()
+  };
+  if (globals.json) {
+    printJson(payload);
+    return;
+  }
+  print("");
+  print(`  ${style.dim("Account     ")} ${formatAddress(target, 10, 8)}`);
+  print(`  ${style.dim("Chain       ")} ${String(resolved.chainId)}`);
+  print(`  ${style.dim("USDC        ")} ${formatUsdcAtomic(usdcAtomic.toString())}`);
+  print(
+    `  ${style.dim("ETH (gas)   ")} ${formatBigDecimal(gasWei, { baseDecimals: 18, displayDecimals: 6 })} ETH`
+  );
+});
+
+// src/commands/protocol/decode-revert.ts
+import { Command as Command3 } from "commander";
+var HEX_DATA_RE = /^0x[0-9a-fA-F]+$/;
+var decodeRevertCommand = new Command3("decode-revert").description("Decode raw revert data into (name, args) using the Market + EntryPoint ABIs.").argument("<data>", "raw revert data (0x-prefixed hex)").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash protocol decode-revert 0x4e487b710000000000000000000000000000000000000000000000000000000000000011
+  $ kash protocol decode-revert 0x... --json --quiet | jq -r '.name'
+
+Notes:
+  - Returns \`null\` if the selector doesn't match any known error
+    (the data may be raw \`Error(string)\` or vendor-specific).
+  - The \`args\` array stringifies bigint values to preserve precision.
+`
+).action(async (data, _opts, cmd) => {
+  const globals = readGlobals(cmd);
+  if (!HEX_DATA_RE.test(data) || data.length < 10) {
+    throw new CliValidationError(
+      "<data> must be 0x-prefixed hex with at least a 4-byte selector.",
+      `Got "${data}".`,
+      "data"
+    );
+  }
+  try {
+    const { decodeMarketRevert } = await import("@kashdao/protocol-sdk");
+    const decoded = decodeMarketRevert(data);
+    const args = decoded?.args.map((a) => typeof a === "bigint" ? a.toString() : a) ?? null;
+    const payload = decoded === null ? null : { name: decoded.name, args };
+    if (globals.json) {
+      printJson(payload);
+      return;
+    }
+    if (decoded === null) {
+      print("");
+      print(`  ${style.dim("No match \u2014 selector not in Market or EntryPoint ABIs.")}`);
+      print(`  ${style.dim("Data: ")}${data.slice(0, 10)}${data.length > 10 ? "\u2026" : ""}`);
+      return;
+    }
+    print("");
+    print(`  ${style.dim("Error  ")} ${style.bold(decoded.name)}`);
+    if (args && args.length > 0) {
+      print(`  ${style.dim("Args   ")}`);
+      for (const [i, arg] of args.entries()) {
+        print(`    [${String(i)}] ${String(arg)}`);
+      }
+    } else {
+      print(`  ${style.dim("Args   ")} (none)`);
+    }
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+});
+
+// src/commands/protocol/fees.ts
+import { Command as Command4 } from "commander";
+var feesCommand = new Command4("fees").description("EIP-1559 fee estimate for the configured chain (uses eth_feeHistory).").option("--blocks <n>", "number of recent blocks to sample (default 4)").option(
+  "--percentile <n>",
+  "priority-fee percentile to take from each sampled block (1-99, default 50)"
+).option(
+  "--base-multiplier <n>",
+  "multiplier applied to predicted next-block base fee (default 2.0; raise for congested chains)"
+).option("--priority-floor-gwei <n>", "floor for maxPriorityFeePerGas in gwei (default 1)").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash protocol fees
+  $ kash protocol fees --base-multiplier 3 --json --quiet | jq -r '.maxFeePerGas'
+  $ kash protocol fees --blocks 16 --percentile 75   # smoother, more conservative
+`
+).action(async (options, cmd) => {
+  const globals = readGlobals(cmd);
+  const blocks = parseOptionalPositiveInt(options.blocks, "blocks");
+  const percentile = parseOptionalPositiveInt(options.percentile, "percentile");
+  if (percentile !== void 0 && (percentile < 1 || percentile > 99)) {
+    throw new CliValidationError(
+      "--percentile must be between 1 and 99.",
+      void 0,
+      "percentile"
+    );
+  }
+  const baseMultiplier = parseOptionalPositiveFloat(options.baseMultiplier, "base-multiplier");
+  const priorityFloorGwei = parseOptionalPositiveInt(
+    options.priorityFloorGwei,
+    "priority-floor-gwei"
+  );
+  try {
+    const resolved = await buildDirectClient({ globals });
+    const estimate = await resolved.client.bundler.estimateFees({
+      ...blocks === void 0 ? {} : { blockCount: blocks },
+      ...percentile === void 0 ? {} : { rewardPercentile: percentile },
+      ...baseMultiplier === void 0 ? {} : { baseMultiplier },
+      ...priorityFloorGwei === void 0 ? {} : { priorityFeeFloorWei: BigInt(priorityFloorGwei) * 10n ** 9n }
+    });
+    const payload = {
+      chainId: resolved.chainId,
+      maxFeePerGas: estimate.maxFeePerGas.toString(),
+      maxPriorityFeePerGas: estimate.maxPriorityFeePerGas.toString()
+    };
+    if (globals.json) {
+      printJson(payload);
+      return;
+    }
+    print("");
+    print(`  ${style.dim("Chain    ")} ${String(resolved.chainId)}`);
+    print(
+      `  ${style.dim("maxFee   ")} ${formatGwei(estimate.maxFeePerGas)} gwei ${style.dim(`(${estimate.maxFeePerGas.toString()} wei)`)}`
+    );
+    print(
+      `  ${style.dim("maxPrio  ")} ${formatGwei(estimate.maxPriorityFeePerGas)} gwei ${style.dim(`(${estimate.maxPriorityFeePerGas.toString()} wei)`)}`
+    );
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+});
+
+// src/commands/protocol/market.ts
+import { Command as Command5 } from "commander";
+var marketCommand = new Command5("market").description("Read on-chain market state (reserves, supplies, weights, derived probabilities).").argument("<address>", "market contract address (0x-prefixed)").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash protocol market 0xabc...
+  $ kash protocol market 0xabc... --json --quiet | jq '.outcomes'
+`
+).action(async (address, _opts, cmd) => {
+  const globals = readGlobals(cmd);
+  validateAddress(address, "address");
+  let resolved;
+  let state;
+  try {
+    resolved = await buildDirectClient({ globals });
+    state = await resolved.client.markets.state(address);
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+  const payload = {
+    marketAddress: state.marketAddress,
+    chainId: resolved.chainId,
+    status: state.status,
+    readAt: state.readAt.toString(),
+    reserveWad: state.reserveWad.toString(),
+    outcomes: state.outcomes.map((o) => ({
+      index: o.index,
+      outstandingTokensWad: o.outstandingTokensWad.toString(),
+      weightWad: o.weightWad.toString(),
+      probability: o.probability
+    }))
+  };
+  if (globals.json) {
+    printJson(payload);
+    return;
+  }
+  print("");
+  print(`  ${style.dim("Market   ")} ${formatAddress(state.marketAddress, 10, 8)}`);
+  print(`  ${style.dim("Status   ")} ${state.status}`);
+  print(`  ${style.dim("Outcomes ")} ${String(state.outcomes.length)}`);
+  print("");
+  for (const outcome of state.outcomes) {
+    const pct = (outcome.probability * 100).toFixed(2);
+    print(
+      `  [${String(outcome.index)}] p=${pct}%  outstanding=${formatWad(outcome.outstandingTokensWad)}  weight=${formatWad(outcome.weightWad)}`
+    );
+  }
+});
+
+// src/commands/protocol/position.ts
+import { Command as Command6 } from "commander";
+var positionCommand = new Command6("position").description("Read on-chain outcome-token holdings (ERC-1155) for a market.").argument("<market>", "market contract address (0x-prefixed)").argument(
+  "[account]",
+  "EOA or smart-account address whose holdings to read (default: profile's smartAccount)"
+).addHelpText(
+  "after",
+  `
+Examples:
+  $ kash protocol position 0xMarket...
+  $ kash protocol position 0xMarket... 0xOther...
+  $ kash protocol position 0xMarket... --json --quiet | jq '.holdings[].balanceWad'
+`
+).action(async (market, account, _opts, cmd) => {
+  const globals = readGlobals(cmd);
+  const marketAddr = validateAddress(market, "market");
+  const accountAddr = validateAddressOptional(account, "account");
+  let resolved;
+  let position;
+  try {
+    resolved = await buildDirectClient({ globals });
+    const target = accountAddr ?? resolved.smartAccount;
+    position = await resolved.client.account.position(target, marketAddr);
+    const payload = {
+      account: target,
+      marketAddress: position.marketAddress,
+      chainId: resolved.chainId,
+      numOutcomes: position.numOutcomes,
+      holdings: position.holdings.map((h) => ({
+        outcomeIndex: h.outcomeIndex,
+        balanceWad: h.balanceWad.toString()
+      }))
+    };
+    if (globals.json) {
+      printJson(payload);
+      return;
+    }
+    print("");
+    print(`  ${style.dim("Account  ")} ${formatAddress(target, 10, 8)}`);
+    print(`  ${style.dim("Market   ")} ${formatAddress(position.marketAddress, 10, 8)}`);
+    print(`  ${style.dim("Outcomes ")} ${String(position.numOutcomes)}`);
+    print("");
+    for (const h of position.holdings) {
+      const balanceLabel = formatWad(h.balanceWad);
+      print(
+        `  [${String(h.outcomeIndex)}] balance=${balanceLabel} ${style.dim(`(${h.balanceWad.toString()} WAD)`)}`
+      );
+    }
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+});
+
+// src/commands/protocol/quote.ts
+import { Command as Command7 } from "commander";
+var quoteCommand = new Command7("quote").description("On-chain price quote for buying or selling an outcome.").argument("<address>", "market contract address (0x-prefixed)").requiredOption("-s, --side <buy|sell>", "trade side: buy or sell").requiredOption("-o, --outcome <index>", "outcome index (0-based)").requiredOption(
+  "-a, --amount <decimal>",
+  'amount: USDC decimal for buy (e.g. "10"), outcome-token decimal for sell (e.g. "1.5")'
+).addHelpText(
+  "after",
+  `
+Examples:
+  $ kash protocol quote 0xabc... --side buy --outcome 0 --amount 10
+  $ kash protocol quote 0xabc... --side sell --outcome 1 --tokens 1.5 --json
+`
+).action(async (address, options, cmd) => {
+  const globals = readGlobals(cmd);
+  const marketAddress = validateAddress(address, "address");
+  const side = parseUppercaseSide(options.side, "side");
+  const outcome = parseOutcomeIndex(options.outcome);
+  const amount = side === "BUY" ? decimalToAtomicUsdc(options.amount, "amount") : decimalToAtomicWad(options.amount, "amount");
+  let resolved;
+  let quote;
+  try {
+    resolved = await buildDirectClient({ globals });
+    quote = await resolved.client.markets.quote(marketAddress, {
+      side,
+      outcome,
+      amount
+    });
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+  const payload = {
+    side: quote.side,
+    outcomeIndex: quote.outcomeIndex,
+    amountIn: quote.amountIn.toString(),
+    amountOut: quote.amountOut.toString(),
+    reserveAfterWad: quote.reserveAfterWad.toString(),
+    pricesAfterWad: quote.pricesAfterWad.map((p) => p.toString())
+  };
+  if (globals.json) {
+    printJson(payload);
+    return;
+  }
+  print("");
+  print(`  ${style.dim("Market    ")} ${formatAddress(address, 10, 8)}`);
+  print(`  ${style.dim("Action    ")} ${quote.side} outcome ${String(quote.outcomeIndex)}`);
+  if (quote.side === "BUY") {
+    print(`  ${style.dim("Spend     ")} ${formatUsdcAtomic(quote.amountIn)}`);
+    print(`  ${style.dim("Tokens out")} ${formatWad(quote.amountOut)}`);
+  } else {
+    print(`  ${style.dim("Tokens in ")} ${formatWad(quote.amountIn)}`);
+    print(`  ${style.dim("USDC out  ")} ${formatUsdcAtomic(quote.amountOut)}`);
+  }
+  print(
+    `  ${style.dim("Probs after")} [${quote.pricesAfterWad.map((p) => `${(Number(p) / 1e18 * 100).toFixed(2)}%`).join(", ")}]`
+  );
+});
+
+// src/commands/protocol/smart-account.ts
+import { Command as Command8 } from "commander";
+var computeCommand = new Command8("compute").description("Derive the deterministic smart-account address for an EOA owner.").requiredOption("-o, --owner <address>", "EOA owner address (0x-prefixed)").option("-s, --salt <n>", "optional salt as a non-negative integer (default 0)", "0").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash protocol smart-account compute --owner 0xEoa...
+  $ kash protocol smart-account compute --owner 0xEoa... --salt 1
+  $ kash protocol smart-account compute --owner 0xEoa... --json --quiet | jq -r '.address'
+`
+).action(async (options, cmd) => {
+  const globals = readGlobals(cmd);
+  const ownerAddress = validateAddress(options.owner, "owner");
+  let salt;
+  if (options.salt !== void 0) {
+    let parsed;
+    try {
+      parsed = BigInt(options.salt);
+    } catch {
+      throw new CliValidationError(
+        "--salt must be a non-negative integer (decimal or 0x-hex).",
+        `Got "${options.salt}".`,
+        "salt"
+      );
+    }
+    if (parsed < 0n) {
+      throw new CliValidationError(
+        "--salt must be non-negative.",
+        `Got "${options.salt}".`,
+        "salt"
+      );
+    }
+    salt = parsed === 0n ? void 0 : parsed;
+  }
+  try {
+    const resolved = await buildDirectClient({ globals });
+    const address = await resolved.client.account.computeAddress(ownerAddress, salt);
+    const payload = {
+      owner: ownerAddress,
+      salt: (salt ?? 0n).toString(),
+      chainId: resolved.chainId,
+      address
+    };
+    if (globals.json) {
+      printJson(payload);
+      return;
+    }
+    print("");
+    print(`  ${style.dim("Owner  ")} ${formatAddress(ownerAddress, 10, 8)}`);
+    print(`  ${style.dim("Salt   ")} ${(salt ?? 0n).toString()}`);
+    print(`  ${style.dim("Address")} ${address}`);
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+});
+var isDeployedCommand = new Command8("is-deployed").description("Check whether a smart account has bytecode (i.e. has been deployed on-chain).").argument("[address]", "smart account address (default: profile's smartAccount)").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash protocol smart-account is-deployed
+  $ kash protocol smart-account is-deployed 0xSa...
+  $ kash protocol smart-account is-deployed --json --quiet | jq -r '.deployed'
+`
+).action(async (address, _opts, cmd) => {
+  const globals = readGlobals(cmd);
+  const addressOverride = validateAddressOptional(address, "address");
+  try {
+    const resolved = await buildDirectClient({ globals });
+    const target = addressOverride ?? resolved.smartAccount;
+    const deployed = await resolved.client.account.isDeployed(target);
+    const payload = {
+      address: target,
+      chainId: resolved.chainId,
+      deployed
+    };
+    if (globals.json) {
+      printJson(payload);
+      return;
+    }
+    print("");
+    print(`  ${style.dim("Address ")} ${formatAddress(target, 10, 8)}`);
+    print(
+      `  ${style.dim("Deployed")} ${deployed ? style.success("yes") : style.dim("no \u2014 first UserOp will deploy")}`
+    );
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+});
+var smartAccountCommand = new Command8("smart-account").description("Smart-account address derivation and deployment-status checks.").addCommand(computeCommand).addCommand(isDeployedCommand);
+
+// src/commands/protocol/token-id.ts
+import { Command as Command9 } from "commander";
+var tokenIdCommand = new Command9("token-id").description(
+  "Compute the ERC-1155 token id for a (marketId, outcomeIndex) pair (offline; no RPC)."
+).requiredOption(
+  "-m, --market-id <bigint>",
+  "on-chain numeric market id (decimal or 0x-prefixed hex)"
+).requiredOption("-o, --outcome <index>", "outcome index (0-255)").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash protocol token-id --market-id 42 --outcome 0
+  $ kash protocol token-id --market-id 0x2a --outcome 1 --json --quiet | jq -r '.tokenId'
+
+Notes:
+  - The numeric \`marketId\` is the on-chain id read from
+    \`IMarket(<addr>).marketId()\`. It's NOT the same as the market
+    contract address.
+  - The token id encoding is \`(marketId << 8) | outcomeIndex\`,
+    matching the on-chain \`OutcomeTokens1155\` contract.
+`
+).action(async (options, cmd) => {
+  const globals = readGlobals(cmd);
+  let marketId;
+  try {
+    marketId = BigInt(options.marketId);
+  } catch {
+    throw new CliValidationError(
+      "--market-id must be a non-negative integer (decimal or 0x-hex).",
+      `Got "${options.marketId}".`,
+      "market-id"
+    );
+  }
+  if (marketId < 0n) {
+    throw new CliValidationError(
+      "--market-id must be non-negative.",
+      `Got "${options.marketId}".`,
+      "market-id"
+    );
+  }
+  const outcomeIndex = Number.parseInt(options.outcome, 10);
+  if (!Number.isFinite(outcomeIndex) || outcomeIndex < 0 || outcomeIndex > 255) {
+    throw new CliValidationError(
+      "--outcome must be an integer between 0 and 255.",
+      `Got "${options.outcome}".`,
+      "outcome"
+    );
+  }
+  try {
+    const { tokenIdFor } = await import("@kashdao/protocol-sdk");
+    const tokenId = tokenIdFor(marketId, outcomeIndex);
+    const payload = {
+      marketId: marketId.toString(),
+      outcomeIndex,
+      tokenId: tokenId.toString(),
+      tokenIdHex: `0x${tokenId.toString(16)}`
+    };
+    if (globals.json) {
+      printJson(payload);
+      return;
+    }
+    print("");
+    print(`  ${style.dim("Market id  ")} ${marketId.toString()}`);
+    print(`  ${style.dim("Outcome    ")} ${String(outcomeIndex)}`);
+    print(`  ${style.dim("Token id   ")} ${tokenId.toString()}`);
+    print(`  ${style.dim("  (hex)    ")} 0x${tokenId.toString(16)}`);
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+});
+
+// src/commands/protocol/trade.ts
+import { Command as Command10 } from "commander";
+import ora from "ora";
+
+// src/utils/userop-json.ts
+function serializeUserOp(userOp) {
+  const out = {};
+  for (const [k, v] of Object.entries(userOp)) {
+    out[k] = typeof v === "bigint" ? v.toString() : v;
+  }
+  return out;
+}
+
+// src/commands/protocol/trade.ts
+var buyCommand = new Command10("buy").description("One-shot BUY: prepare \u2192 simulate \u2192 sign \u2192 submit (and wait by default).").argument("<market>", "market contract address (0x-prefixed)").requiredOption("-o, --outcome <index>", "outcome index (0-based)").requiredOption("-a, --amount <usdc>", 'USDC to spend (decimal \u2014 e.g. "10" or "12.50")').option("--slippage-bps <n>", "slippage tolerance in basis points (default 50 = 0.5%)").option("--deadline-sec <n>", "unix-seconds deadline (default now + 5min)").option("--dry-run", "prepare + simulate but DO NOT sign or submit; print the UserOp").option("--no-simulate", "skip the eth_call preflight (faster, riskier)").option("--no-wait", "fire-and-forget: return userOpHash without waiting for inclusion").option("--wait-timeout-ms <n>", "cap on the receipt wait (default 60000)").option("--wait-interval-ms <n>", "receipt poll interval (default 1500)").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash protocol trade buy 0xMarket... -o 0 -a 10
+  $ kash protocol trade buy 0xMarket... -o 0 -a 10 --slippage-bps 100   # 1% slippage
+  $ kash protocol trade buy 0xMarket... -o 0 -a 10 --dry-run --json
+  $ kash protocol trade buy 0xMarket... -o 0 -a 10 --no-wait --json --quiet
+`
+).action(async (market, options, cmd) => {
+  await runTrade("buy", market, options, cmd);
+});
+var sellCommand = new Command10("sell").description("One-shot SELL: prepare \u2192 simulate \u2192 sign \u2192 submit (and wait by default).").argument("<market>", "market contract address (0x-prefixed)").requiredOption("-o, --outcome <index>", "outcome index (0-based)").requiredOption("-t, --tokens <amount>", "outcome tokens to sell (decimal \u2014 WAD precision)").option("--slippage-bps <n>", "slippage tolerance in basis points (default 50 = 0.5%)").option("--deadline-sec <n>", "unix-seconds deadline (default now + 5min)").option("--dry-run", "prepare + simulate but DO NOT sign or submit; print the UserOp").option("--no-simulate", "skip the eth_call preflight (faster, riskier)").option("--no-wait", "fire-and-forget: return userOpHash without waiting for inclusion").option("--wait-timeout-ms <n>", "cap on the receipt wait (default 60000)").option("--wait-interval-ms <n>", "receipt poll interval (default 1500)").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash protocol trade sell 0xMarket... -o 0 -t 1.5
+  $ kash protocol trade sell 0xMarket... -o 1 -t 0.5 --json --quiet
+`
+).action(async (market, options, cmd) => {
+  await runTrade("sell", market, options, cmd);
+});
+var closeCommand = new Command10("close").description("Sell the entire SA balance for an outcome (one-shot prepare \u2192 submit).").argument("<market>", "market contract address (0x-prefixed)").requiredOption("-o, --outcome <index>", "outcome index (0-based)").option("--slippage-bps <n>", "slippage tolerance in basis points (default 50 = 0.5%)").option("--deadline-sec <n>", "unix-seconds deadline (default now + 5min)").option("--dry-run", "prepare + simulate but DO NOT sign or submit; print the UserOp").option("--no-simulate", "skip the eth_call preflight (faster, riskier)").option("--no-wait", "fire-and-forget: return userOpHash without waiting for inclusion").option("--wait-timeout-ms <n>", "cap on the receipt wait (default 60000)").option("--wait-interval-ms <n>", "receipt poll interval (default 1500)").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash protocol trade close 0xMarket... -o 0
+  $ kash protocol trade close 0xMarket... -o 1 --slippage-bps 200 --json
+`
+).action(async (market, options, cmd) => {
+  await runTrade("close", market, options, cmd);
+});
+var approveCommand = new Command10("approve").description("USDC approval \u2014 required once before the first BUY.").argument("<spender>", "spender contract address (typically a Market) \u2014 0x-prefixed").option(
+  "-a, --amount <usdc>",
+  "atomic-USDC amount to approve (decimal); default is unlimited (MAX_UINT256)"
+).option("--dry-run", "prepare + simulate but DO NOT sign or submit; print the UserOp").option("--no-simulate", "skip the eth_call preflight (faster, riskier)").option("--no-wait", "fire-and-forget: return userOpHash without waiting for inclusion").option("--wait-timeout-ms <n>", "cap on the receipt wait (default 60000)").option("--wait-interval-ms <n>", "receipt poll interval (default 1500)").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash protocol trade approve 0xMarket...                     # unlimited approval
+  $ kash protocol trade approve 0xMarket... --amount 100        # cap at 100 USDC
+  $ kash protocol trade approve 0xMarket... --dry-run --json    # preview only
+`
+).action(async (spender, options, cmd) => {
+  await runApprove(spender, options, cmd);
+});
+var tradeCommand = new Command10("trade").description("Direct-mode trade execution (UserOp signed locally, submitted via bundler).").addCommand(buyCommand).addCommand(sellCommand).addCommand(closeCommand).addCommand(approveCommand);
+async function runTrade(side, market, options, cmd) {
+  const globals = readGlobals(cmd);
+  const marketAddress = validateAddress(market, "market");
+  const outcome = parseOutcomeIndex(options.outcome);
+  const slippageBps = options.slippageBps ? parseSlippageBps(options.slippageBps) : DEFAULT_SLIPPAGE_BPS;
+  const deadline = options.deadlineSec ? parseDeadlineSec(options.deadlineSec) : void 0;
+  const waitTimeoutMs = options.waitTimeoutMs ? parsePositiveInt(options.waitTimeoutMs, "wait-timeout-ms") : void 0;
+  const waitIntervalMs = options.waitIntervalMs ? parsePositiveInt(options.waitIntervalMs, "wait-interval-ms") : void 0;
+  let amountUsdc;
+  let amountTokens;
+  if (side === "buy") {
+    const buyOpts = options;
+    amountUsdc = decimalToAtomicUsdc(buyOpts.amount, "amount");
+  } else if (side === "sell") {
+    const sellOpts = options;
+    amountTokens = decimalToAtomicWad(sellOpts.tokens, "tokens");
+  }
+  try {
+    const resolved = await buildDirectClient({ globals, requireSigner: true });
+    if (options.dryRun === true) {
+      const built = await prepareForSide(resolved.client, side, {
+        market: marketAddress,
+        smartAccount: resolved.smartAccount,
+        outcome,
+        slippageBps,
+        ...deadline === void 0 ? {} : { deadline },
+        ...amountUsdc === void 0 ? {} : { amountUsdc },
+        ...amountTokens === void 0 ? {} : { amountTokens },
+        simulate: options.simulate !== false
+      });
+      emitDryRun(built, side, market, globals.json);
+      return;
+    }
+    const sendOptions = {
+      simulate: options.simulate !== false,
+      wait: options.wait !== false,
+      ...waitTimeoutMs === void 0 ? {} : { waitTimeoutMs },
+      ...waitIntervalMs === void 0 ? {} : { waitIntervalMs }
+    };
+    const spinner = !globals.json && !isQuiet() ? ora({
+      text: `Preparing ${side} on ${formatAddress(market, 8, 6)}\u2026`,
+      stream: process.stderr
+    }).start() : void 0;
+    let result;
+    try {
+      if (side === "buy") {
+        result = await resolved.client.trades.send.buy(
+          marketAddress,
+          {
+            account: resolved.smartAccount,
+            outcome,
+            amountUsdc,
+            maxSlippageBps: slippageBps,
+            ...deadline === void 0 ? {} : { deadline }
+          },
+          sendOptions
+        );
+      } else if (side === "sell") {
+        result = await resolved.client.trades.send.sell(
+          marketAddress,
+          {
+            account: resolved.smartAccount,
+            outcome,
+            amountTokens,
+            maxSlippageBps: slippageBps,
+            ...deadline === void 0 ? {} : { deadline }
+          },
+          sendOptions
+        );
+      } else {
+        result = await resolved.client.trades.send.closePosition(
+          marketAddress,
+          {
+            account: resolved.smartAccount,
+            outcome,
+            maxSlippageBps: slippageBps,
+            ...deadline === void 0 ? {} : { deadline }
+          },
+          sendOptions
+        );
+      }
+    } catch (cause) {
+      spinner?.fail(`${side} failed.`);
+      const partialHash = extractPartialUserOpHash(cause);
+      if (partialHash !== void 0) {
+        if (globals.json) {
+          printJson({ userOpHash: partialHash, waited: false, partial: true });
+        } else {
+          log.warn(
+            `Submit succeeded but wait timed out. UserOp is on the bundler queue \u2014 resume with: kash protocol userop wait ${partialHash}`
+          );
+        }
+      }
+      throw cause;
+    }
+    spinner?.succeed(`${side} submitted.`);
+    emitSendResult(result, side, market, globals.json);
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+}
+async function runApprove(spender, options, cmd) {
+  const globals = readGlobals(cmd);
+  const spenderAddress = validateAddress(spender, "spender");
+  const amount = options.amount ? decimalToAtomicUsdc(options.amount, "amount") : MAX_UINT256;
+  const waitTimeoutMs = options.waitTimeoutMs ? parsePositiveInt(options.waitTimeoutMs, "wait-timeout-ms") : void 0;
+  const waitIntervalMs = options.waitIntervalMs ? parsePositiveInt(options.waitIntervalMs, "wait-interval-ms") : void 0;
+  try {
+    const resolved = await buildDirectClient({ globals, requireSigner: true });
+    const params = {
+      account: resolved.smartAccount,
+      spender: spenderAddress,
+      amount
+    };
+    if (options.dryRun === true) {
+      const built = await resolved.client.trades.prepareApprove(params, {
+        simulate: options.simulate !== false
+      });
+      emitDryRun(built, "approve", spender, globals.json);
+      return;
+    }
+    const sendOptions = {
+      simulate: options.simulate !== false,
+      wait: options.wait !== false,
+      ...waitTimeoutMs === void 0 ? {} : { waitTimeoutMs },
+      ...waitIntervalMs === void 0 ? {} : { waitIntervalMs }
+    };
+    const spinner = !globals.json && !isQuiet() ? ora({
+      text: `Approving ${formatAddress(spender, 8, 6)}\u2026`,
+      stream: process.stderr
+    }).start() : void 0;
+    let result;
+    try {
+      result = await resolved.client.trades.send.approve(params, sendOptions);
+    } catch (cause) {
+      spinner?.fail("approve failed.");
+      const partialHash = extractPartialUserOpHash(cause);
+      if (partialHash !== void 0) {
+        if (globals.json) {
+          printJson({ userOpHash: partialHash, waited: false, partial: true });
+        } else {
+          log.warn(
+            `Submit succeeded but wait timed out. The approve UserOp is on the bundler queue \u2014 resume with: kash protocol userop wait ${partialHash}`
+          );
+        }
+      }
+      throw cause;
+    }
+    spinner?.succeed("approve submitted.");
+    emitSendResult(result, "approve", spender, globals.json);
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+}
+async function prepareForSide(client, side, args) {
+  const opts = { simulate: args.simulate };
+  const baseParams = {
+    account: args.smartAccount,
+    outcome: args.outcome,
+    maxSlippageBps: args.slippageBps,
+    ...args.deadline === void 0 ? {} : { deadline: args.deadline }
+  };
+  if (side === "buy") {
+    return await client.trades.prepareBuy(
+      args.market,
+      { ...baseParams, amountUsdc: args.amountUsdc },
+      opts
+    );
+  }
+  if (side === "sell") {
+    return await client.trades.prepareSell(
+      args.market,
+      { ...baseParams, amountTokens: args.amountTokens },
+      opts
+    );
+  }
+  return await client.trades.prepareClosePosition(args.market, baseParams, opts);
+}
+function emitDryRun(built, side, target, json) {
+  const userOp = serializeUserOp(built.userOp);
+  if (json) {
+    printJson({
+      side,
+      target,
+      userOp,
+      userOpHash: built.userOpHash,
+      typedData: built.typedData,
+      dryRun: true
+    });
+    return;
+  }
+  print("");
+  print(`  ${style.bold("Dry run")} \u2014 UserOp prepared but NOT signed/submitted.`);
+  print(`  ${style.dim("Side    ")} ${side}`);
+  print(`  ${style.dim("Target  ")} ${formatAddress(target, 10, 8)}`);
+  const senderRaw = userOp["sender"];
+  const sender = typeof senderRaw === "string" ? senderRaw : "";
+  print(`  ${style.dim("Sender  ")} ${formatAddress(sender, 10, 8)}`);
+  print(`  ${style.dim("Nonce   ")} ${String(userOp["nonce"])}`);
+  print(`  ${style.dim("Hash    ")} ${built.userOpHash}`);
+  print("");
+  print(style.dim("Re-run without --dry-run to sign and submit."));
+}
+function emitSendResult(result, side, target, json) {
+  const waited = "transactionHash" in result;
+  const payload = waited ? {
+    side,
+    target,
+    userOpHash: result.userOpHash,
+    transactionHash: result.transactionHash,
+    blockNumber: result.blockNumber.toString(),
+    success: result.success,
+    actualGasUsed: result.gasUsed.toString()
+  } : {
+    side,
+    target,
+    userOpHash: result.userOpHash,
+    waited: false
+  };
+  if (json) {
+    printJson(payload);
+    return;
+  }
+  print("");
+  if (waited) {
+    if (result.success) {
+      log.success(`${side} included in block ${result.blockNumber.toString()}.`);
+    } else {
+      log.error(`${side} included but reverted on-chain.`);
+    }
+    print(`  ${style.dim("UserOp   ")} ${result.userOpHash}`);
+    print(`  ${style.dim("Tx       ")} ${result.transactionHash}`);
+    print(`  ${style.dim("Block    ")} ${result.blockNumber.toString()}`);
+    print(`  ${style.dim("Gas used ")} ${result.gasUsed.toString()}`);
+  } else {
+    log.success(`${side} submitted (fire-and-forget).`);
+    print(`  ${style.dim("UserOp ")} ${result.userOpHash}`);
+    log.info(`Use \`kash protocol userop wait ${result.userOpHash}\` to poll for inclusion.`);
+  }
+}
+function extractPartialUserOpHash(cause) {
+  return extractPartialHash(cause, {
+    code: "BUNDLER_RECEIPT_TIMEOUT",
+    contextKey: "userOpHash"
+  });
+}
+
+// src/commands/protocol/userop.ts
+import { readFile, writeFile } from "fs/promises";
+import { Command as Command11 } from "commander";
+var buildBuyCommand = new Command11("buy").description("Build a fully-populated unsigned BUY UserOp ready for offline signing.").argument("<market>", "market contract address (0x-prefixed)").requiredOption("-o, --outcome <index>", "outcome index (0-based)").requiredOption("-a, --amount <usdc>", "USDC to spend (decimal)").option("--slippage-bps <n>", "slippage tolerance in bps (default 50 = 0.5%)").option("--deadline-sec <n>", "unix-seconds deadline (default now + 5min)").option("--out <path>", "write the UserOp envelope to a file (default stdout)").option("--no-simulate", "skip eth_call preflight in `prepare`").action(
+  async (market, options, cmd) => {
+    await runBuild("buy", market, options, cmd);
+  }
+);
+var buildSellCommand = new Command11("sell").description("Build a fully-populated unsigned SELL UserOp ready for offline signing.").argument("<market>", "market contract address (0x-prefixed)").requiredOption("-o, --outcome <index>", "outcome index (0-based)").requiredOption("-t, --tokens <amount>", "outcome tokens to sell (WAD decimal)").option("--slippage-bps <n>", "slippage tolerance in bps (default 50 = 0.5%)").option("--deadline-sec <n>", "unix-seconds deadline (default now + 5min)").option("--out <path>", "write the UserOp envelope to a file (default stdout)").option("--no-simulate", "skip eth_call preflight in `prepare`").action(
+  async (market, options, cmd) => {
+    await runBuild("sell", market, options, cmd);
+  }
+);
+var buildCloseCommand = new Command11("close").description("Build a fully-populated unsigned UserOp that closes a position (full balance).").argument("<market>", "market contract address (0x-prefixed)").requiredOption("-o, --outcome <index>", "outcome index (0-based)").option("--slippage-bps <n>", "slippage tolerance in bps (default 50 = 0.5%)").option("--deadline-sec <n>", "unix-seconds deadline (default now + 5min)").option("--out <path>", "write the UserOp envelope to a file (default stdout)").option("--no-simulate", "skip eth_call preflight in `prepare`").action(async (market, options, cmd) => {
+  await runBuild("close", market, options, cmd);
+});
+var buildApproveCommand = new Command11("approve").description("Build a fully-populated unsigned approve UserOp ready for offline signing.").argument("<spender>", "spender contract address (typically a Market) \u2014 0x-prefixed").option("-a, --amount <usdc>", "atomic-USDC amount (decimal); default unlimited (MAX_UINT256)").option("--out <path>", "write the UserOp envelope to a file (default stdout)").option("--no-simulate", "skip eth_call preflight in `prepare`").action(
+  async (spender, options, cmd) => {
+    await runBuildApprove(spender, options, cmd);
+  }
+);
+var buildCommand = new Command11("build").description("Build (prepare) a fully-populated unsigned UserOp ready for offline signing.").addCommand(buildBuyCommand).addCommand(buildSellCommand).addCommand(buildCloseCommand).addCommand(buildApproveCommand);
+async function runBuild(side, market, options, cmd) {
+  const globals = readGlobals(cmd);
+  const marketAddress = validateAddress(market, "market");
+  const outcome = parseOutcomeIndex(options.outcome);
+  const slippageBps = options.slippageBps ? parseSlippageBps(options.slippageBps) : DEFAULT_SLIPPAGE_BPS;
+  const deadline = options.deadlineSec ? parseDeadlineSec(options.deadlineSec) : void 0;
+  let amountUsdc;
+  let amountTokens;
+  if (side === "buy") {
+    amountUsdc = decimalToAtomicUsdc(options.amount, "amount");
+  } else if (side === "sell") {
+    amountTokens = decimalToAtomicWad(options.tokens, "tokens");
+  }
+  try {
+    const resolved = await buildDirectClient({ globals });
+    const baseParams = {
+      account: resolved.smartAccount,
+      outcome,
+      maxSlippageBps: slippageBps,
+      ...deadline === void 0 ? {} : { deadline }
+    };
+    const opts = { simulate: options.simulate !== false };
+    let built;
+    if (side === "buy") {
+      built = await resolved.client.trades.prepareBuy(
+        marketAddress,
+        { ...baseParams, amountUsdc },
+        opts
+      );
+    } else if (side === "sell") {
+      built = await resolved.client.trades.prepareSell(
+        marketAddress,
+        { ...baseParams, amountTokens },
+        opts
+      );
+    } else {
+      built = await resolved.client.trades.prepareClosePosition(marketAddress, baseParams, opts);
+    }
+    await emitBuildResult(built, side, market, options.out, globals.json);
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+}
+async function runBuildApprove(spender, options, cmd) {
+  const globals = readGlobals(cmd);
+  const spenderAddress = validateAddress(spender, "spender");
+  const amount = options.amount ? decimalToAtomicUsdc(options.amount, "amount") : MAX_UINT256;
+  try {
+    const resolved = await buildDirectClient({ globals });
+    const built = await resolved.client.trades.prepareApprove(
+      {
+        account: resolved.smartAccount,
+        spender: spenderAddress,
+        amount
+      },
+      { simulate: options.simulate !== false }
+    );
+    await emitBuildResult(built, "approve", spender, options.out, globals.json);
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+}
+var simulateCommand = new Command11("simulate").description("Simulate (eth_call) an UnsignedUserOp from a file or stdin.").argument("[file]", 'path to a UserOp JSON file (omit or pass "-" for stdin)').addHelpText(
+  "after",
+  `
+Examples:
+  $ kash protocol userop build buy 0xMarket... -o 0 -a 10 --out trade.json
+  $ kash protocol userop simulate trade.json
+  $ cat trade.json | kash protocol userop simulate
+`
+).action(async (file, _opts, cmd) => {
+  const globals = readGlobals(cmd);
+  try {
+    const userOp = await readUnsignedUserOp(file);
+    const resolved = await buildDirectClient({ globals });
+    const result = await resolved.client.trades.simulate(userOp);
+    if (globals.json) {
+      printJson(serializeSimulationResult(result));
+      return;
+    }
+    print("");
+    if (result.willSucceed) {
+      log.success("Simulation: would succeed.");
+      if (result.gasEstimate !== void 0) {
+        print(`  ${style.dim("Gas estimate ")} ${result.gasEstimate.toString()}`);
+      }
+    } else {
+      log.error("Simulation: would revert.");
+      print(`  ${style.dim("Reason   ")} ${result.revertReason}`);
+      if (result.decodedError) {
+        print(`  ${style.dim("Custom err")} ${result.decodedError.name}`);
+      }
+    }
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+});
+var submitCommand = new Command11("submit").description("Submit a SignedUserOp from a file or stdin to the configured bundler.").argument("[file]", 'path to a SignedUserOp JSON file (omit or pass "-" for stdin)').option("--skip-staleness-check", "bypass the EIP-191 staleness check (for typed-data signers)").option("--wait", "wait for receipt after submitting").option("--wait-timeout-ms <n>", "cap on the receipt wait (default 60000)").option("--wait-interval-ms <n>", "receipt poll interval (default 1500)").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash protocol userop submit signed.json --json
+  $ cat signed.json | kash protocol userop submit --wait
+`
+).action(async (file, options, cmd) => {
+  const globals = readGlobals(cmd);
+  const waitTimeoutMs = options.waitTimeoutMs ? parsePositiveInt(options.waitTimeoutMs, "wait-timeout-ms") : void 0;
+  const waitIntervalMs = options.waitIntervalMs ? parsePositiveInt(options.waitIntervalMs, "wait-interval-ms") : void 0;
+  try {
+    const signed = await readSignedUserOp(file);
+    const resolved = await buildDirectClient({ globals });
+    const result = await resolved.client.trades.submit(signed, {
+      skipStalenessCheck: options.skipStalenessCheck === true
+    });
+    if (options.wait !== true) {
+      if (globals.json) {
+        printJson({ userOpHash: result.userOpHash, waited: false });
+        return;
+      }
+      log.success("UserOp submitted.");
+      print(`  ${style.dim("Hash")} ${result.userOpHash}`);
+      log.info(`Use \`kash protocol userop wait ${result.userOpHash}\` to poll for inclusion.`);
+      return;
+    }
+    const waitOpts = {
+      ...waitTimeoutMs === void 0 ? {} : { timeoutMs: waitTimeoutMs },
+      ...waitIntervalMs === void 0 ? {} : { intervalMs: waitIntervalMs }
+    };
+    let receipt;
+    try {
+      receipt = await resolved.client.bundler.waitForReceipt(result.userOpHash, waitOpts);
+    } catch (waitCause) {
+      if (globals.json) {
+        printJson({ userOpHash: result.userOpHash, waited: false, partial: true });
+      } else {
+        log.warn(
+          `Submit succeeded but wait failed. UserOp is on the bundler queue \u2014 resume with: kash protocol userop wait ${result.userOpHash}`
+        );
+      }
+      throw toCliError(waitCause);
+    }
+    if (globals.json) {
+      printJson(serializeReceipt(receipt));
+      return;
+    }
+    emitReceiptHuman(receipt);
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+});
+var hashCommand = new Command11("hash").description("Recompute the canonical EIP-4337 v0.7 hash for a UnsignedUserOp.").argument("[file]", 'path to a UserOp JSON file (omit or pass "-" for stdin)').addHelpText(
+  "after",
+  `
+Examples:
+  $ kash protocol userop hash trade.json
+  $ cat trade.json | kash protocol userop hash --json --quiet | jq -r '.userOpHash'
+
+Notes:
+  - The hash baked into a freshly-built UserOp goes stale after gas
+    fields are populated. Always recompute via this command (or
+    \`hashOf\` in the SDK) before signing.
+`
+).action(async (file, _opts, cmd) => {
+  const globals = readGlobals(cmd);
+  try {
+    const userOp = await readUnsignedUserOp(file);
+    const resolved = await buildDirectClient({ globals });
+    const userOpHash = resolved.client.trades.hashOf(userOp);
+    if (globals.json) {
+      printJson({ userOpHash });
+      return;
+    }
+    print(userOpHash);
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+});
+var receiptCommand = new Command11("receipt").description("Fetch the bundler receipt for a UserOp hash (null if not yet included).").argument("<hash>", "UserOp hash (0x-prefixed, 32 bytes)").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash protocol userop receipt 0xabc...
+  $ kash protocol userop receipt 0xabc... --json --quiet | jq -r '.success'
+`
+).action(async (hash, _opts, cmd) => {
+  const globals = readGlobals(cmd);
+  if (!HEX_HASH_REGEX.test(hash)) {
+    throw new CliValidationError(
+      "<hash> must be a 0x-prefixed 32-byte hex hash.",
+      `Got "${hash}".`,
+      "hash"
+    );
+  }
+  try {
+    const resolved = await buildDirectClient({ globals });
+    const receipt = await resolved.client.bundler.getReceipt(hash);
+    if (globals.json) {
+      printJson(receipt === null ? null : serializeReceipt(receipt));
+      return;
+    }
+    if (receipt === null) {
+      log.info("Not yet included (receipt is null).");
+      return;
+    }
+    emitReceiptHuman(receipt);
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+});
+var waitCommand = new Command11("wait").description("Wait for a UserOp to be included; polls with exponential backoff.").argument("<hash>", "UserOp hash (0x-prefixed, 32 bytes)").option(
+  "--wait-timeout-ms, --timeout-ms <n>",
+  "total time budget across polls (default 60000) \u2014 distinct from the global --timeout-ms (per-HTTP-request)"
+).option("--interval-ms <n>", "poll interval (default 1500)").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash protocol userop wait 0xabc...
+  $ kash protocol userop wait 0xabc... --wait-timeout-ms 300000   # 5min budget
+`
+).action(
+  async (hash, options, cmd) => {
+    const globals = readGlobals(cmd);
+    if (!HEX_HASH_REGEX.test(hash)) {
+      throw new CliValidationError(
+        "<hash> must be a 0x-prefixed 32-byte hex hash.",
+        `Got "${hash}".`,
+        "hash"
+      );
+    }
+    const timeoutMs = options.timeoutMs ? parsePositiveInt(options.timeoutMs, "timeout-ms") : void 0;
+    const intervalMs = options.intervalMs ? parsePositiveInt(options.intervalMs, "interval-ms") : void 0;
+    try {
+      const resolved = await buildDirectClient({ globals });
+      const waitOpts = {
+        ...timeoutMs === void 0 ? {} : { timeoutMs },
+        ...intervalMs === void 0 ? {} : { intervalMs }
+      };
+      const receipt = await resolved.client.bundler.waitForReceipt(
+        hash,
+        waitOpts
+      );
+      if (globals.json) {
+        printJson(serializeReceipt(receipt));
+        return;
+      }
+      emitReceiptHuman(receipt);
+    } catch (cause) {
+      throw toCliError(cause);
+    }
+  }
+);
+var useropCommand = new Command11("userop").description("Granular UserOp lifecycle: build, simulate, submit, hash, receipt, wait.").addCommand(buildCommand).addCommand(simulateCommand).addCommand(submitCommand).addCommand(hashCommand).addCommand(receiptCommand).addCommand(waitCommand);
+async function emitBuildResult(built, side, target, outPath, json) {
+  const payload = {
+    side,
+    target,
+    userOp: serializeUserOp(built.userOp),
+    userOpHash: built.userOpHash,
+    typedData: built.typedData
+  };
+  const serialized = JSON.stringify(payload, null, 2);
+  if (outPath) {
+    try {
+      await writeFile(outPath, `${serialized}
+`, { encoding: "utf8", mode: 384 });
+    } catch (cause) {
+      throw new CliError(`Failed to write ${outPath}.`, {
+        code: "CONFIGURATION",
+        recoverable: true,
+        suggestion: "Verify the path is writable and the parent directory exists.",
+        cause
+      });
+    }
+    if (!json) {
+      log.success(`Wrote ${outPath} (mode 0600).`);
+      print(`  ${style.dim("Side  ")} ${side}`);
+      print(`  ${style.dim("Target")} ${formatAddress(target, 10, 8)}`);
+      print(`  ${style.dim("Hash  ")} ${built.userOpHash}`);
+    }
+    return;
+  }
+  if (json) {
+    printJson(payload);
+    return;
+  }
+  log.success(`Built ${side} UserOp.`);
+  log.detail("Hash", built.userOpHash);
+  print(serialized);
+}
+async function readUnsignedUserOp(file) {
+  const raw = await readSource(file);
+  const parsed = parseEnvelope(raw);
+  return deserializeUserOp(parsed.userOp);
+}
+var SIGNED_USEROP_SIG_REGEX = /^0x([0-9a-fA-F]{2})+$/;
+async function readSignedUserOp(file) {
+  const raw = await readSource(file);
+  const parsed = parseEnvelope(raw);
+  const userOp = deserializeUserOp(parsed.userOp);
+  const signature = userOp.signature;
+  if (typeof signature !== "string" || signature === "0x") {
+    throw new CliValidationError(
+      "UserOp envelope is missing a non-empty `signature` field.",
+      "Sign the userOp externally and write the resulting signature into the `userOp.signature` field."
+    );
+  }
+  if (!SIGNED_USEROP_SIG_REGEX.test(signature)) {
+    throw new CliValidationError(
+      "UserOp `signature` must be a 0x-prefixed hex string with even-length payload.",
+      `Got ${String(signature.length)} characters. Expected at least 132 (0x + 130 hex chars for a 65-byte ECDSA signature).`
+    );
+  }
+  if (signature.length < 132) {
+    throw new CliValidationError(
+      "UserOp `signature` is too short to be a valid ECDSA signature.",
+      `Got ${String(signature.length)} hex chars; canonical ECDSA signatures are 132 (0x + 130). Did the signer truncate output?`
+    );
+  }
+  return userOp;
+}
+async function readSource(file) {
+  if (file !== void 0 && file !== "-") {
+    try {
+      return await readFile(file, "utf8");
+    } catch (cause) {
+      throw new CliError(`Failed to read ${file}.`, {
+        code: "CONFIGURATION",
+        recoverable: true,
+        suggestion: "Verify the path exists and is readable.",
+        cause
+      });
+    }
+  }
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    if (typeof chunk === "string") chunks.push(Buffer.from(chunk));
+    else if (chunk instanceof Buffer) chunks.push(chunk);
+    else chunks.push(Buffer.from(chunk));
+  }
+  if (chunks.length === 0) {
+    throw new CliValidationError(
+      "No input received on stdin.",
+      "Pass a file path or pipe a UserOp JSON envelope into stdin."
+    );
+  }
+  const { stripBom } = await import("./stdin-YW2CEQXU.js");
+  return stripBom(Buffer.concat(chunks).toString("utf8"));
+}
+function parseEnvelope(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new CliValidationError(
+      "Input is not valid JSON.",
+      "Expected the JSON output of `kash protocol userop build`."
+    );
+  }
+  if (typeof parsed !== "object" || parsed === null || typeof parsed.userOp !== "object" || parsed.userOp === null) {
+    throw new CliValidationError(
+      "Input does not contain a `userOp` object.",
+      'The envelope must look like { userOp: {...}, userOpHash: "0x\u2026", typedData: {...} }.'
+    );
+  }
+  return parsed;
+}
+function deserializeUserOp(input) {
+  const BIGINT_FIELDS = /* @__PURE__ */ new Set([
+    "nonce",
+    "callGasLimit",
+    "verificationGasLimit",
+    "preVerificationGas",
+    "maxFeePerGas",
+    "maxPriorityFeePerGas",
+    "paymasterVerificationGasLimit",
+    "paymasterPostOpGasLimit"
+  ]);
+  const out = {};
+  for (const [k, v] of Object.entries(input)) {
+    if (BIGINT_FIELDS.has(k) && typeof v === "string") {
+      try {
+        out[k] = BigInt(v);
+      } catch {
+        throw new CliValidationError(
+          `UserOp field "${k}" is not a valid bigint string.`,
+          `Got ${typeof v === "string" ? `"${v}"` : String(v)}.`
+        );
+      }
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function serializeReceipt(receipt) {
+  return {
+    userOpHash: receipt.userOpHash,
+    sender: receipt.sender,
+    nonce: receipt.nonce,
+    success: receipt.success,
+    actualGasCost: receipt.actualGasCost,
+    actualGasUsed: receipt.actualGasUsed,
+    receipt: {
+      transactionHash: receipt.receipt.transactionHash,
+      blockNumber: receipt.receipt.blockNumber,
+      status: receipt.receipt.status
+    }
+  };
+}
+function emitReceiptHuman(receipt) {
+  print("");
+  if (receipt.success) {
+    log.success("UserOp included successfully.");
+  } else {
+    log.error("UserOp included but reverted on-chain.");
+  }
+  print(`  ${style.dim("UserOp ")} ${receipt.userOpHash}`);
+  print(`  ${style.dim("Tx     ")} ${receipt.receipt.transactionHash}`);
+  print(`  ${style.dim("Block  ")} ${receipt.receipt.blockNumber}`);
+  print(`  ${style.dim("Gas    ")} ${receipt.actualGasUsed}`);
+}
+function serializeSimulationResult(result) {
+  if (result.willSucceed) {
+    return {
+      willSucceed: true,
+      ...result.gasEstimate === void 0 ? {} : { gasEstimate: result.gasEstimate.toString() }
+    };
+  }
+  return {
+    willSucceed: false,
+    revertReason: result.revertReason,
+    ...result.decodedError === void 0 ? {} : {
+      decodedError: {
+        name: result.decodedError.name,
+        args: result.decodedError.args.map((a) => typeof a === "bigint" ? a.toString() : a)
+      }
+    }
+  };
+}
+
+// src/commands/protocol/watch.ts
+import { Command as Command12 } from "commander";
+var watchCommand = new Command12("watch").description("Subscribe to on-chain trade events for a market (NDJSON stream).").argument("<market>", "market contract address (0x-prefixed)").option("--max-events <n>", "exit cleanly after observing N events").option("--timeout-ms <n>", "exit cleanly after this wall-clock budget (ms)").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash protocol watch 0xMarket... --json
+  $ kash protocol watch 0xMarket... --json --quiet | jq -r '.transactionHash'
+  $ kash protocol watch 0xMarket... --max-events 100 --json
+
+Notes:
+  - Best-effort: on RPC reconnect, missed events are NOT replayed. For
+    gap-free history, use \`kash markets predictions <id>\` (indexer-backed).
+  - Press Ctrl-C to terminate cleanly. The subscription unsubscribes
+    before the process exits.
+`
+).action(async (market, options, cmd) => {
+  const globals = readGlobals(cmd);
+  const marketAddress = validateAddress(market, "market");
+  const maxEvents = options.maxEvents ? parsePositiveInt(options.maxEvents, "max-events") : void 0;
+  const timeoutMs = options.timeoutMs ? parsePositiveInt(options.timeoutMs, "timeout-ms") : void 0;
+  try {
+    const resolved = await buildDirectClient({ globals });
+    let resolveDone;
+    let count = 0;
+    const done = new Promise((resolve) => {
+      resolveDone = resolve;
+    });
+    const subscriptionHolder = { current: void 0 };
+    let teardownTriggered = false;
+    const teardown = (reason2) => {
+      if (teardownTriggered) return;
+      teardownTriggered = true;
+      try {
+        subscriptionHolder.current?.unsubscribe();
+      } catch {
+      }
+      resolveDone?.(reason2);
+    };
+    subscriptionHolder.current = resolved.client.markets.watch(marketAddress, {
+      onEvent: (event) => {
+        if (globals.json) {
+          writeNdjson(event);
+        } else {
+          print(formatEventHuman(event));
+        }
+        count += 1;
+        if (maxEvents !== void 0 && count >= maxEvents) {
+          teardown(`reached --max-events ${String(maxEvents)}`);
+        }
+      },
+      onReconnect: () => {
+        if (!globals.json) {
+          log.warn("Watcher reconnecting \u2014 missed events will NOT be replayed.");
+        }
+      },
+      onError: (err) => {
+        if (!globals.json) {
+          log.warn(`Watcher error: ${err.message}`);
+        }
+      }
+    });
+    const onSigint = () => teardown("SIGINT");
+    const onSigterm = () => teardown("SIGTERM");
+    process.on("SIGINT", onSigint);
+    process.on("SIGTERM", onSigterm);
+    const timeoutHandle = timeoutMs !== void 0 ? setTimeout(() => teardown(`reached --timeout-ms ${String(timeoutMs)}`), timeoutMs) : void 0;
+    timeoutHandle?.unref();
+    if (!globals.json) {
+      log.info(`Watching market ${marketAddress}\u2026`);
+      log.detail("Stop", "Ctrl-C");
+      if (maxEvents !== void 0) log.detail("Max events", String(maxEvents));
+      if (timeoutMs !== void 0) log.detail("Timeout (ms)", String(timeoutMs));
+    }
+    const reason = await done;
+    process.off("SIGINT", onSigint);
+    process.off("SIGTERM", onSigterm);
+    if (timeoutHandle !== void 0) clearTimeout(timeoutHandle);
+    if (!globals.json) {
+      log.info(`Watcher stopped (${reason}).`);
+    }
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+});
+function formatEventHuman(event) {
+  const time = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+  if (event.type === "TRADE") {
+    return `${style.dim(time)}  ${style.bold("TRADE")}    side=${event.side} out=${String(event.outcome)} usdc=${event.assetsUsdc.toString()} tokens=${event.tokensWad.toString()} tx=${event.transactionHash.slice(0, 10)}\u2026`;
+  }
+  if (event.type === "RESOLVED") {
+    return `${style.dim(time)}  ${style.bold("RESOLVED")} winner=${String(event.winningOutcome)} tx=${event.transactionHash.slice(0, 10)}\u2026`;
+  }
+  return `${style.dim(time)}  ${style.bold("FROZEN")}   observedAt=${event.observedAt.toString()} tx=${event.transactionHash.slice(0, 10)}\u2026`;
+}
+
+// src/commands/protocol/index.ts
+var protocolCommand = new Command13("protocol").description(
+  "Self-orchestrated direct-to-chain operations (uses @kashdao/protocol-sdk). Like the default Kash-orchestrated mode, this path is non-custodial \u2014 the difference is who builds and submits trades."
+).addCommand(balanceCommand).addCommand(marketCommand).addCommand(quoteCommand).addCommand(positionCommand).addCommand(allowanceCommand).addCommand(smartAccountCommand).addCommand(feesCommand).addCommand(tokenIdCommand).addCommand(decodeRevertCommand).addCommand(tradeCommand).addCommand(useropCommand).addCommand(watchCommand);
+export {
+  protocolCommand
+};
+//# sourceMappingURL=protocol-XEQXF2GW.js.map