@logswap/sdk 0.5.55 → 0.5.56

package/dist/fpool.js

@@ -4,7 +4,7 @@
  * The other primitive. `CPoolManager` gives every position its own floor on a tick ladder;
  * `FPoolManager` gives every share the SAME floor and deletes the ladder, the accumulators and the
  * per-position accounting with it. Reading the two side by side is the fastest way to understand
- * either (logswap-docs:docs/multi/f-pool.md).
+ * either.
  *
  * **A pool is an ID, not an address.** Both primitives are singletons now, so neither has a
  * per-pool deployment — but they are addressed differently and for a reason. The C manager rides
@@ -15,7 +15,7 @@
  * **Two products, one contract.** The basket (n > 1) and the launch (n = 1, the creator alone on
  * the lever) are the same bytecode under two key fields — the KIND (what the manager promises
  * structurally) and the POLICY (the pool's policy: its roles, its gates, the terms of every harvest
- * and release; decisions 041, 044) — and nothing in the maths. `describeFPool` below reports
+ * and release) — and nothing in the maths. `describeFPool` below reports
  * which shape a given pool is, because a UI has to decide what to render.
  *
  * **The roles are the policy's, not the manager's** (F version 15). The manager holds no
@@ -32,9 +32,9 @@
 import { encodeFunctionData, toFunctionSelector } from "viem";
 import { fPoolManagerAbi, logswapRouterAbi, padPolicyAbi, polPolicyAbi, policyRegistryAbi, privatePolicyAbi, publicPolicyAbi } from "./generated.js";
 /**
- * One contract, one ABI (decisions 039, F version 12): `harvest`, `claim`, `retire`, `regenerate`,
+ * One contract, one ABI (F version 12): `harvest`, `claim`, `retire`, `regenerate`,
  * `setLegs`, the names, the fee parameters are `FPoolManager`'s own code. The roles left it for
- * the policies in F version 15 (decisions 044): {@link fPolicyBaseAbi} is what every policy shares,
+ * the policies in F version 15: {@link fPolicyBaseAbi} is what every policy shares,
  * {@link privatePolicyAbi} the desk's, {@link padPolicyAbi} / {@link polPolicyAbi} / {@link publicPolicyAbi}
  * the kinds'.
  */
@@ -48,7 +48,7 @@ export const fPolicyBaseAbi = polPolicyAbi;
 import { signerFor } from "./write.js";
 const WAD = 10n ** 18n;
 const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-/** The optional questions a policy declared at birth (decisions 044), as bits of `Pool.asks`. */
+/** The optional questions a policy declared at birth, as bits of `Pool.asks`. */
 export const ASK_SWAP = 1;
 export const ASK_MINT = 2;
 /** Read a basket pool whole. Batched — viem multicalls these when the transport allows. */
@@ -75,8 +75,8 @@ export async function getFPool(c, poolId) {
     const n = Number(p.n);
     const idx = Array.from({ length: n }, (_, i) => BigInt(i));
     const [theta, compositeX, legs, kind, name] = await Promise.all([
-        // before the seed there is no L and no floor: θ is X by convention (the manager says so since
-        // bd3dd87's successor; older deployments revert with DivWadFailed, so do not ask them)
+        // before the seed there is no L and no floor: θ is X by convention (older deployments revert
+        // with DivWadFailed, so do not ask them)
         p.L > 0n ? rd("theta", [poolId]) : rd("compositeX", [poolId]),
         rd("compositeX", [poolId]),
         Promise.all(idx.map((i) => rd("legOf", [poolId, i]))),
@@ -85,7 +85,7 @@ export async function getFPool(c, poolId) {
     ]);
     const bases = legs.map((l) => l[0]);
     const weights = legs.map((l) => l[1]);
-    const x = legs.map((l) => l[2]); // derived by the manager: x_j = ln(w_j·L / R_j) (decisions 026)
+    const x = legs.map((l) => l[2]); // derived by the manager: x_j = ln(w_j·L / R_j) 
     const reserves = legs.map((l) => l[3]); // the state
     const { quote, Q, L, phi, theta0, bigSigma, policy, restructureBlock, seeded, gen } = p;
     const totalSupply = p.shares;
@@ -119,7 +119,7 @@ export const SEED_TO_DEAD = 4;
 const kindCache = new Map();
 /**
  * What a policy IS — its `kind()` tag, read once per policy address and cached for the client's
- * chain: a pool's kind is its policy's word (decisions 049), never the manager's. An unknown tag
+ * chain: a pool's kind is its policy's word, never the manager's. An unknown tag
  * (a policy that is not one of the protocol's four shapes) throws; the app has no screen for it.
  */
 export function fPoolKindOfPolicy(c, policy) {
@@ -137,13 +137,13 @@ export function fPoolKindOfPolicy(c, policy) {
     }
     return hit;
 }
-/** The pool's label, as its policy holds it (decisions 049). "" when unnamed. */
+/** The pool's label, as its policy holds it. "" when unnamed. */
 export async function fPoolNameOf(c, poolId, policy) {
     const p = policy ?? (await fPoolPolicyOf(c, poolId));
     const word = (await c.public.readContract({ address: p, abi: fPolicyBaseAbi, functionName: "nameOf", args: [poolId] }));
     return bytes32ToText(word);
 }
-/** The deployment's policy for a kind (decisions 044, 049): the protocol's policy that IS that kind. */
+/** The deployment's policy for a kind: the protocol's policy that IS that kind. */
 export function fPoolPolicyFor(c, kind) {
     const a = c.addresses;
     const policy = kind === "public" ? a.publicPolicy : kind === "private" ? a.privatePolicy : kind === "pol" ? a.polPolicy : a.padPolicy;
@@ -196,7 +196,7 @@ export async function describeFPool(c, s) {
         ? await Promise.all([rd("unharvested"), rd("harvestable"), rd("dividendOf", [s.poolId, BigInt(s.gen), DEAD_ADDRESS])])
         : [0n, 0n, 0n];
     return {
-        shape: s.kind === "pad" ? "launch" : "basket", // the kind, not n = 1 (decisions 036)
+        shape: s.kind === "pad" ? "launch" : "basket", // the kind, not n = 1 
         legs: s.bases.length,
         atFloor: s.Q === 0n,
         unharvested,
@@ -249,7 +249,7 @@ a) {
 }
 /**
  * Burn shares for the pro-rata slice of every reserve. Available at any Q, and after dissolution.
- * By owner since contracts `c782811` (decisions 019): the account burns its own shares; an
+ * By owner: the account burns its own shares; an
  * operator may pass another owner's address, as on the C manager's `burnById`.
  */
 export async function fPoolBurn(c, 
@@ -294,7 +294,7 @@ export async function fPoolPreviewZapIn(c, poolId, dL) {
  *
  * The imbalanced part goes through the pool's own curve before anything is minted. That is not a
  * penalty: minting against a quote-only deposit would be a zero-slippage, zero-fee swap at stale
- * spot, paid for by the existing LPs — 27.4% in f-pool §6's worked example. Routing it through
+ * spot, paid for by the existing LPs. Routing it through
  * the curve deletes the subsidy and hands the fee and impact to the incumbents instead.
  */
 export async function fPoolZapIn(c, a) {
@@ -331,7 +331,7 @@ export async function fPoolPreviewZapOut(c, a) {
     return result;
 }
 /**
- * Roll a retired generation's bundle into the pool's live one (decisions 025, 032), on the
+ * Roll a retired generation's bundle into the pool's live one, on the
  * router under one lock: redeem `shares` of generation `gen` in place — the legs, the quote and
  * any unpulled dividend come back — buy through the pool's own curve only what the live
  * generation's ratio lacks, mint `dL` of it to `to`, and refund the rest in kind. Quote the
@@ -363,26 +363,26 @@ export async function fPoolPreviewRollIn(c, poolId, gen, holder, shares) {
 }
 // ─── the floor lever (authority only) ─────────────────────────────────────────
 /**
- * Remove quote, lifting θ — price-neutral, no base moves, and since decisions 028 a DIVIDEND to
+ * Remove quote, lifting θ — price-neutral, no base moves, and a DIVIDEND to
  * every share: the amount goes into the pool's pot and each holder's slice is settled lazily on
  * their next transfer, mint or burn, or pulled with {@link fPoolClaim}. The sponsor's own slice —
  * its shares' and the locked seed's at 0xdead — is pushed to `to` at once. On a pad
- * the lift stops at the seed floor θ₀ (income only); nothing else bounds it (decisions 035) — an
+ * the lift stops at the seed floor θ₀ (income only); nothing else bounds it — an
  * unlocked pool's authority may take Q to zero.
  */
 export async function fPoolHarvest(c, a) {
     return writeFPool(c, a.poolId, "harvest", [a.amount, a.to ?? a.account], a.account);
 }
 /**
- * Pull one's settled dividend (decisions 028) on a generation's shares without moving them;
+ * Pull one's settled dividend on a generation's shares without moving them;
  * anyone with shares. `gen` defaults to the live generation; a retired generation's harvests
- * stay claimable under its own id (decisions 032).
+ * stay claimable under its own id.
  */
 export async function fPoolClaim(c, a) {
     const gen = a.gen ?? (await fPoolGen(c, a.poolId));
     return writeFPool(c, a.poolId, "claim", [BigInt(gen), a.to ?? a.account], a.account);
 }
-/** A holder's dividend as of now on generation `gen` (the live one by default) — banked plus pending on the current balance (decisions 028). */
+/** A holder's dividend as of now on generation `gen` (the live one by default) — banked plus pending on the current balance. */
 export async function fPoolDividendOf(c, poolId, holder, gen) {
     const g = gen ?? (await fPoolGen(c, poolId));
     return c.public.readContract({
@@ -513,7 +513,7 @@ export async function approveRouterForFPool(c, account) {
 // than read from the chain: it is pure, and a client that has to call to learn an id cannot build
 // a multicall that uses it.
 /**
- * The ERC-6909 id carrying generation `gen` of a pool's shares (decisions 032): bit 255 set (the
+ * The ERC-6909 id carrying generation `gen` of a pool's shares: bit 255 set (the
  * share flag), the pool id's top 239 bits, the generation in the low 16. Each generation's shares
  * are their own asset — a retired one is a claim on its bundle, the live one on the pool.
  */
@@ -548,7 +548,7 @@ export async function fPoolShareBalance(c, poolId, owner, gen) {
         args: [owner, fPoolShareId(poolId, g)],
     });
 }
-/** A retired generation's bundle (decisions 032): what is left to redeem — supply, quote, base per leg index. */
+/** A retired generation's bundle: what is left to redeem — supply, quote, base per leg index. */
 export async function fPoolBundleOf(c, poolId, gen) {
     const [supply, quote, base] = (await c.public.readContract({
         address: c.addresses.fPoolManager,
@@ -558,7 +558,7 @@ export async function fPoolBundleOf(c, poolId, gen) {
     }));
     return { supply, quote, base: [...base] };
 }
-/** A holder's claims on a pool's retired generations — one row per generation still held (decisions 032). */
+/** A holder's claims on a pool's retired generations — one row per generation still held. */
 export async function fPoolClaimsOf(c, poolId, owner) {
     const { logswapLensAbi } = await import("./generated.js");
     const rows = (await c.public.readContract({
@@ -570,7 +570,7 @@ export async function fPoolClaimsOf(c, poolId, owner) {
     return rows.map((r) => ({ gen: Number(r.gen), shares: r.shares, base: [...r.base], quote: r.quote, dividend: r.dividend }));
 }
 /**
- * Redeem `shares` of a RETIRED generation (decisions 032): its bundle, pro rata — the base per
+ * Redeem `shares` of a RETIRED generation: its bundle, pro rata — the base per
  * leg and the quote — plus the owner's settled dividend. Not `burn`: nothing can move a bundle's
  * ratio, so there is no slippage to bound. The owner, or an operator of theirs.
  */
@@ -708,8 +708,8 @@ export async function fPoolIdOf(c, a) {
     });
 }
 /**
- * The reserve a leg holds at a mark: `R = Lj·e^{−x}`, WAD math. The seed names RESERVES since
- * decisions 029 — the sponsor states holdings and the price follows, `p = Lj / R` — so this is
+ * The reserve a leg holds at a mark: `R = Lj·e^{−x}`, WAD math. The seed names RESERVES —
+ * the sponsor states holdings and the price follows, `p = Lj / R` — so this is
  * the one conversion from a price to what the pool will hold, done here, on the way in. Float
  * precision (~1e-16 relative) is what a seed needs: any reserve is a legal seed, and the mark
  * the pool derives from it is the one the sponsor meant to within that.
@@ -730,7 +730,7 @@ export async function fPoolSeed(c, a) {
     return writeFPool(c, a.poolId, "seed", [a.L0, r0, a.Q0], a.account);
 }
 /**
- * Retire the live generation (decisions 025, 032, 035) — the raw entry (`dissolve` before F
+ * Retire the live generation — the raw entry (`dissolve` before F
  * version 14). Allowed only at an empty bid, Q ≤ L/1e9, on every pool: the market took it, or the
  * operator harvested it out first ({@link fPoolRetire} does both in one transaction). The live
  * (S, Q, R_j) become a frozen bundle every share of this generation redeems ({@link fPoolRedeem})
@@ -756,25 +756,25 @@ export async function fPoolRetire(c, a) {
 }
 /**
  * The harvests that empty an unlocked pool's bid, in order — what a relaunch sends before its
- * `retire` (decisions 035: a retire needs an empty bid on every pool). Since F version 14 one
+ * `retire` (a retire needs an empty bid on every pool). Since F version 14 one
  * `harvest(Q)` does it: the protocol's cut leaves the pool with the amount (with no collector
  * there is no cut). `[]` when the bid is already empty. Throws on a pad that still bids (its bid
  * empties only as the market sells it down), and when the pool's policy keeps a floor on the bid
- * (`PolPolicy.keepQuote`, decisions 044): a `retire` under that policy waits for the market.
+ * (`PolPolicy.keepQuote`): a `retire` under that policy waits for the market.
  */
 export async function fPoolEmptyingHarvests(c, poolId) {
     const s = await getFPool(c, poolId);
     if (s.Q === 0n)
         return [];
     if (s.kind === "pad")
-        throw new Error("logswap: a pad is retired only once its bid is empty (decisions 035)");
+        throw new Error("logswap: a pad is retired only once its bid is empty");
     const { maxHarvest } = await getFPoolRoles(c, poolId, s);
     if (maxHarvest < s.Q)
-        throw new Error("logswap: the pool's policy keeps a floor on the bid — it cannot be harvested empty (decisions 044)");
+        throw new Error("logswap: the pool's policy keeps a floor on the bid — it cannot be harvested empty");
     return [s.Q];
 }
 /**
- * Release the dead shares' pot under the policy's terms (decisions 041, 044) — a pad's graduation.
+ * Release the dead shares' pot under the policy's terms — a pad's graduation.
  * The manager harvests the generation's income first (the pot then holds everything the dead
  * shares earned), asks the policy, and applies its answer: a share to the payee it names (the pad's
  * creator — the pool's authority), a cut to the collector, the rest bought in as more of the
@@ -785,7 +785,7 @@ export async function fPoolRegenerate(c, a) {
     return writeFPool(c, a.poolId, "regenerate", [a.to ?? a.account], a.account);
 }
 /**
- * The relaunch as ONE transaction (decisions 025, 032, 035, 037): `harvest` the bid out — a
+ * The relaunch as ONE transaction: `harvest` the bid out — a
  * dividend to every share, {@link fPoolEmptyingHarvests} — `retire` the live generation at the
  * empty bid, `redeem` the caller's own shares of it (when `shares` > 0), optionally `setLegs` the
  * next generation's composition (`legs`: a private pool's reshape — retire, admit, reweight), and
@@ -810,7 +810,7 @@ export async function fPoolRelaunch(c, a) {
     ];
     return writeFPool0(c, "multicall", [calls], a.account);
 }
-/** Where a pad's seed lives (decisions 036): `seed` mints every share of a pad here itself. */
+/** Where a pad's seed lives: `seed` mints every share of a pad here itself. */
 export const DEAD_ADDRESS = "0x000000000000000000000000000000000000dEaD";
 /** The manager's `MIN_SHARES`: the seed mints this much to 0xdead on every pool, the rest to the seeder — or, on a pad, to 0xdead too. */
 export const F_MIN_SHARES = 1000n;
@@ -837,22 +837,22 @@ export function fPoolLaunchCalls(poolId, a) {
         calls.push(enc("initialize", [key]));
     calls.push(enc("seed", [poolId, a.L0, companions[1], a.Q0]));
     // gen 0 by construction: a launch is the pool's FIRST seed — a relaunch is `fPoolRelaunch`.
-    // No transfer to 0xdead: on a pad `seed` mints every share there itself (decisions 036).
+    // No transfer to 0xdead: on a pad `seed` mints every share there itself.
     if (a.openBuy) {
         const j = bases.indexOf(a.bases[a.openBuy.j]);
         if (j < 0)
             throw new Error(`logswap: openBuy.j = ${a.openBuy.j} is not a leg`);
         calls.push(enc("swapQuoteIn", [poolId, BigInt(j), a.openBuy.amountIn, a.openBuy.minOut ?? 0n, a.account]));
     }
-    // the name, the desk's gates and its list are the POLICY's (decisions 044, 049), not the
+    // the name, the desk's gates and its list are the POLICY's, not the
     // manager's: they cannot ride in this batch — `fPoolLaunch` and `fPoolDeskOpening` send them
     // right after, as the same creator
     calls.push(...(a.extra ?? []));
     return calls;
 }
 /**
- * The desk's opening posture, on its policy (decisions 044, 048): gated minting, the creator a
- * minter. No appointment: the authority is the operator until one is appointed (decisions 037).
+ * The desk's opening posture, on its policy: gated minting, the creator a
+ * minter. No appointment: the authority is the operator until one is appointed.
  * Two writes to `PrivatePolicy`; the launch batch cannot carry them (they are not manager calls).
  */
 export async function fPoolDeskOpening(c, a) {
@@ -888,7 +888,7 @@ export async function fPoolLaunch(c, a) {
         await fPoolSetName(c, { poolId, name: a.name, account: a.account, policy });
     return { hash, poolId };
 }
-// ─── the roles, on the policy (decisions 044) ─────────────────────────────────────────────
+// ─── the roles, on the policy ─────────────────────────────────────────────
 //
 // Every write here goes to the pool's POLICY, not the manager: the manager holds no role. `policy`
 // may be passed when in hand (`FPoolState.policy`, `FPoolRoles.policy`); otherwise it is read once.
@@ -906,7 +906,7 @@ async function writePolicy(c, abi, a, functionName, args) {
     return wallet.writeContract(request);
 }
 /**
- * Propose the next authority — step one of two (decisions 020), on the pool's policy. Nothing moves
+ * Propose the next authority — step one of two, on the pool's policy. Nothing moves
  * until `next` accepts; proposing again (the zero address included) cancels a pending proposal.
  * Indexed on-chain via the policy's AuthorityProposed.
  */
@@ -916,26 +916,26 @@ export async function fPoolProposeAuthority(c, a) {
 /**
  * Accept a pending proposal — step two; only the proposed address can. Indexed via the policy's
  * AuthoritySet. On the desk's policy this clears the operator (pending and accepted) and voids the
- * seller's list (decisions 040, 044).
+ * seller's list.
  */
 export async function fPoolAcceptAuthority(c, a) {
     return writePolicy(c, fPolicyBaseAbi, a, "acceptAuthority", []);
 }
-// ─── the desk's controls (PrivatePolicy; decisions 021, 044) ───────────────────────────────
+// ─── the desk's controls (PrivatePolicy) ───────────────────────────────
 /** Turn the mint / swap gates on or off (the authority, on the desk's policy). `burn` is never gated. */
 export async function fPoolSetGates(c, a) {
     return writePolicy(c, privatePolicyAbi, a, "setGates", [a.gateMint, a.gateSwap]);
 }
 /**
  * Add to or remove from the pool's MINTERS — who may mint, and swap (a zap in is both under one
- * lock) — in one call (the authority, on the desk's policy; decisions 048). The list is keyed by
+ * lock) — in one call (the authority, on the desk's policy). The list is keyed by
  * the authority that granted it: a handover starts the buyer with an empty one. Stamps the
  * block: no swap lands in it (047).
  */
 export async function fPoolSetMinters(c, a) {
     return writePolicy(c, privatePolicyAbi, a, "setMinters", [a.who, a.allowed]);
 }
-/** Add to or remove from the pool's TAKERS — who may swap only — in one call (the authority; decisions 048). Stamps the block. */
+/** Add to or remove from the pool's TAKERS — who may swap only — in one call (the authority). Stamps the block. */
 export async function fPoolSetTakers(c, a) {
     return writePolicy(c, privatePolicyAbi, a, "setTakers", [a.who, a.allowed]);
 }
@@ -955,12 +955,12 @@ export async function fPoolIsTaker(c, poolId, who, policy) {
 export async function fPoolIsAllowed(c, poolId, who, policy) {
     return readDesk(c, poolId, who, "isAllowed", policy);
 }
-/** Label the pool — the authority's own words on the pool's POLICY (decisions 049), mutable, never identity. At most 31 bytes of UTF-8. */
+/** Label the pool — the authority's own words on the pool's POLICY, mutable, never identity. At most 31 bytes of UTF-8. */
 export async function fPoolSetName(c, a) {
     return writePolicy(c, fPolicyBaseAbi, a, "setName", [textToBytes32(a.name)]);
 }
 /**
- * What the PROTOCOL says an address is — "Keyrock" — on the REGISTRY (decisions 049). Only its
+ * What the PROTOCOL says an address is — "Keyrock" — on the REGISTRY. Only its
  * owner, the LOG authority, may write it, which is what makes it an attestation rather than a
  * claim anyone could make about themselves.
  */
@@ -996,7 +996,7 @@ async function registryAddress(c) {
         throw new Error("logswap: this deployment carries no policy registry");
     return registry;
 }
-/** Who runs the pool (decisions 037): the appointed operator, or the authority until one is. */
+/** Who runs the pool: the appointed operator, or the authority until one is. */
 export function fPoolOperatorOf(s) {
     return s.operator === ZERO_ADDRESS ? s.authority : s.operator;
 }
@@ -1014,7 +1014,7 @@ export async function fPoolAcceptOperator(c, a) {
 }
 /**
  * The next generation's composition (operator; private pools only; ONLY while the pool is
- * unseeded — between a retire and the seed that prices it, decisions 037). `weights` has one
+ * unseeded — between a retire and the seed that prices it). `weights` has one
  * entry per leg the pool has ever had, in index order (0 retires a leg; indices are never reused),
  * then one per base in `newBases`, appended; they sum to 1e18 exactly. No value moves: the
  * following {@link fPoolSeed} names every reserve. A live reshape is {@link fPoolRelaunch} with
@@ -1083,7 +1083,7 @@ export async function discoverFPools(c, opts = {}) {
             block: l.blockNumber ?? 0n,
             seeded: q0 !== undefined,
             q0: q0 ?? 0n,
-            shape: kind === "pad" ? "launch" : "basket", // the policy's word, not n = 1: a mono POL is a pool (decisions 036, 049)
+            shape: kind === "pad" ? "launch" : "basket", // the policy's word, not n = 1: a mono POL is a pool 
         };
     }));
 }

package/dist/keys.d.ts

@@ -23,7 +23,7 @@ export interface PoolKey {
     /**
      * The swap fee, WAD, fixed for the life of the market: `FEE_MIN` (1 bp) ≤ φ ≤ `FEE_MAX` (25%),
      * or `0n`, which selects `DEFAULT_FEE` (2 bp) at read time. Four fields since C version 4
-     * (decisions 042): `kappa` and `alpha` left with the variance kernel, and `phiMin` — a floor with
+     *: `kappa` and `alpha` left with the variance kernel, and `phiMin` — a floor with
      * nothing above it — became `phi`. Every pool id changed with the shape.
      */
     phi: bigint;

package/dist/liquidity.d.ts

@@ -2,7 +2,7 @@
  * liquidity.ts — providing, editing and exiting a C position.
  *
  * A class is (ξ, μ, L): floor, cap, exposure. One primitive sets all three — `update` — and every
- * edit is a constraint on it. The vocabulary follows the geometry (decisions 009): **the verb
+ * edit is a constraint on it. The vocabulary follows the geometry: **the verb
  * names the axis, the direction is a signed rung count**, and only two direction-words survive,
  * because each names a wallet flow the user must see.
  *
@@ -15,7 +15,7 @@
  *   └─ reprice(ξ')         R pinned: L' = L·e^{ξ' − ξ}, dormant only
  *   mint · burn · claim
  *
- * Every edit is ONE action of the router's batch (decisions 010, `actions.ts`), which is what
+ * Every edit is ONE action of the router's batch (`actions.ts`), which is what
  * lets it settle in kind, or in base, or in quote: `settleIn` appends the one swap that nets the
  * other side, and the batch moves a single token. `previewEdit` is the lens's `previewUpdate` —
  * the exact flows, mint fee and swept fees included — and is what an editor shows before its one
@@ -55,7 +55,7 @@ export interface MintArgs extends WriteOptions {
 export declare function mint(c: LogswapClient, a: MintArgs): Promise<Hash>;
 export interface CreateMarketArgs extends WriteOptions {
     key: PoolKey;
-    /** Launch log-price. Bounded by the manager to ±46 (the price domain, decisions 012). */
+    /** Launch log-price. Bounded by the manager to ±46 (the price domain). */
     x0: bigint;
     /** The backstop's floor — the first mint's rung, permanent for the pool's life. */
     targetFloor: bigint;
@@ -67,7 +67,7 @@ export interface CreateMarketArgs extends WriteOptions {
 }
 /**
  * Create a market ATOMICALLY: `initialize` at `x0` plus the backstop-establishing first mint in
- * one transaction — the canonical creation path (decisions 013, security-review H-02). The
+ * one transaction — the canonical creation path. The
  * two-step path let an attacker seat the PERMANENT backstop at a hostile rung between an honest
  * `initialize` and its first mint; here either both land or neither, and a front-run of the whole
  * call reverts it without moving a wei. No cap: the first mint IS the backstop and must be
@@ -79,7 +79,7 @@ export interface ZapArgs extends WriteOptions {
     /** Fund entirely from base (true) or entirely from quote (false). */
     fundWithBase: boolean;
     amountIn: bigint;
-    /** The least the swap leg may return (contracts 7c82eed, decisions 043): the zap's own slippage bound, as `swapExactIn`'s. Required. */
+    /** The least the swap leg may return: the zap's own slippage bound, as `swapExactIn`'s. Required. */
     minSwapOut: bigint;
     targetFloor: bigint;
     cap?: bigint;
@@ -93,7 +93,7 @@ export interface ZapArgs extends WriteOptions {
  *
  * Routing the imbalanced part through the CURVE is the point, not an implementation detail. A
  * pro-rata deposit of one asset would be a zero-slippage, zero-fee swap at stale spot — a subsidy
- * paid by the incumbent LPs (`logswap-docs` §*Quote-only capital*). Paying the curve removes it.
+ * paid by the incumbent LPs. Paying the curve removes it.
  */
 export declare function zapIn(c: LogswapClient, a: ZapArgs): Promise<Hash>;
 export interface UpdateArgs extends WriteOptions {
@@ -124,7 +124,7 @@ export interface MoveArgs extends WriteOptions {
  * Reposition at constant exposure — the L-pinned parent of `floor`, `cap` and `shift`; in kind.
  *
  * **Bound it.** The router used to settle this entry with no limit, which meant a reposition that
- * priced differently by inclusion time could pull the whole allowance (security-review2 M-01).
+ * priced differently by inclusion time could pull the whole allowance.
  * The bounds are required; {@link UNBOUNDED} is an explicit, visible opt-out.
  */
 export declare function move(c: LogswapClient, a: MoveArgs): Promise<Hash>;

package/dist/liquidity.js

@@ -2,7 +2,7 @@
  * liquidity.ts — providing, editing and exiting a C position.
  *
  * A class is (ξ, μ, L): floor, cap, exposure. One primitive sets all three — `update` — and every
- * edit is a constraint on it. The vocabulary follows the geometry (decisions 009): **the verb
+ * edit is a constraint on it. The vocabulary follows the geometry: **the verb
  * names the axis, the direction is a signed rung count**, and only two direction-words survive,
  * because each names a wallet flow the user must see.
  *
@@ -15,7 +15,7 @@
  *   └─ reprice(ξ')         R pinned: L' = L·e^{ξ' − ξ}, dormant only
  *   mint · burn · claim
  *
- * Every edit is ONE action of the router's batch (decisions 010, `actions.ts`), which is what
+ * Every edit is ONE action of the router's batch (`actions.ts`), which is what
  * lets it settle in kind, or in base, or in quote: `settleIn` appends the one swap that nets the
  * other side, and the batch moves a single token. `previewEdit` is the lens's `previewUpdate` —
  * the exact flows, mint fee and swept fees included — and is what an editor shows before its one
@@ -55,7 +55,7 @@ export async function mint(c, a) {
 }
 /**
  * Create a market ATOMICALLY: `initialize` at `x0` plus the backstop-establishing first mint in
- * one transaction — the canonical creation path (decisions 013, security-review H-02). The
+ * one transaction — the canonical creation path. The
  * two-step path let an attacker seat the PERMANENT backstop at a hostile rung between an honest
  * `initialize` and its first mint; here either both land or neither, and a front-run of the whole
  * call reverts it without moving a wei. No cap: the first mint IS the backstop and must be
@@ -83,7 +83,7 @@ export async function createMarket(c, a) {
  *
  * Routing the imbalanced part through the CURVE is the point, not an implementation detail. A
  * pro-rata deposit of one asset would be a zero-slippage, zero-fee swap at stale spot — a subsidy
- * paid by the incumbent LPs (`logswap-docs` §*Quote-only capital*). Paying the curve removes it.
+ * paid by the incumbent LPs. Paying the curve removes it.
  */
 export async function zapIn(c, a) {
     return sendRouterWriteWithPermits(c, {
@@ -126,7 +126,7 @@ export async function update(c, a) {
  * Reposition at constant exposure — the L-pinned parent of `floor`, `cap` and `shift`; in kind.
  *
  * **Bound it.** The router used to settle this entry with no limit, which meant a reposition that
- * priced differently by inclusion time could pull the whole allowance (security-review2 M-01).
+ * priced differently by inclusion time could pull the whole allowance.
  * The bounds are required; {@link UNBOUNDED} is an explicit, visible opt-out.
  */
 export async function move(c, a) {
@@ -191,7 +191,7 @@ export async function edit(c, a) {
         settle = settleInKind(key, recipient, { ...boundsFromFlows(p.dBase, p.dQuote, a.slippageBps), ...defined(a) });
     }
     else {
-        // the swept fees ride INSIDE dQuote (the manager burns by owner and nets them; decisions 018),
+        // the swept fees ride INSIDE dQuote (the manager burns by owner and nets them),
         // so quote's open delta after the update is dQuote itself — `fees` is reported for display only
         const otherFlow = settleIn === "base" ? p.dQuote : p.dBase; // + = owed, − = released
         const otherIsBase = settleIn === "quote";

package/dist/pools.d.ts

@@ -26,7 +26,7 @@ export interface PoolState {
     reserveQuote: bigint;
     /** Fee-per-unit-L accumulator: $\phi \cdot \mathrm{TV}(\log p)$. */
     F: bigint;
-    /** Quadratic variation of log-price, $\Sigma = \sum_{\text{swaps}} (\Delta x_{\text{swap}})^2$ — one term per swap (decisions 042). */
+    /** Quadratic variation of log-price, $\Sigma = \sum_{\text{swaps}} (\Delta x_{\text{swap}})^2$ — one term per swap. */
     bigSigma: bigint;
     currentK: bigint;
     protocolOwed: bigint;
@@ -37,7 +37,7 @@ export interface PoolState {
 export declare function getPool(c: LogswapClient, key: PoolKey): Promise<PoolState>;
 /**
  * The market's fee: the key's `phi` with `0n` resolved to `DEFAULT_FEE`. Constant for the market's
- * life (C version 4, decisions 042 — `phiEff` and the variance kernel before). Reverts for a key
+ * life (C version 4, — `phiEff` and the variance kernel before). Reverts for a key
  * nobody initialized, which `discoverMarkets` relies on to drop a stale indexer's rows.
  */
 export declare function phiOf(c: LogswapClient, key: PoolKey): Promise<bigint>;

package/dist/pools.js

@@ -28,7 +28,7 @@ export async function getPool(c, key) {
 }
 /**
  * The market's fee: the key's `phi` with `0n` resolved to `DEFAULT_FEE`. Constant for the market's
- * life (C version 4, decisions 042 — `phiEff` and the variance kernel before). Reverts for a key
+ * life (C version 4, — `phiEff` and the variance kernel before). Reverts for a key
  * nobody initialized, which `discoverMarkets` relies on to drop a stale indexer's rows.
  */
 export async function phiOf(c, key) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logswap/sdk",
-  "version": "0.5.55",
+  "version": "0.5.56",
   "description": "TypeScript SDK for Logswap, the liquidity primitive introducing the logarithmic invariant — typed wrappers over the CPoolManager / FPoolManager / Router / Lens surface.",
   "license": "GPL-2.0-or-later",
   "type": "module",
@@ -45,5 +45,6 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/logswap/logswap-sdk.git"
-  }
+  },
+  "homepage": "https://logswap.org"
 }

package/src/actions.ts

@@ -1,5 +1,5 @@
 /**
- * actions.ts — the router's transaction: a BATCH (decisions 010).
+ * actions.ts — the router's transaction: a BATCH.
  *
  * `execute(actions, settle)` runs a list of actions — mint, burn, update, claim, swap, path, in any
  * order, across any C markets — under ONE manager lock. Each action accrues deltas on the router

package/src/admin.ts

@@ -1,12 +1,12 @@
 /**
  * admin — the protocol's writes: the C manager's cut of the mint fee (the F manager's is a
- * constant, decisions 049), the policies a pool may be born with (the registry's), the
+ * constant), the policies a pool may be born with (the registry's), the
  * policies' own numbers, and the two-step collector handover. Plain writes to the managers,
  * the registry and the policies; no router.
  *
- * One vocabulary (decisions 040): both managers call the protocol's cut of the mint fee
+ * One vocabulary: both managers call the protocol's cut of the mint fee
  * `MINT_FEE_PROTOCOL_CUT`; C sets it through `setFeeParams(uint256)`, F holds it as a constant
- * (049). The harvest's cut is the policy's answer at every harvest (decisions 044), set on the
+ * (049). The harvest's cut is the policy's answer at every harvest, set on the
  * policy (`setHarvestCut`) and capped by the manager (`HARVEST_CUT_MAX`); the release's
  * protocol share likewise (`POT_CUT_MAX`).
  */
@@ -29,12 +29,12 @@ function write(c: LogswapClient, address: Address, abi: readonly unknown[], func
 export async function setFeeParamsC(c: LogswapClient, mintFeeProtocolCutWad: bigint): Promise<Hash> {
   return write(c, c.addresses.cPoolManager, cPoolManagerAbi, "setFeeParams", [mintFeeProtocolCutWad]);
 }
-/** The F manager's `MINT_FEE_PROTOCOL_CUT` — a constant since F version 18 (decisions 049); there is no setter. */
+/** The F manager's `MINT_FEE_PROTOCOL_CUT` — a constant since F version 18; there is no setter. */
 export async function fMintFeeProtocolCut(c: LogswapClient): Promise<bigint> {
   return c.public.readContract({ address: c.addresses.fPoolManager as Address, abi: fPoolManagerAbi, functionName: "MINT_FEE_PROTOCOL_CUT" } as never) as Promise<bigint>;
 }
 
-// ─── the registry (decisions 046): the LOG authority's, not the collector's ─────────────────
+// ─── the registry: the LOG authority's, not the collector's ─────────────────
 
 const ZERO = "0x0000000000000000000000000000000000000000" as const;
 
@@ -58,7 +58,7 @@ export async function policyApproved(c: LogswapClient, policy: Address): Promise
 /** One policy on the registry's list, with what it says it is. */
 export interface RegistryEntry {
   policy: Address;
-  /** The policy's own `kind()` tag (decisions 049) — what a pool born under it is. */
+  /** The policy's own `kind()` tag — what a pool born under it is. */
   kind: FPoolKind;
   name: string;
   /** The block it closes to new pools from; 0 = open. */
@@ -68,7 +68,7 @@ export interface RegistryEntry {
 }
 
 /**
- * Every policy listed, sunset ones included — one flat list (decisions 049), each with the kind
+ * Every policy listed, sunset ones included — one flat list, each with the kind
  * it says it is; `kind` narrows it to one, which is what a create form's dropdown reads. Empty
  * with no registry.
  */
@@ -138,7 +138,7 @@ export async function setPolicyApproved(c: LogswapClient, policy: Address, appro
 }
 
 /**
- * Move a pool to another approved policy of the same kind (decisions 046, 049): the registry
+ * Move a pool to another approved policy of the same kind: the registry
  * owner's alone, orchestrated on the registry — `migrate(manager, poolId, to)`. The new policy
  * takes the authority and the name from the old; the operator and the lists void; no swap lands
  * in the block.