@logswap/sdk 0.5.73 → 0.5.75

package/README.md

@@ -44,6 +44,46 @@ Both are computed **offline** — no RPC, no deployment needed to address a mark
   floor price (was `theta`), `refLogFloor` θ₀ — the reference floor income counts from (was
   `theta0`), `cap` (d in 1e-6 log units, 0 uncapped), and per leg `virtualReserves` and `kappa`.
 
+## Who may create what: the gate, the menus (C version 7, F version 26)
+
+Since logswap-contract #60 (decisions 064–065) creation is curated at launch, on both managers:
+
+- **The C gate is the public policy**, set in the C manager's constructor. A C market is admitted if
+  its creator, quote, pair, swap-fee tier (2, 5, 10, 25, 50, 100 bp) and tick spacing (10 or 100 bp)
+  are listed, and only one market per (base, quote, fee) exists. `cGateRules(c, { key, creator })`
+  reads every check in one round; `gateErrorAbi` decodes the refusals (`CreatorNotListed`,
+  `MarketExists`, `SpacingNotListed`, `PairNotListed`, `MintFeeNotListed`, `NoForwardedUser`,
+  `PadExists`).
+- **`createMarket` stays one transaction**: the router is a trusted forwarder, so the gate checks
+  the router's `user()` — the wallet that sent the call — against the creator list.
+- **The mint fee is per pool**, the creator's pick from the policy's menu, proposed at
+  `initialize` / `createMarket` / `fPoolInitialize` / `fPoolLaunch` (`mintFee?`). It defaults to
+  `presetMintFee(swapFee)`: twice the swap fee, capped at `FEE_MAX` — guidance, not a contract rule.
+  `policyMintFeeMenu(c, policy, candidates)` lists what a policy accepts; `getPool(...).mintFee` /
+  `getFPool(...).mintFee` read a pool's. `mintFee(p, x, rate)` previews it at the market's rate.
+- **A fee of 0 is no fee**: `swapFeeOf` and `DEFAULT_FEE` are gone; `marketSwapFee` returns the key's
+  own fee for an initialized market.
+- **C reads**: `getPool` reads the lens's `getPools`; `getPositionClass` reads the class through
+  `extsload` at `CPoolState`'s slot (the manager's typed views are gone).
+- **Creators are curated on every kind** at launch (onboarding under a service agreement); the
+  collector's helpers: `policySetCreatorListed`, `policySetMintFeeListed`, `gateSetPairListed`,
+  `gateSetSpacingListed`, `gateSetForwarderTrusted`, `setCGate`.
+
+## History from the indexer (indexer phase 1)
+
+Every event read goes through `getEventLogs` (one event) or `getEventsLogs` (several, tagged by
+`eventName`): the rindexer GraphQL endpoint when one is given, the node otherwise or when it fails.
+Since logswap-be #43 the indexer also holds the four policies (one `Policy` table per event, tracked
+from the registry's `Approved`), the registry, the token factory and the managers' admin events, so
+nothing has to scan the node from block 0 — which the devnet node, pruning logs after about a day,
+answers only partly.
+
+- `swapFees`, `holdingsOf`, `discoverMarkets` and `fPoolKeyOfPool` take `indexer` (the salt is not in
+  `FInitialize`, so a pad's key is still rebuilt from its split with nonce 0).
+- `getEventLogs` takes several emitters (`address: [...]`); a policy outside the artifact names its
+  shared tables with `contract: indexedContractOf(kind, event)` (or `kind` on `getEventsLogs`).
+- `tokensCreated` lists the factory's tokens (`addresses.tokenFactory`): the token list's provenance.
+
 ## Capped F pools and the lien (F version 25)
 
 - **The cap** (decisions 061) is a key field: `FPoolKey.cap` / `FPoolCreateArgs.cap`, d =

package/dist/admin.d.ts

@@ -9,6 +9,7 @@
  * is the policy's (`PadPolicy.setSchedule`), capped by the manager at `POT_CUT_MAX`.
  */
 import type { Address, Hash } from "viem";
+import type { PoolKey } from "./keys.js";
 import type { LogswapClient } from "./client.js";
 import { type FPoolKey, type FPoolKind } from "./fpool.js";
 /**
@@ -140,6 +141,200 @@ export declare function policyFeeAllowed(c: LogswapClient, policy: Address, fee:
     listed: boolean;
     allowed: boolean;
 }>;
+/** `setMintFeeListed` on any protocol policy (065): an entry of its mint-fee menu. The collector's. */
+export declare function policySetMintFeeListed(c: LogswapClient, policy: Address, mintFee: bigint, listed: boolean): Promise<Hash>;
+/** `setMintFeeCurated` on any protocol policy: on, a birth proposing an unlisted mint fee is refused (`MintFeeNotListed`). */
+export declare function policySetMintFeeCurated(c: LogswapClient, policy: Address, curated: boolean): Promise<Hash>;
+/**
+ * A policy's mint-fee menu, for a create form (065): which of `candidates` it lists, and whether it
+ * curates at all (uncurated, any fee in the domain is accepted — the desk's policy never curates).
+ * The candidates are the app's — typically {@link presetMintFee} of each listed swap tier.
+ */
+export declare function policyMintFeeMenu(c: LogswapClient, policy: Address, candidates: readonly bigint[]): Promise<{
+    curated: boolean;
+    listed: bigint[];
+}>;
+/** `setCreatorListed` on any protocol policy (064): a creator onboarded under a service agreement. */
+export declare function policySetCreatorListed(c: LogswapClient, policy: Address, who: Address, listed: boolean): Promise<Hash>;
+/** `setCreatorCurated` on any protocol policy: on, only listed creators may create on that kind (C: the caller; F: `key.creator`). */
+export declare function policySetCreatorCurated(c: LogswapClient, policy: Address, curated: boolean): Promise<Hash>;
+/** `PublicPolicy.setPairListed` (064): a C pair a market may be born on while pairs are curated. Directional (base, quote). */
+export declare function gateSetPairListed(c: LogswapClient, policy: Address, base: Address, quote: Address, listed: boolean): Promise<Hash>;
+/** `PublicPolicy.setPairCurated` (064). */
+export declare function gateSetPairCurated(c: LogswapClient, policy: Address, curated: boolean): Promise<Hash>;
+/** `PublicPolicy.setSpacingListed` (064): a C tick spacing, WAD (10 bp = 1e15, 100 bp = 1e16). Always consulted. */
+export declare function gateSetSpacingListed(c: LogswapClient, policy: Address, tickSpacing: bigint, listed: boolean): Promise<Hash>;
+/** `PublicPolicy.setForwarderTrusted` (064): a router whose `user()` the gate takes as the creator. */
+export declare function gateSetForwarderTrusted(c: LogswapClient, policy: Address, forwarder: Address, trusted: boolean): Promise<Hash>;
+/** `CPoolManager.setGate` (064): name, change or lift (`address(0)`) the C gate. The C collector's. */
+export declare function setCGate(c: LogswapClient, gate: Address): Promise<Hash>;
+/** The C manager's gate (`address(0)`: permissionless, a fee-free market then refused). */
+export declare function cGate(c: LogswapClient): Promise<Address>;
+export interface CGateRules {
+    creatorOk: boolean;
+    quoteOk: boolean;
+    pairOk: boolean;
+    feeOk: boolean;
+    spacingOk: boolean;
+    /** A market on (base, quote, fee) already exists, whatever its spacing: the gate refuses another (064 (b)). */
+    exists: boolean;
+    /** Whether `router` is a trusted forwarder — `createMarket` through it is then checked against `creator`. */
+    routerTrusted: boolean;
+    /** Every check passes: the gate would admit this market from this creator (the mint fee aside — see {@link policyMintFeeMenu}). */
+    admitted: boolean;
+}
+/**
+ * The public policy's C checks for one candidate market and creator, in one round of reads — what
+ * the create form shows before a wallet is asked (064). `router` is the router the form will go
+ * through (`c.addresses.router` by default).
+ */
+export declare function cGateRules(c: LogswapClient, a: {
+    key: PoolKey;
+    creator: Address;
+    router?: Address;
+    gate?: Address;
+}): Promise<CGateRules>;
+/**
+ * Every refusal a birth can meet at the gate or a policy (064, 065), for `decodeErrorResult` on a
+ * failed simulation: the public policy's errors plus the pad's `PadExists` (one pad per base).
+ */
+export declare const gateErrorAbi: readonly ({
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "base";
+        readonly internalType: "address";
+        readonly type: "address";
+    }, {
+        readonly name: "pad";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly name: "PadExists";
+} | {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "BadFee";
+} | {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "BadRate";
+} | {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "creator";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly name: "CreatorNotListed";
+} | {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "fee";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "FeeNotListed";
+} | {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "base";
+        readonly internalType: "address";
+        readonly type: "address";
+    }, {
+        readonly name: "quote";
+        readonly internalType: "address";
+        readonly type: "address";
+    }, {
+        readonly name: "fee";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "MarketExists";
+} | {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "mintFee";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "MintFeeNotListed";
+} | {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "NoCreator";
+} | {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "forwarder";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly name: "NoForwardedUser";
+} | {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "NotAuthority";
+} | {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "NotCanonical";
+} | {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "NotCollector";
+} | {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly name: "NotListed";
+} | {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "NotManager";
+} | {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "NotRegistry";
+} | {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "OneBase";
+} | {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "base";
+        readonly internalType: "address";
+        readonly type: "address";
+    }, {
+        readonly name: "quote";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly name: "PairNotListed";
+} | {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "quote";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly name: "QuoteNotListed";
+} | {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "Refused";
+} | {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "tickSpacing";
+        readonly internalType: "int256";
+        readonly type: "int256";
+    }];
+    readonly name: "SpacingNotListed";
+})[];
 /** `PublicPolicy.setListed`: an asset a curated seed may hold. */
 export declare function publicSetListed(c: LogswapClient, policy: Address, token: Address, listed: boolean): Promise<Hash>;
 /** `PublicPolicy.setCurated`: whether every public seed is checked against the list. */

package/dist/admin.js

@@ -205,6 +205,97 @@ export async function policyFeeAllowed(c, policy, fee) {
     ]);
     return { curated, listed, allowed: !curated || listed };
 }
+/** `setMintFeeListed` on any protocol policy (065): an entry of its mint-fee menu. The collector's. */
+export async function policySetMintFeeListed(c, policy, mintFee, listed) {
+    return write(c, policy, fPolicyBaseAbi, "setMintFeeListed", [mintFee, listed]);
+}
+/** `setMintFeeCurated` on any protocol policy: on, a birth proposing an unlisted mint fee is refused (`MintFeeNotListed`). */
+export async function policySetMintFeeCurated(c, policy, curated) {
+    return write(c, policy, fPolicyBaseAbi, "setMintFeeCurated", [curated]);
+}
+/**
+ * A policy's mint-fee menu, for a create form (065): which of `candidates` it lists, and whether it
+ * curates at all (uncurated, any fee in the domain is accepted — the desk's policy never curates).
+ * The candidates are the app's — typically {@link presetMintFee} of each listed swap tier.
+ */
+export async function policyMintFeeMenu(c, policy, candidates) {
+    const rd = (functionName, args = []) => c.public.readContract({ address: policy, abi: fPolicyBaseAbi, functionName, args });
+    const [curated, ...flags] = await Promise.all([rd("mintFeeCurated"), ...candidates.map((m) => rd("mintFeeListed", [m]))]);
+    return { curated, listed: candidates.filter((_, i) => flags[i]) };
+}
+/** `setCreatorListed` on any protocol policy (064): a creator onboarded under a service agreement. */
+export async function policySetCreatorListed(c, policy, who, listed) {
+    return write(c, policy, fPolicyBaseAbi, "setCreatorListed", [who, listed]);
+}
+/** `setCreatorCurated` on any protocol policy: on, only listed creators may create on that kind (C: the caller; F: `key.creator`). */
+export async function policySetCreatorCurated(c, policy, curated) {
+    return write(c, policy, fPolicyBaseAbi, "setCreatorCurated", [curated]);
+}
+/** `PublicPolicy.setPairListed` (064): a C pair a market may be born on while pairs are curated. Directional (base, quote). */
+export async function gateSetPairListed(c, policy, base, quote, listed) {
+    return write(c, policy, publicPolicyAbi, "setPairListed", [base, quote, listed]);
+}
+/** `PublicPolicy.setPairCurated` (064). */
+export async function gateSetPairCurated(c, policy, curated) {
+    return write(c, policy, publicPolicyAbi, "setPairCurated", [curated]);
+}
+/** `PublicPolicy.setSpacingListed` (064): a C tick spacing, WAD (10 bp = 1e15, 100 bp = 1e16). Always consulted. */
+export async function gateSetSpacingListed(c, policy, tickSpacing, listed) {
+    return write(c, policy, publicPolicyAbi, "setSpacingListed", [tickSpacing, listed]);
+}
+/** `PublicPolicy.setForwarderTrusted` (064): a router whose `user()` the gate takes as the creator. */
+export async function gateSetForwarderTrusted(c, policy, forwarder, trusted) {
+    return write(c, policy, publicPolicyAbi, "setForwarderTrusted", [forwarder, trusted]);
+}
+/** `CPoolManager.setGate` (064): name, change or lift (`address(0)`) the C gate. The C collector's. */
+export async function setCGate(c, gate) {
+    return write(c, c.addresses.cPoolManager, cPoolManagerAbi, "setGate", [gate]);
+}
+/** The C manager's gate (`address(0)`: permissionless, a fee-free market then refused). */
+export async function cGate(c) {
+    return c.public.readContract({ address: c.addresses.cPoolManager, abi: cPoolManagerAbi, functionName: "gate" });
+}
+/**
+ * The public policy's C checks for one candidate market and creator, in one round of reads — what
+ * the create form shows before a wallet is asked (064). `router` is the router the form will go
+ * through (`c.addresses.router` by default).
+ */
+export async function cGateRules(c, a) {
+    const g = a.gate ?? c.addresses.publicPolicy;
+    const rd = (functionName, args = []) => c.public.readContract({ address: g, abi: publicPolicyAbi, functionName, args });
+    const { key } = a;
+    const [creatorCurated, creatorListed, quoteCurated, quoteListed, pairCurated, pairListed, feeCurated, feeListed, spacingListed, market, routerTrusted] = await Promise.all([
+        rd("creatorCurated"),
+        rd("creatorListed", [a.creator]),
+        rd("quoteCurated"),
+        rd("quoteListed", [key.quote]),
+        rd("pairCurated"),
+        rd("pairListed", [key.base, key.quote]),
+        rd("feeCurated"),
+        rd("feeListed", [key.swapFee]),
+        rd("spacingListed", [key.tickSpacing]),
+        rd("cMarketOf", [key.base, key.quote, key.swapFee]),
+        rd("forwarderTrusted", [a.router ?? c.addresses.router]),
+    ]);
+    const r = {
+        creatorOk: !creatorCurated || creatorListed,
+        quoteOk: !quoteCurated || quoteListed,
+        pairOk: !pairCurated || pairListed,
+        feeOk: !feeCurated || feeListed,
+        spacingOk: spacingListed,
+        exists: BigInt(market) !== 0n,
+        routerTrusted,
+    };
+    return { ...r, admitted: r.creatorOk && r.quoteOk && r.pairOk && r.feeOk && r.spacingOk && !r.exists };
+}
+/**
+ * Every refusal a birth can meet at the gate or a policy (064, 065), for `decodeErrorResult` on a
+ * failed simulation: the public policy's errors plus the pad's `PadExists` (one pad per base).
+ */
+export const gateErrorAbi = [
+    ...publicPolicyAbi.filter((x) => x.type === "error"),
+    ...padPolicyAbi.filter((x) => x.type === "error" && x.name === "PadExists"),
+];
 /** `PublicPolicy.setListed`: an asset a curated seed may hold. */
 export async function publicSetListed(c, policy, token, listed) {
     return write(c, policy, publicPolicyAbi, "setListed", [token, listed]);

package/dist/client.d.ts

@@ -35,6 +35,8 @@ export interface LogswapAddresses {
      * absent; a deployment with none asks nobody.
      */
     policyRegistry?: Address;
+    /** The devnet's token factory (`TokenFactory`, a mock): where launchable tokens come from. Optional. */
+    tokenFactory?: Address;
     /** Optional — the router falls back to plain approvals when absent. */
     permit2?: Address;
 }
@@ -75,8 +77,15 @@ export declare function createLogswapClient(args: {
  * (`MINT_FEE_PROTOCOL_CUT` and `setFeeParams` are gone, decisions 058); the swap-fee tax at payout,
  * `swapFeeTax` / `setSwapFeeTax` (060); `phi` is `swapFee` and `phiOf` `swapFeeOf` (059) — field
  * names only, no pool id moved.
+ *
+ * **7** since 2026-10-12 (logswap-contract#60, decisions 064–065): the typed views (`getPool`,
+ * `ticks`, `tickBitmapWord`, `positions`, `feeAcct`, `idInfo`) are behind `extsload` — the pool
+ * reads through the lens's `getPools`, a class through `CPoolState`'s layout; a fee of 0 is no
+ * fee (`swapFeeOf` and `DEFAULT_FEE` are gone); the mint fee is the market's, proposed at
+ * `initialize` / `createMarket` and answered by the gate; the gate (`gate`, `setGate`) is the
+ * public policy, set at construction. No pool id moved.
  */
-export declare const EXPECTED_VERSION = 6n;
+export declare const EXPECTED_VERSION = 7n;
 /**
  * The F manager's own tag (5 — the key's salt, pool names, the sponsor registry;
  * 4 was the income-only harvest cut).
@@ -88,7 +97,7 @@ export declare const EXPECTED_VERSION = 6n;
  * passes it; when one lands, raise this constant in the same change, which is the discipline
  * `EXPECTED_VERSION` enforces mechanically and this one asks for.
  */
-export declare const EXPECTED_F_VERSION = 25n;
+export declare const EXPECTED_F_VERSION = 26n;
 export declare function assertVersion(c: LogswapClient, expected?: bigint): Promise<void>;
 /**
  * The versions say the managers are the right code; this says the rest of the addresses belong

package/dist/client.js

@@ -69,8 +69,15 @@ function guardChain(wallet, pub) {
  * (`MINT_FEE_PROTOCOL_CUT` and `setFeeParams` are gone, decisions 058); the swap-fee tax at payout,
  * `swapFeeTax` / `setSwapFeeTax` (060); `phi` is `swapFee` and `phiOf` `swapFeeOf` (059) — field
  * names only, no pool id moved.
+ *
+ * **7** since 2026-10-12 (logswap-contract#60, decisions 064–065): the typed views (`getPool`,
+ * `ticks`, `tickBitmapWord`, `positions`, `feeAcct`, `idInfo`) are behind `extsload` — the pool
+ * reads through the lens's `getPools`, a class through `CPoolState`'s layout; a fee of 0 is no
+ * fee (`swapFeeOf` and `DEFAULT_FEE` are gone); the mint fee is the market's, proposed at
+ * `initialize` / `createMarket` and answered by the gate; the gate (`gate`, `setGate`) is the
+ * public policy, set at construction. No pool id moved.
  */
-export const EXPECTED_VERSION = 6n;
+export const EXPECTED_VERSION = 7n;
 /**
  * The F manager's own tag (5 — the key's salt, pool names, the sponsor registry;
  * 4 was the income-only harvest cut).
@@ -147,8 +154,11 @@ export const EXPECTED_VERSION = 6n;
 // 25 (logswap-contract#59): the views moved behind `extsload` (062) — this SDK reads them through the
 // lens (`fPool`, `getFPools`, `fBundleOf`, `fDividendOf`, `fLienOf`); the capped F pool, `FPoolKey.cap`
 // appended so every pool id moved (061); the lien, `lock` / `unlock` (063); θ is `logFloor`, θ₀ `refLogFloor`.
+// 26 (logswap-contract#60): the mint fee is per pool, proposed at `initialize(key, mintFee)` and answered
+// by the policy's `onInitialize` from its menu (065); `MINT_FEE` is gone; a fee of 0 is no fee; the
+// policies curate creators, a public pool is uncapped, one pad per base (064). No pool id moved.
 // A breaking bump: raised in the same change.
-export const EXPECTED_F_VERSION = 25n;
+export const EXPECTED_F_VERSION = 26n;
 export async function assertVersion(c, expected = EXPECTED_VERSION) {
     const { cPoolManagerAbi, fPoolManagerAbi } = await import("./generated.js");
     // three independent reads: one round trip, not three in a row

package/dist/fees.d.ts

@@ -55,7 +55,8 @@ export declare function blockAtOrAfter(c: LogswapClient, t: bigint, lo: bigint,
 export declare function swapFees(c: LogswapClient, m: DiscoveredMarket, opts?: {
     since?: bigint;
     fromBlock?: bigint;
-    toBlock?: bigint;
+    toBlock?: bigint; /** The rindexer GraphQL endpoint: the Swap rows from there, the node otherwise. */
+    indexer?: string;
 }): Promise<SwapFeeWindow>;
 /**
  * The window's swap fees over the market's CURRENT active L, annualised linearly over the window.

package/dist/fees.js

@@ -11,6 +11,7 @@
  * Both equal φ·L·|Δx| summed over the swap's segments — the same φ·|dx| per unit L that `F` books.
  */
 import { cPoolManagerAbi } from "./generated.js";
+import { getEventLogs } from "./history.js";
 const WAD = 10n ** 18n;
 const YEAR_SECONDS = 31_536_000;
 /**
@@ -89,7 +90,7 @@ export async function swapFees(c, m, opts = {}) {
         throw new Error("logswap: Swap event missing from the generated ABI");
     const logs = fromBlock > toBlock
         ? []
-        : await c.public.getLogs({ address: c.addresses.cPoolManager, event: ev, args: { poolId: m.poolId }, fromBlock, toBlock });
+        : (await getEventLogs(c, { indexer: opts.indexer, address: c.addresses.cPoolManager, event: ev, args: { poolId: m.poolId }, fromBlock, toBlock })).logs;
     // the event carries the fee the swap charged (decisions 050), exactly — no re-derivation from φ
     let fees = 0n;
     for (const l of logs)