@provablehq/shield-swap-cli 0.7.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Provable Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,178 @@
+# @provablehq/shield-swap-cli
+
+The `shield-swap` command: trade on Shield Swap from a terminal. Each subcommand
+does one job against a live deployment — builds a session, plans the work,
+prints what happened.
+
+This is a separate install from `@provablehq/shield-swap-sdk`, so a project that
+only needs the client never pulls the command line in. Install it, then call it by
+name:
+
+```sh
+npm install -g @provablehq/shield-swap-cli
+
+shield-swap pools
+shield-swap swap --from USDCx --to ETH --amount 1.5 --execute
+```
+
+Or keep it in the project and go through the local bin:
+
+```sh
+npm install --save-dev @provablehq/shield-swap-cli
+
+npx shield-swap setup --new
+npx shield-swap pools
+```
+
+`npx shield-swap` runs the binary that is installed. `npx @provablehq/shield-swap-cli`
+names the package instead, which sends npx to the registry: the version can change
+between two commands in the same session, and it does not work offline. Prefer the
+install.
+
+`shield-swap` on its own lists the subcommands, and every subcommand takes
+`--help` for its own flags.
+
+## Running it from the Veil repo
+
+No build step. `tsx` honours the root tsconfig's `paths`, so the SDK resolves
+straight to source and every run picks up edits immediately:
+
+```sh
+pnpm install
+pnpm shield-swap pools
+pnpm shield-swap swap --from USDCx --to ETH --amount 1.5
+```
+
+Use `pnpm -s` when parsing the output. `pnpm run` prints a two-line banner on
+stdout, which is harmless for a person and fatal for `--json`:
+
+```sh
+pnpm -s shield-swap balances --json
+```
+
+Or skip the wrapper and call it directly, which has no banner:
+
+```sh
+npx tsx packages/shield-swap-cli/src/index.ts balances --json
+```
+
+To exercise the built binary as a user would get it — the shebang, the lazy
+command loading, the `bin` wiring — build the package and run `dist`:
+
+```sh
+pnpm --filter @provablehq/shield-swap-cli build
+node packages/shield-swap-cli/dist/index.js pools
+```
+
+State lands in `./.shield-swap/<network>/` relative to the working directory, so
+running from the repo root keeps a session there. Set `SHIELD_SWAP_STATE_DIR` to
+point somewhere else — worth doing if you want a scratch account separate from
+the one you normally trade with.
+
+To drive the SDK directly while sharing the same state file the command line
+writes, import the session helpers:
+
+```ts
+import { loadSession, formatAmount } from '@provablehq/shield-swap-cli/session'
+```
+
+## Two rules that hold everywhere
+
+**Nothing spends until you pass `--execute`.** Every write command plans the
+transaction against live chain state, prints exactly what it would do, and stops.
+The dry run and the real run differ only in whether a transaction follows, so a
+first run is always safe and always worth doing.
+
+**Mainnet is never implicit.** The default network is testnet. Mainnet needs
+`--network mainnet` on every invocation (or `SHIELD_SWAP_NETWORK=mainnet` in the
+environment), because everything downstream is per-network — the DEX API host, the
+prover, the record scanner, the token registry, and the blinded identity store —
+and the mainnet ones move real value. When a plan is for mainnet, the banner above
+it says so.
+
+Amounts you type are human units (`--amount 1.5`), amounts you read are rendered
+with each token's decimals, and raw base units stay inside the SDK where they
+belong. `--json` prints one machine-readable object and silences everything else,
+so an agent or a pipeline can drive the same command a person uses.
+
+## What each command needs
+
+Every command loads the session from `./.shield-swap/<network>/state.json`, which
+means all of them need `setup` to have run once. "Funds" below means a private
+balance: private records are what pay for trades and deposits, and a public
+balance cannot be traded from. Transaction fees are paid by the delegated prover's
+FeeMaster account by default, so a faucet-funded account needs no public credits
+(set `SHIELD_SWAP_FEE_MASTER=0` when the account should pay its own).
+
+| Command | What it does | Needs |
+| --- | --- | --- |
+| `setup` | Sets up all credentials Shield Swap requires, idempotently: key material, DEX authentication, Provable API credentials, invite-code redemption, API token, testnet airdrop. | Nothing (an invite code when access is locked; a key file for a returning account) |
+| `pools` | Lists pools from the API and joins each with chain state, so the tradeable flag and the depth come from the mappings rather than the index. | Session |
+| `balances` | Private and public holdings per token, reconciled against the registry. | Session, record access |
+| `positions` | Every liquidity position the account holds, with its range, its backing amounts, and the fees earned that a collect would pay. | Session, record access |
+| `swap` | Sells one token for another, single hop or routed, then claims the output. | Funds in the token being sold |
+| `swap-concurrent` | Makes multiple swaps concurrently, one per token sold, planned before any is submitted. | Funds in each token being sold |
+| `history` | Swap history and the status of each swap, claiming what is still waiting; rebuilds a lost identity store from chain history. | Session (claiming needs the prover) |
+| `mint` | Opens a position: aligns a percentage range to the pool's tick spacing and deposits what the range consumes. | Funds on **both** sides of the pool |
+| `liquidity` | Adds to an open position, or removes liquidity and books it as owed. | A position; funds on both sides to add |
+| `collect` | Sweeps what a position is owed into records, and with `--close` burns the drained position. | A position with something owed |
+| `liquidity-e2e` | The whole lifecycle in one run — mint, increase, decrease, collect, burn — with the waits each step needs. | Funds on both sides of the pool |
+
+"Record access" means the hosted record scanner, which `setup` configures with
+the Provable API credentials it registers. Reads that touch only mappings
+(`pools`) work without it.
+
+## A suggested order
+
+1. **`shield-swap setup --new`** — once. It ends by telling you the account is
+   ready, and on testnet it draws funds and waits for the records to land.
+2. **`shield-swap balances`** — confirm what arrived. Nothing below works until
+   this shows a private balance.
+3. **`shield-swap pools`** — see what can be traded and how deep it is. Note the
+   pool keys and symbols you care about.
+4. **`shield-swap swap --from … --to … --amount …`** — no `--execute` first, then
+   with it. A swap is two transactions and this does both, so the proceeds arrive
+   in the same run.
+5. **`shield-swap history`** — after any trading session. It reads the chain
+   rather than local bookkeeping, so an entry appears exactly when a claim would
+   succeed.
+6. **`shield-swap mint --pair … --percent …`** — become the market instead of
+   trading against it. Read the plan carefully: the range, and how much of each
+   side the range actually consumes.
+7. **`shield-swap positions`** — watch what the position holds and earns.
+8. **`shield-swap liquidity --position … --increase|--decrease`** — top it up, or
+   take part of it back out. A decrease books the proceeds; it does not pay them
+   out.
+9. **`shield-swap collect`** — sweep the earnings, and `--close` to burn a
+   position you are finished with.
+
+`shield-swap liquidity-e2e` walks steps 6 through 9 in one go. It is the fastest
+way to prove a funded account works end to end against a live deployment, and the
+place to look for how the waiting between dependent transactions has to be done.
+
+## Two kinds of lag worth knowing about
+
+Both bite when one transaction is built from the result of the last one, which is
+most of the liquidity flow.
+
+Mapping writes propagate to reads asynchronously, so a read taken straight after a
+confirmed transaction can still show the previous state. Every command that needs
+its own write back polls for it.
+
+The record scanner lags further, and its failure mode is quieter. Each liquidity
+write spends the position record and issues a new one; a transaction built on the
+spent record carries a serial number the chain has already consumed, so the node
+drops it at verification. It never reaches a block, and the only symptom is a
+confirmation wait against a transaction nothing has heard of. Checking that a
+record exists is not enough — the spent one satisfies that too — so the commands
+wait for the record's tag to change.
+
+## Keeping state safe
+
+`./.shield-swap/<network>/state.json` holds the private key and the DEX
+credentials, written with mode 0600. Add `.shield-swap/` to `.gitignore` and treat
+it like a wallet file. Set `SHIELD_SWAP_STATE_DIR` to keep it somewhere else.
+
+Nothing is shared between testnet and mainnet — not the key, not the API grant,
+and above all not the blinded identity store, whose reservations are only
+meaningful against the chain they were checked on.

package/dist/balances-6SU4DCKM.js

@@ -0,0 +1,66 @@
+import {
+  done,
+  flags,
+  output,
+  run,
+  step,
+  table
+} from "./chunk-IBVZHLUT.js";
+import {
+  dim,
+  green,
+  greenBright,
+  greenDim
+} from "./chunk-IHYFMX5A.js";
+import {
+  formatAmount,
+  loadSession
+} from "./chunk-2OT6LZPW.js";
+
+// src/commands/balances.ts
+var USAGE = `shield-swap balances \u2014 private and public holdings per token
+
+  --network <testnet|mainnet>   default testnet
+  --token <symbol|id>           only this token
+  --all                         include tokens with a zero balance
+  --json                        machine-readable output`;
+async function main(argv) {
+  const args = flags({ token: { type: "string" }, all: { type: "boolean" } }, USAGE, argv);
+  await run(async () => {
+    const { client, account, network } = await loadSession({ network: args.network });
+    done(`session on ${network} for ${account.address}`);
+    const only = args.token ? await client.tokenData(args.token) : void 0;
+    step("scanning records and reading public balances");
+    const scope = only ? [only.id] : args.all ? (await client.listTokens()).map((token) => token.id) : void 0;
+    const balances = await client.getBalances(scope ? { tokens: scope } : {});
+    const rows = Object.entries(balances).map(([id, entry]) => ({ id, ...entry })).filter((row) => args.all || row.total > 0n).sort((a, b) => a.symbol.localeCompare(b.symbol));
+    output({ network, address: account.address, tokens: rows }, (data) => {
+      if (!data.tokens.length) {
+        console.log("\nNo balances. Fund the account (testnet: `shield-swap setup`) and try again.");
+        return;
+      }
+      table(
+        ["TOKEN", "PRIVATE", "PUBLIC", "TOTAL", "TOKEN ID"],
+        // Green throughout, because every figure here is money the account holds.
+        // The private side is brightest: it is the only one a swap can spend, so a
+        // reader deciding whether a trade is possible wants it to stand out from a
+        // public balance that has to be wrapped or transferred first.
+        data.tokens.map((row) => [
+          row.symbol,
+          greenBright(formatAmount(row.private, row.decimals)),
+          greenDim(formatAmount(row.public, row.decimals)),
+          green(formatAmount(row.total, row.decimals)),
+          dim(row.id)
+        ]),
+        // Left throughout: the amounts already line up on their decimal points, and
+        // ragging them against the right edge of a wide header only pushed them away
+        // from the token they belong to.
+        ["left", "left", "left", "left", "left"]
+      );
+    });
+  });
+}
+export {
+  main
+};
+//# sourceMappingURL=balances-6SU4DCKM.js.map

package/dist/balances-6SU4DCKM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/balances.ts"],"sourcesContent":["/**\n * Balances — what the account holds, private and public, per token.\n *\n * The private side is what funds trades: swaps and mints spend private records,\n * and a freshly funded account shows zero public balance because the faucet\n * delivers records. Both sides come from `getBalances`, which reconciles the\n * token registry against the record scanner and the API.\n *\n * Reads only. Spends nothing.\n *\n * Usage:\n *   shield-swap balances                     # testnet\n *   shield-swap balances --network mainnet\n *   shield-swap balances --token USDCx       # one token\n *   shield-swap balances --all               # include zero balances\n *   shield-swap balances --json\n */\nimport { loadSession, formatAmount } from '../session.js'\nimport { flags, step, done, output, run, table } from '../shared.js'\nimport { dim, green, greenBright, greenDim } from '../color.js'\n\nconst USAGE = `shield-swap balances — private and public holdings per token\n\n  --network <testnet|mainnet>   default testnet\n  --token <symbol|id>           only this token\n  --all                         include tokens with a zero balance\n  --json                        machine-readable output`\n\n/**\n * Runs the `balances` subcommand.\n *\n * @param argv Arguments after the subcommand name, as the dispatcher supplies them.\n */\nexport async function main(argv: string[]): Promise<void> {\n  const args = flags({ token: { type: 'string' }, all: { type: 'boolean' } }, USAGE, argv)\n\n  await run(async () => {\n    const { client, account, network } = await loadSession({ network: args.network as string | undefined })\n    done(`session on ${network} for ${account.address}`)\n\n    const only = args.token ? await client.tokenData(args.token as string) : undefined\n    step('scanning records and reading public balances')\n    // getBalances returns only what the account holds unless asked for specific\n    // tokens, so `--all` has to name the whole registry — filtering a map that\n    // never contained the zero rows would drop them silently.\n    const scope = only\n      ? [only.id]\n      : args.all\n        ? (await client.listTokens()).map((token) => token.id)\n        : undefined\n    const balances = await client.getBalances(scope ? { tokens: scope } : {})\n\n    const rows = Object.entries(balances)\n      .map(([id, entry]) => ({ id, ...entry }))\n      .filter((row) => args.all || row.total > 0n)\n      .sort((a, b) => a.symbol.localeCompare(b.symbol))\n\n    output({ network, address: account.address, tokens: rows }, (data) => {\n      if (!data.tokens.length) {\n        console.log('\\nNo balances. Fund the account (testnet: `shield-swap setup`) and try again.')\n        return\n      }\n      // Printed as formatted, with no padding of their own. Aligning on the decimal\n      // point instead would pad each integer part out to the widest one, and in a\n      // left-aligned column that pad becomes a visible indent — the points would\n      // line up while the numbers started at three different places.\n      table(\n        ['TOKEN', 'PRIVATE', 'PUBLIC', 'TOTAL', 'TOKEN ID'],\n        // Green throughout, because every figure here is money the account holds.\n        // The private side is brightest: it is the only one a swap can spend, so a\n        // reader deciding whether a trade is possible wants it to stand out from a\n        // public balance that has to be wrapped or transferred first.\n        data.tokens.map((row) => [\n          row.symbol,\n          greenBright(formatAmount(row.private, row.decimals)),\n          greenDim(formatAmount(row.public, row.decimals)),\n          green(formatAmount(row.total, row.decimals)),\n          dim(row.id),\n        ]),\n        // Left throughout: the amounts already line up on their decimal points, and\n        // ragging them against the right edge of a wide header only pushed them away\n        // from the token they belong to.\n        ['left', 'left', 'left', 'left', 'left'],\n      )\n    })\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAqBA,IAAM,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAYd,eAAsB,KAAK,MAA+B;AACxD,QAAM,OAAO,MAAM,EAAE,OAAO,EAAE,MAAM,SAAS,GAAG,KAAK,EAAE,MAAM,UAAU,EAAE,GAAG,OAAO,IAAI;AAEvF,QAAM,IAAI,YAAY;AACpB,UAAM,EAAE,QAAQ,SAAS,QAAQ,IAAI,MAAM,YAAY,EAAE,SAAS,KAAK,QAA8B,CAAC;AACtG,SAAK,cAAc,OAAO,QAAQ,QAAQ,OAAO,EAAE;AAEnD,UAAM,OAAO,KAAK,QAAQ,MAAM,OAAO,UAAU,KAAK,KAAe,IAAI;AACzE,SAAK,8CAA8C;AAInD,UAAM,QAAQ,OACV,CAAC,KAAK,EAAE,IACR,KAAK,OACF,MAAM,OAAO,WAAW,GAAG,IAAI,CAAC,UAAU,MAAM,EAAE,IACnD;AACN,UAAM,WAAW,MAAM,OAAO,YAAY,QAAQ,EAAE,QAAQ,MAAM,IAAI,CAAC,CAAC;AAExE,UAAM,OAAO,OAAO,QAAQ,QAAQ,EACjC,IAAI,CAAC,CAAC,IAAI,KAAK,OAAO,EAAE,IAAI,GAAG,MAAM,EAAE,EACvC,OAAO,CAAC,QAAQ,KAAK,OAAO,IAAI,QAAQ,EAAE,EAC1C,KAAK,CAAC,GAAG,MAAM,EAAE,OAAO,cAAc,EAAE,MAAM,CAAC;AAElD,WAAO,EAAE,SAAS,SAAS,QAAQ,SAAS,QAAQ,KAAK,GAAG,CAAC,SAAS;AACpE,UAAI,CAAC,KAAK,OAAO,QAAQ;AACvB,gBAAQ,IAAI,+EAA+E;AAC3F;AAAA,MACF;AAKA;AAAA,QACE,CAAC,SAAS,WAAW,UAAU,SAAS,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA,QAKlD,KAAK,OAAO,IAAI,CAAC,QAAQ;AAAA,UACvB,IAAI;AAAA,UACJ,YAAY,aAAa,IAAI,SAAS,IAAI,QAAQ,CAAC;AAAA,UACnD,SAAS,aAAa,IAAI,QAAQ,IAAI,QAAQ,CAAC;AAAA,UAC/C,MAAM,aAAa,IAAI,OAAO,IAAI,QAAQ,CAAC;AAAA,UAC3C,IAAI,IAAI,EAAE;AAAA,QACZ,CAAC;AAAA;AAAA;AAAA;AAAA,QAID,CAAC,QAAQ,QAAQ,QAAQ,QAAQ,MAAM;AAAA,MACzC;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AACH;","names":[]}

package/dist/chunk-2OT6LZPW.js

@@ -0,0 +1,178 @@
+// src/session.ts
+import { mkdirSync, readFileSync, writeFileSync, existsSync, chmodSync, renameSync } from "fs";
+import { join } from "path";
+import {
+  loadNetwork,
+  generateAccount
+} from "@provablehq/veil-aleo-sdk";
+import { fileCredentialStore } from "@provablehq/veil-aleo-sdk/node";
+import { shieldSwapActions, parseUnits } from "@provablehq/shield-swap-sdk";
+import { fileBlindedIdentityStore } from "@provablehq/shield-swap-sdk/node";
+function resolveNetwork(explicit) {
+  const value = explicit ?? process.env.SHIELD_SWAP_NETWORK ?? "testnet";
+  if (value !== "testnet" && value !== "mainnet") {
+    throw new Error(`Unknown network "${value}" \u2014 use testnet or mainnet.`);
+  }
+  return value;
+}
+var NETWORK_URL = "https://api.provable.com/v2";
+var STATE_ROOT = process.env.SHIELD_SWAP_STATE_DIR ?? join(process.cwd(), ".shield-swap");
+function stateDir(network) {
+  return join(STATE_ROOT, network);
+}
+function blindedStorePath(network) {
+  return join(stateDir(network), "blinded.json");
+}
+function credentialsPath(network) {
+  return join(stateDir(network), "provable-credentials.json");
+}
+function statePath(network) {
+  return join(stateDir(network), "state.json");
+}
+var LEGACY_STATE_PATH = join(STATE_ROOT, "state.json");
+function loadState(network) {
+  const path = existsSync(statePath(network)) ? statePath(network) : network === "testnet" && existsSync(LEGACY_STATE_PATH) ? LEGACY_STATE_PATH : void 0;
+  if (!path) return { network };
+  const parsed = JSON.parse(readFileSync(path, "utf8"));
+  parsed.network = network;
+  return parsed;
+}
+function saveState(state) {
+  const network = resolveNetwork(state.network);
+  mkdirSync(stateDir(network), { recursive: true });
+  const target = statePath(network);
+  const tmp = `${target}.tmp`;
+  writeFileSync(tmp, JSON.stringify(state, null, 2));
+  chmodSync(tmp, 384);
+  renameSync(tmp, target);
+}
+function formatAmount(amount, decimals, symbol) {
+  const scale = 10n ** BigInt(decimals);
+  const whole = amount / scale;
+  const frac = amount % scale;
+  let s = whole.toLocaleString("en-US");
+  if (frac > 0n) {
+    const fracStr = frac.toString().padStart(decimals, "0").replace(/0+$/, "");
+    if (fracStr) s += `.${fracStr}`;
+  }
+  return symbol ? `${s} ${symbol}` : s;
+}
+function namedAmounts(params) {
+  const [token0, token1] = params.tokens;
+  const amounts = [
+    params.indexed[0] ? parseUnits(params.indexed[0], token0.decimals) : void 0,
+    params.indexed[1] ? parseUnits(params.indexed[1], token1.decimals) : void 0
+  ];
+  const namedBy = [params.indexed[0] ? "--amount0" : void 0, params.indexed[1] ? "--amount1" : void 0];
+  for (const entry of params.entries) {
+    const parts = entry.split(":");
+    if (parts.length !== 2 || !parts[0] || !parts[1]) {
+      throw new Error(`--amount takes <symbol>:<amount>, e.g. --amount ${token0.symbol}:0.5 \u2014 got "${entry}"`);
+    }
+    const [name, value] = parts;
+    const wanted = name.trim();
+    const side = [token0, token1].findIndex(
+      (token2) => token2.symbol.toLowerCase() === wanted.toLowerCase() || token2.id === wanted
+    );
+    if (side === -1) {
+      throw new Error(`"${wanted}" is not in this pool's pair \u2014 it holds ${token0.symbol} and ${token1.symbol}.`);
+    }
+    const token = side === 0 ? token0 : token1;
+    if (amounts[side] !== void 0) {
+      throw new Error(`${token.symbol} is named twice, by ${namedBy[side]} and --amount ${entry}.`);
+    }
+    amounts[side] = parseUnits(value.trim(), token.decimals);
+    namedBy[side] = `--amount ${entry}`;
+  }
+  return { amount0: amounts[0], amount1: amounts[1] };
+}
+async function loadSession(options = {}) {
+  const network = resolveNetwork(options.network);
+  const state = loadState(network);
+  if (!state.privateKey) {
+    throw new Error(
+      `No shield-swap session found for ${network} \u2014 run \`shield-swap setup --network ${network}\` first (see startup.md).`
+    );
+  }
+  const aleo = await loadNetwork(network);
+  const scanner = aleo.createRemoteScanner();
+  const { walletClient, account } = aleo.createAleoClient({
+    privateKey: state.privateKey,
+    networkUrl: NETWORK_URL,
+    provingMode: "delegated",
+    credentialStore: fileCredentialStore(credentialsPath(network)),
+    // Faucet-funded accounts hold no public credits; the delegated prover
+    // pays fees from its FeeMaster account. Opt out with
+    // SHIELD_SWAP_FEE_MASTER=0 when the account funds its own fees.
+    useFeeMaster: process.env.SHIELD_SWAP_FEE_MASTER !== "0",
+    records: scanner
+  });
+  const apiUrl = process.env.SHIELD_SWAP_API_URL ?? state.apiUrl;
+  const blindedIdentities = fileBlindedIdentityStore(blindedStorePath(network));
+  const client = walletClient.extend(
+    shieldSwapActions({ api: { baseUrl: apiUrl }, blindedIdentities })
+  );
+  try {
+    await client.authenticateShieldSwap();
+  } catch (error) {
+    if (!apiUrl) throw error;
+    const source = process.env.SHIELD_SWAP_API_URL === apiUrl ? "SHIELD_SWAP_API_URL" : `apiUrl in ${statePath(network)}`;
+    throw new Error(
+      `could not authenticate with the DEX API at ${apiUrl}, which is pinned by ${source} rather than derived from the network. If that deployment is gone, re-pin with \`shield-swap setup --api-url <origin>\` or clear the field to fall back to the default for ${network}.`,
+      { cause: error }
+    );
+  }
+  return { client, account, scanner, state, aleo, network, blindedIdentities };
+}
+async function pollUntil(fn, attempts, intervalMs) {
+  for (let i = 0; i < attempts; i++) {
+    if (await fn()) return true;
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  return false;
+}
+async function ensureKeyMaterial(state, options = {}) {
+  const network = resolveNetwork(state.network);
+  await loadNetwork(network);
+  if (state.privateKey && options.importKey && options.importKey !== state.privateKey) {
+    throw new Error(
+      `a DIFFERENT account is already configured here (${state.address ?? "address unknown"}). Refusing to switch silently \u2014 its funds and access live on that key. To use the imported key instead, move or delete the state directory first, then re-run with --private-key-file.`
+    );
+  }
+  if (!state.privateKey) {
+    if (options.importKey) {
+      state.privateKey = options.importKey;
+    } else if (options.allowGenerate) {
+      state.privateKey = generateAccount().privateKey;
+    } else {
+      throw new NeedsConfigDecisionError();
+    }
+  }
+  const aleo = await loadNetwork(network);
+  state.address = aleo.privateKeyToAccount(state.privateKey).address;
+  saveState(state);
+  return state;
+}
+var NeedsConfigDecisionError = class extends Error {
+  constructor() {
+    super("no key material found and none provided");
+    this.name = "NeedsConfigDecisionError";
+  }
+};
+
+export {
+  resolveNetwork,
+  NETWORK_URL,
+  stateDir,
+  blindedStorePath,
+  credentialsPath,
+  loadState,
+  saveState,
+  formatAmount,
+  namedAmounts,
+  loadSession,
+  pollUntil,
+  ensureKeyMaterial,
+  NeedsConfigDecisionError
+};
+//# sourceMappingURL=chunk-2OT6LZPW.js.map

package/dist/chunk-2OT6LZPW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/session.ts"],"sourcesContent":["/**\n * Shared session plumbing for the `shield-swap` command.\n *\n * Owns the state file (`./.shield-swap/<network>/state.json` by default) and\n * the client wiring, so every command starts from `loadSession()` and gets a\n * fully authenticated client plus persistent storage for the one thing that\n * must survive a crash and cannot be rediscovered: the private key, plus the\n * DEX grants tied to it.\n *\n * Exported as `@provablehq/shield-swap-cli/session` so a script driving the SDK\n * directly can share the same state file the command line writes.\n *\n * Nothing else is stored. Swap handles belong to the SDK's blinded identity\n * store, and positions are discovered from records with\n * `client.getOwnedPositions()` — a local list of either could only ever be a\n * stale copy of what the chain already knows.\n *\n * Everything is scoped by network. Nothing is shared between testnet and\n * mainnet: not the key, not the API grant, and above all not the identity\n * store, whose reservations are only meaningful against one chain.\n *\n * The state file holds a private key and API credentials — keep it out of\n * version control (`.shield-swap/` belongs in .gitignore) and treat it like\n * a wallet file.\n */\nimport { mkdirSync, readFileSync, writeFileSync, existsSync, chmodSync, renameSync } from 'node:fs'\nimport { join } from 'node:path'\nimport {\n  loadNetwork,\n  generateAccount,\n} from '@provablehq/veil-aleo-sdk'\nimport { fileCredentialStore } from '@provablehq/veil-aleo-sdk/node'\nimport { shieldSwapActions, getPrivateBalances, parseUnits, DEFAULT_PROGRAM } from '@provablehq/shield-swap-sdk'\nimport { fileBlindedIdentityStore } from '@provablehq/shield-swap-sdk/node'\n\n/** The networks these scripts run against. */\nexport type Network = 'testnet' | 'mainnet'\n\n/**\n * Resolves the network from an explicit choice, the environment, or the default.\n *\n * Testnet is the default and mainnet is never reached by omission: a script has\n * to be told, because everything downstream — the DEX API host, the prover, the\n * scanner, the token registry, and the identity store — is per-network, and the\n * mainnet ones move real value.\n *\n * @param explicit A `--network` value, when a script parsed one.\n * @throws When the value is neither network, rather than silently using testnet.\n */\nexport function resolveNetwork(explicit?: string): Network {\n  const value = explicit ?? process.env.SHIELD_SWAP_NETWORK ?? 'testnet'\n  if (value !== 'testnet' && value !== 'mainnet') {\n    throw new Error(`Unknown network \"${value}\" — use testnet or mainnet.`)\n  }\n  return value\n}\n\nexport const NETWORK_URL = 'https://api.provable.com/v2'\n\n/** Everything that must survive between agent sessions. */\nexport type ShieldSwapState = {\n  network: string\n  /**\n   * DEX API origin this session targets. Unset means the SDK's default\n   * hosted deployment. Set by `shield-swap setup` (`--api-url` / SHIELD_SWAP_API_URL);\n   * the access grant, API token, and airdrop job are scoped to one\n   * deployment, so setup clears them when this changes.\n   */\n  apiUrl?: string\n  privateKey?: string\n  address?: string\n  dexApiToken?: string\n  accessRedeemed?: boolean\n  /** Faucet job already requested for this account — prevents double-drawing on re-runs. */\n  airdropJobId?: string\n}\n\nconst STATE_ROOT = process.env.SHIELD_SWAP_STATE_DIR ?? join(process.cwd(), '.shield-swap')\n\n/** Per-network state directory. Nothing is shared between networks. */\nexport function stateDir(network: Network): string {\n  return join(STATE_ROOT, network)\n}\n\n/**\n * Where the blinded identity store lives for a network.\n *\n * Scoped by network because a reservation is only meaningful against the chain\n * it was checked on: counters reserved against testnet's\n * `used_blinded_addresses` say nothing about mainnet's, and one shared file\n * would hand out identities the other chain has already consumed.\n */\nexport function blindedStorePath(network: Network): string {\n  return join(stateDir(network), 'blinded.json')\n}\n\n/**\n * Where Provable API credentials live for a network.\n *\n * Separate from the state file because the SDK owns the format: `shield-swap setup`\n * hands `fileCredentialStore` this path and the client reads and writes it\n * directly, including registering a consumer when the file is absent.\n */\nexport function credentialsPath(network: Network): string {\n  return join(stateDir(network), 'provable-credentials.json')\n}\n\nfunction statePath(network: Network): string {\n  return join(stateDir(network), 'state.json')\n}\n\n/** The pre-network layout, still read for testnet so existing keys survive. */\nconst LEGACY_STATE_PATH = join(STATE_ROOT, 'state.json')\n\n/**\n * Reads a network's state file, or returns a fresh empty state.\n *\n * Falls back to the pre-network layout for testnet only, so an existing\n * `.shield-swap/state.json` keeps working; the next save writes it to the\n * network-scoped path.\n */\nexport function loadState(network: Network): ShieldSwapState {\n  const path = existsSync(statePath(network))\n    ? statePath(network)\n    : network === 'testnet' && existsSync(LEGACY_STATE_PATH)\n      ? LEGACY_STATE_PATH\n      : undefined\n  if (!path) return { network }\n  const parsed = JSON.parse(readFileSync(path, 'utf8')) as ShieldSwapState\n  // A state file that names a different network is a wrong-chain hazard: its\n  // key is fine but its access grant, API token, and airdrop job are not.\n  parsed.network = network\n  return parsed\n}\n\n/**\n * Writes the state file atomically (temp file + rename, 0600 — it holds the\n * private key). A crash mid-write can never truncate the only copy of the\n * key and the open swap handles.\n */\nexport function saveState(state: ShieldSwapState): void {\n  const network = resolveNetwork(state.network)\n  mkdirSync(stateDir(network), { recursive: true })\n  const target = statePath(network)\n  const tmp = `${target}.tmp`\n  writeFileSync(tmp, JSON.stringify(state, null, 2))\n  chmodSync(tmp, 0o600)\n  renameSync(tmp, target)\n}\n\n\n/**\n * Renders a raw base-unit amount in human units (\"0.0534 ETH\"), the ONLY\n * format that should ever reach the user. Raw units (wei-style integers)\n * are SDK-facing; showing them to a person misstates their balances by\n * orders of magnitude.\n */\nexport function formatAmount(amount: bigint, decimals: number, symbol?: string): string {\n  const scale = 10n ** BigInt(decimals)\n  const whole = amount / scale\n  const frac = amount % scale\n  let s = whole.toLocaleString('en-US')\n  if (frac > 0n) {\n    // Full precision minus trailing zeros — tiny testnet amounts live many\n    // places below the decimal point and must not round away to nothing.\n    const fracStr = frac.toString().padStart(decimals, '0').replace(/0+$/, '')\n    if (fracStr) s += `.${fracStr}`\n  }\n  return symbol ? `${s} ${symbol}` : s\n}\n\n/** What {@link namedAmounts} needs of a pool's token to place an amount. */\nexport type AmountToken = { id: string; symbol: string; decimals: number }\n\n/**\n * Places caller-named amounts into a pool's own token order.\n *\n * A pool orders its tokens by id, not by anything a caller types, so `--amount0`\n * is unknowable without reading the pool first: naming a pair `USDCx:ETH` does\n * not make USDCx side 0. `--amount USDCx:0.5` names the token instead and is\n * matched here, while `--amount0`/`--amount1` stay available for callers who know\n * the order. Parsing is the inverse of {@link formatAmount}: human decimals in,\n * raw base units out. Pure and local.\n *\n * @param params.entries `--amount` values, each `<symbol|id>:<decimal>`.\n * @param params.indexed The raw `--amount0` and `--amount1` strings, in that\n *   order, `undefined` where the flag was absent.\n * @param params.tokens The pool's tokens in ITS order — `[token0, token1]`.\n * @returns Raw base units per side, `undefined` where nothing named that side.\n * @throws When an entry is malformed, names a token outside the pair, or names a\n *   side twice — including once by symbol and once by index, where preferring\n *   either would commit an amount the caller did not ask for.\n *\n * @example\n * const { amount0, amount1 } = namedAmounts({\n *   entries: ['USDCx:0.5'],\n *   indexed: [undefined, undefined],\n *   tokens: [token0, token1],\n * })\n */\nexport function namedAmounts(params: {\n  entries: string[]\n  indexed: readonly [string | undefined, string | undefined]\n  tokens: readonly [AmountToken, AmountToken]\n}): { amount0: bigint | undefined; amount1: bigint | undefined } {\n  const [token0, token1] = params.tokens\n  const amounts: Array<bigint | undefined> = [\n    params.indexed[0] ? parseUnits(params.indexed[0], token0.decimals) : undefined,\n    params.indexed[1] ? parseUnits(params.indexed[1], token1.decimals) : undefined,\n  ]\n  // Tracked alongside so a collision can name both flags rather than just the token.\n  const namedBy = [params.indexed[0] ? '--amount0' : undefined, params.indexed[1] ? '--amount1' : undefined]\n\n  for (const entry of params.entries) {\n    const parts = entry.split(':')\n    if (parts.length !== 2 || !parts[0] || !parts[1]) {\n      throw new Error(`--amount takes <symbol>:<amount>, e.g. --amount ${token0.symbol}:0.5 — got \"${entry}\"`)\n    }\n    const [name, value] = parts as [string, string]\n    const wanted = name.trim()\n    const side = [token0, token1].findIndex(\n      (token) => token.symbol.toLowerCase() === wanted.toLowerCase() || token.id === wanted,\n    )\n    if (side === -1) {\n      throw new Error(`\"${wanted}\" is not in this pool's pair — it holds ${token0.symbol} and ${token1.symbol}.`)\n    }\n    const token = side === 0 ? token0 : token1\n    if (amounts[side] !== undefined) {\n      throw new Error(`${token.symbol} is named twice, by ${namedBy[side]} and --amount ${entry}.`)\n    }\n    amounts[side] = parseUnits(value.trim(), token.decimals)\n    namedBy[side] = `--amount ${entry}`\n  }\n  return { amount0: amounts[0], amount1: amounts[1] }\n}\n\n/**\n * Builds the fully wired, authenticated session from the state file.\n *\n * Requires `shield-swap setup` to have run (key material in the state file).\n * Authenticates with the DEX API on every call — the session JWT covers\n * everything including access/token management, and auto-renews on expiry.\n *\n * Provable API credentials are not required up front: the client registers a\n * consumer through the credential file on first prove or scan when it holds\n * none — though `shield-swap setup` registers and verifies eagerly, so a session built\n * after setup has working credentials rather than untested ones.\n */\nexport async function loadSession(options: { network?: string } = {}) {\n  const network = resolveNetwork(options.network)\n  const state = loadState(network)\n  if (!state.privateKey) {\n    throw new Error(\n      `No shield-swap session found for ${network} — run \\`shield-swap setup --network ${network}\\` first (see startup.md).`,\n    )\n  }\n\n  const aleo = await loadNetwork(network)\n  // Credentials reach both the prover and the scanner through one session the\n  // client builds from the store, so a single JWT serves both.\n  // No prover or scanner URL: both default to the Provable API and take the\n  // network from the client, so naming them here would only risk drift.\n  const scanner = aleo.createRemoteScanner()\n  const { walletClient, account } = aleo.createAleoClient({\n    privateKey: state.privateKey,\n    networkUrl: NETWORK_URL,\n    provingMode: 'delegated',\n    credentialStore: fileCredentialStore(credentialsPath(network)),\n    // Faucet-funded accounts hold no public credits; the delegated prover\n    // pays fees from its FeeMaster account. Opt out with\n    // SHIELD_SWAP_FEE_MASTER=0 when the account funds its own fees.\n    useFeeMaster: process.env.SHIELD_SWAP_FEE_MASTER !== '0',\n    records: scanner,\n  })\n  // SHIELD_SWAP_API_URL overrides for one-off runs; the persistent choice\n  // lives in the state file (`shield-swap setup --api-url`).\n  const apiUrl = process.env.SHIELD_SWAP_API_URL ?? state.apiUrl\n  // The identity store is what makes concurrent swaps safe and unclaimed swaps\n  // recoverable, and it is scoped by network because a reservation is only\n  // meaningful against the chain it was checked on. Every swap through this\n  // client reserves and records automatically.\n  const blindedIdentities = fileBlindedIdentityStore(blindedStorePath(network))\n  const client = walletClient.extend(\n    shieldSwapActions({ api: { baseUrl: apiUrl }, blindedIdentities }),\n  )\n  try {\n    await client.authenticateShieldSwap()\n  } catch (error) {\n    // A pinned host is invisible state: it lives in a file nobody re-reads, so\n    // when the deployment behind it is retired every call fails with a bare 404\n    // and nothing points at the pin. Name it, and say how to drop it.\n    if (!apiUrl) throw error\n    const source =\n      process.env.SHIELD_SWAP_API_URL === apiUrl ? 'SHIELD_SWAP_API_URL' : `apiUrl in ${statePath(network)}`\n    throw new Error(\n      `could not authenticate with the DEX API at ${apiUrl}, which is pinned by ${source} rather than ` +\n        `derived from the network. If that deployment is gone, re-pin with \\`shield-swap setup --api-url ` +\n        `<origin>\\` or clear the field to fall back to the default for ${network}.`,\n      { cause: error },\n    )\n  }\n\n  return { client, account, scanner, state, aleo, network, blindedIdentities }\n}\n\n\n\n/** Polls a predicate until it returns true or attempts run out. */\nexport async function pollUntil(fn: () => Promise<boolean>, attempts: number, intervalMs: number): Promise<boolean> {\n  for (let i = 0; i < attempts; i++) {\n    if (await fn()) return true\n    await new Promise((r) => setTimeout(r, intervalMs))\n  }\n  return false\n}\n\n/**\n * Resolves key material and stores it. Priority: existing state → imported\n * key (`importKey`) → fresh generation, but only when `allowGenerate` is\n * true. Returning users keep their account; a fresh key is never created\n * silently.\n */\nexport async function ensureKeyMaterial(\n  state: ShieldSwapState,\n  options: { importKey?: string; allowGenerate?: boolean } = {},\n): Promise<ShieldSwapState> {\n  const network = resolveNetwork(state.network)\n  await loadNetwork(network) // initializes the WASM the account helpers use\n  if (state.privateKey && options.importKey && options.importKey !== state.privateKey) {\n    throw new Error(\n      `a DIFFERENT account is already configured here (${state.address ?? 'address unknown'}). ` +\n        'Refusing to switch silently — its funds and access live on that key. To use the imported ' +\n        `key instead, move or delete the state directory first, then re-run with --private-key-file.`,\n    )\n  }\n  if (!state.privateKey) {\n    if (options.importKey) {\n      state.privateKey = options.importKey\n    } else if (options.allowGenerate) {\n      state.privateKey = generateAccount().privateKey\n    } else {\n      throw new NeedsConfigDecisionError()\n    }\n  }\n  // Derive the address from the key so imported/seeded states are complete.\n  const aleo = await loadNetwork(network)\n  state.address = aleo.privateKeyToAccount(state.privateKey).address\n  saveState(state)\n  return state\n}\n\n/** Signals that setup must ask the user about existing config before creating anything. */\nexport class NeedsConfigDecisionError extends Error {\n  constructor() {\n    super('no key material found and none provided')\n    this.name = 'NeedsConfigDecisionError'\n  }\n}\n\n\n"],"mappings":"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","names":["token"]}

package/dist/chunk-IBVZHLUT.js

@@ -0,0 +1,152 @@
+import {
+  alarm,
+  bold,
+  dim,
+  green,
+  help,
+  red,
+  yellow
+} from "./chunk-IHYFMX5A.js";
+
+// src/shared.ts
+import { parseArgs } from "util";
+var COMMON = {
+  network: { type: "string" },
+  execute: { type: "boolean" },
+  json: { type: "boolean" },
+  // `-h` is declared here rather than only on the dispatcher: `parseArgs` rejects
+  // undeclared short options, so `shield-swap pools -h` failed with a usage error
+  // while `shield-swap -h` printed the help. The two must not disagree.
+  help: { type: "boolean", short: "h" },
+  "no-color": { type: "boolean" }
+};
+function flags(spec, usage, argv) {
+  let values;
+  try {
+    ;
+    ({ values } = parseArgs({
+      options: { ...COMMON, ...spec },
+      args: argv,
+      allowPositionals: false
+    }));
+  } catch (error) {
+    reportUsage(error.message, usage, argv);
+  }
+  if (values.help) {
+    console.log(help(usage));
+    process.exit(0);
+  }
+  return values;
+}
+function basisPoints(value, flag) {
+  if (value === void 0) return void 0;
+  const bps = Number(value);
+  if (!Number.isInteger(bps) || bps < 0 || bps > 1e4) {
+    fail(`${flag} takes a whole number of basis points between 0 and 10000, got "${value}". 50 is 0.5%.`);
+  }
+  return bps;
+}
+function reportUsage(message, usage, argv) {
+  if (argv.includes("--json")) {
+    console.log(JSON.stringify({ error: { message, usage } }, null, 2));
+  } else {
+    console.error(`${red(message, "stderr")}
+
+${help(usage)}`);
+  }
+  process.exit(64);
+}
+var quiet = false;
+function setJsonMode(on) {
+  quiet = on;
+}
+function step(message) {
+  if (!quiet) console.log(dim(`\xB7 ${message}`));
+}
+function done(message) {
+  if (!quiet) console.log(`${green("\u2713")} ${message}`);
+}
+function warn(message) {
+  if (!quiet) console.warn(yellow(`! ${message}`, "stderr"));
+}
+function visibleWidth(text) {
+  return text.replace(/\u001B\[[0-9;]*m/g, "").length;
+}
+function output(data, human) {
+  if (quiet) {
+    console.log(JSON.stringify(data, (_key, value) => typeof value === "bigint" ? value.toString() : value, 2));
+    return;
+  }
+  human(data);
+}
+function table(headers, rows, align) {
+  const cells = rows.map((row) => headers.map((_, i) => row[i] ?? ""));
+  const widths = headers.map((header, i) => Math.max(header.length, ...cells.map((row) => visibleWidth(row[i]))));
+  const side = (i) => align?.[i] ?? (i === 0 ? "left" : "right");
+  const pad = (cell, i) => {
+    const fill = " ".repeat(Math.max(0, widths[i] - visibleWidth(cell)));
+    return side(i) === "left" ? cell + fill : fill + cell;
+  };
+  const line = (row) => `  ${row.map(pad).join("   ")}`.trimEnd();
+  console.log("");
+  console.log(bold(line(headers)));
+  console.log(dim(`  ${widths.map((w) => "\u2500".repeat(w)).join("   ")}`));
+  for (const row of cells) console.log(line(row));
+}
+function confirmed(options) {
+  const banner = options.network === "mainnet" ? alarm("MAINNET \u2014 real funds") : dim(options.network);
+  if (!quiet) {
+    table(
+      ["PLAN", banner],
+      options.plan.map(([label, value]) => [label, value]),
+      ["left", "left"]
+    );
+  }
+  if (options.execute) return true;
+  if (!quiet) console.log(dim("\nnothing submitted. re-run with --execute to send it.\n"));
+  return false;
+}
+async function run(main) {
+  try {
+    await main();
+  } catch (error) {
+    const err = error;
+    reportError(err.message, err.cause);
+    process.exitCode = 1;
+  }
+}
+function reportError(message, cause) {
+  if (quiet) {
+    console.log(
+      JSON.stringify(
+        { error: { message, ...cause instanceof Error ? { cause: cause.message } : {} } },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  console.error(`
+${red("\u2717", "stderr")} ${message}`);
+  if (cause instanceof Error) console.error(dim(`  caused by: ${cause.message}`));
+}
+function fail(message, cause) {
+  reportError(message, cause);
+  process.exit(1);
+}
+
+export {
+  flags,
+  basisPoints,
+  reportUsage,
+  setJsonMode,
+  step,
+  done,
+  warn,
+  output,
+  table,
+  confirmed,
+  run,
+  fail
+};
+//# sourceMappingURL=chunk-IBVZHLUT.js.map