@logswap/sdk 0.5.73 → 0.5.74

package/dist/indexer.js

@@ -204,12 +204,7 @@ export async function poolPositionsFromChain(c, key, x) {
             functionName: "idOf",
             args: [key, floor],
         }));
-        const [L, shares] = (await c.public.readContract({
-            address: c.addresses.cPoolManager,
-            abi: cPoolManagerAbi,
-            functionName: "positions",
-            args: [id],
-        }));
+        const { L, shares } = await getPositionClass(c, id); // through extsload (C version 7)
         if (L === 0n)
             return null;
         return { id, poolId: pool, floor, cap: NO_CAP, capped: false, L, shares, active: x >= floor };

package/dist/keys.d.ts

@@ -13,7 +13,9 @@
 import { type Address, type Hex } from "viem";
 /**
  * The fee domain of the family, `FeeParams.FEE_MIN` / `FEE_MAX` (decisions 043): one bound for a
- * C market's φ and an F pool's alike, WAD. 1 bp and 1%. The F manager no longer answers
+ * C market's φ and an F pool's alike, WAD. 1 bp and 1% — plus 0, which since C version 7 / F
+ * version 26 is a fee-free market or pool, admitted only if the policy lists it (decisions 065).
+ * The mint fee lives in the same domain. The F manager no longer answers
  * `FEE_MIN()` / `FEE_MAX()` (F version 21 cut the getters for bytecode); every F policy still
  * checks φ against these at `onInitialize`, and the C side re-exposes them through the lens's
  * `cParams()`. Constants here, so a create form bounds φ with no read.
@@ -31,7 +33,8 @@ export interface PoolKey {
     tickSpacing: bigint;
     /**
      * The swap fee, WAD, fixed for the life of the market: {@link FEE_MIN} (1 bp) ≤ φ ≤ {@link FEE_MAX} (1%),
-     * or `0n`, which selects `DEFAULT_FEE` (2 bp) at read time. Four fields since C version 4
+     * or `0n`, which since C version 7 is NO fee (decisions 065; `DEFAULT_FEE` is gone). The gate
+     * admits only its listed tiers (064: 2, 5, 10, 25, 50, 100 bp). Four fields since C version 4
      *: `kappa` and `alpha` left with the variance kernel, and `phiMin` — a floor with
      * nothing above it — became `phi`, named `swapFee` since C version 6 (decisions 059). The name
      * is not part of the encoding: no pool id changed with it.
@@ -41,10 +44,9 @@ export interface PoolKey {
 /**
  * `poolId = keccak256(abi.encode(key))` — the primary key of the entire read model.
  *
- * Note the zero-vs-default caveat the Solidity type documents: a `swapFee` of `0` resolves to
- * `DEFAULT_FEE` at READ time, so a key carrying `0n` and one carrying the resolved default are
- * DIFFERENT markets with different ids, even though they behave identically. Always address a
- * market by the key it was initialized with.
+ * A key's `swapFee` is the market's fee as written — `0n` is a fee-free market since C version 7
+ * (decisions 065), not the 2 bp default it selected before. Always address a market by the key it
+ * was initialized with.
  */
 export declare function poolId(key: PoolKey): Hex;
 /** Structural equality of two keys — i.e. "the same market". */

package/dist/keys.js

@@ -13,7 +13,9 @@
 import { encodeAbiParameters, keccak256 } from "viem";
 /**
  * The fee domain of the family, `FeeParams.FEE_MIN` / `FEE_MAX` (decisions 043): one bound for a
- * C market's φ and an F pool's alike, WAD. 1 bp and 1%. The F manager no longer answers
+ * C market's φ and an F pool's alike, WAD. 1 bp and 1% — plus 0, which since C version 7 / F
+ * version 26 is a fee-free market or pool, admitted only if the policy lists it (decisions 065).
+ * The mint fee lives in the same domain. The F manager no longer answers
  * `FEE_MIN()` / `FEE_MAX()` (F version 21 cut the getters for bytecode); every F policy still
  * checks φ against these at `onInitialize`, and the C side re-exposes them through the lens's
  * `cParams()`. Constants here, so a create form bounds φ with no read.
@@ -34,10 +36,9 @@ const POOL_KEY_ABI = [
 /**
  * `poolId = keccak256(abi.encode(key))` — the primary key of the entire read model.
  *
- * Note the zero-vs-default caveat the Solidity type documents: a `swapFee` of `0` resolves to
- * `DEFAULT_FEE` at READ time, so a key carrying `0n` and one carrying the resolved default are
- * DIFFERENT markets with different ids, even though they behave identically. Always address a
- * market by the key it was initialized with.
+ * A key's `swapFee` is the market's fee as written — `0n` is a fee-free market since C version 7
+ * (decisions 065), not the 2 bp default it selected before. Always address a market by the key it
+ * was initialized with.
  */
 export function poolId(key) {
     return keccak256(encodeAbiParameters(POOL_KEY_ABI, [

package/dist/liquidity.d.ts

@@ -61,13 +61,20 @@ export interface CreateMarketArgs extends WriteOptions {
     targetFloor: bigint;
     /** The founding exposure; must exceed the manager's `minBackstopL` lock. */
     L: bigint;
+    /**
+     * The market's mint fee, WAD of newly-earning L — the creator's pick from the gate's menu
+     * (decisions 065). Defaults to {@link presetMintFee}: twice the swap fee, capped at `FEE_MAX`.
+     */
+    mintFee?: bigint;
     /** Required, as on {@link mint}. Creation is atomic at `x0`, so the flows are fixed by the arguments; {@link UNBOUNDED} is safe here only for that reason. */
     maxBaseIn: bigint;
     maxQuoteIn: bigint;
 }
 /**
  * Create a market ATOMICALLY: `initialize` at `x0` plus the backstop-establishing first mint in
- * one transaction — the canonical creation path. The
+ * one transaction — the canonical creation path. Under the C gate (064) the router is a trusted
+ * forwarder: the gate checks the router's `user()` — the wallet sending this — against the
+ * creator list, so a listed creator opens and funds a market in this one call. 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

package/dist/liquidity.js

@@ -23,7 +23,7 @@
  */
 import { logswapLensAbi, logswapRouterAbi } from "./generated.js";
 import { NO_CAP } from "./ids.js";
-import { describeId, getPositionClass } from "./positions.js";
+import { describeId, getPositionClass, presetMintFee } from "./positions.js";
 import { execute, OPEN_DELTA, settleInKind, settleOnly, swapExactInAction, swapExactOutAction, updateAction, } from "./actions.js";
 import { requireWallet, resolveDeadline, resolveRecipient, sendRouterWrite, sendRouterWriteWithPermits, withSlippage, } from "./write.js";
 import { quoteExactIn, quoteExactOut } from "./swap.js";
@@ -55,7 +55,9 @@ 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. The
+ * one transaction — the canonical creation path. Under the C gate (064) the router is a trusted
+ * forwarder: the gate checks the router's `user()` — the wallet sending this — against the
+ * creator list, so a listed creator opens and funds a market in this one call. 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
@@ -68,6 +70,7 @@ export async function createMarket(c, a) {
         args: [
             a.key,
             a.x0,
+            a.mintFee ?? presetMintFee(a.key.swapFee),
             a.targetFloor,
             a.L,
             a.maxBaseIn,

package/dist/pools.d.ts

@@ -14,7 +14,10 @@
 import { type Address, type Hex } from "viem";
 import type { LogswapClient } from "./client.js";
 import { type PoolKey } from "./keys.js";
-/** The manager's `getPool` view, decoded. Field-for-field with `PoolView` in the contract. */
+/**
+ * A market's scalar state, field-for-field with `CPoolState.PoolView` — what the manager's `getPool`
+ * returned before C version 7 moved it behind `extsload` (decisions 065); read through the lens.
+ */
 export interface PoolState {
     initialized: boolean;
     backstopSeeded: boolean;
@@ -32,14 +35,16 @@ export interface PoolState {
     protocolOwed: bigint;
     minBackstopL: bigint;
     backstopFloor: bigint;
+    /** The market's mint fee, WAD of newly-earning L: proposed at birth, the gate's answer (065). */
+    mintFee: bigint;
 }
-/** Read a market's full state by key. */
+/** Read a market's full state by key, through the lens (`getPools`; C version 7). All zero, `initialized` false, for a market nobody opened. */
 export declare function getPool(c: LogswapClient, key: PoolKey): Promise<PoolState>;
 /**
- * The market's swap fee: the key's `swapFee` with `0n` resolved to `DEFAULT_FEE` — the manager's
- * `swapFeeOf` (`phiOf` before C version 6). Constant for the market's 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. (`swapFeeOf` in `fees.ts` is the fee one swap paid.)
+ * The market's swap fee — the key's own `swapFee` since C version 7: a fee of 0 is no fee, and
+ * `DEFAULT_FEE` / the manager's `swapFeeOf` are gone (decisions 065). Constant for the market's
+ * life. Still a read: it refuses a key nobody initialized, which `discoverMarkets` relies on to
+ * drop a stale indexer's rows. (`swapFeeOf` in `fees.ts` is the fee one swap paid.)
  */
 export declare function marketSwapFee(c: LogswapClient, key: PoolKey): Promise<bigint>;
 /**
@@ -203,12 +208,15 @@ export declare function annualise(perUnitL: bigint, elapsedSeconds: bigint): num
 /** When a market was created, as a unix timestamp — the denominator for {@link annualise}. */
 export declare function marketOpenedAt(c: LogswapClient, m: DiscoveredMarket): Promise<bigint>;
 /**
- * Create a C market: `initialize(key, x0)` on the manager — a call, not a deployment. Manager-
- * direct by design: creation moves no funds, so the router adds nothing. The pool id is
- * `poolId(key)` (pure) and the market is tradeable immediately; the first mint funds it.
+ * Create a C market: `initialize(key, x0, mintFee)` on the manager — a call, not a deployment, and
+ * no funds move. The mint fee is the creator's pick from the gate's menu (065), preset at twice the
+ * swap fee ({@link presetMintFee}). Under a curated gate the CALLER must be a listed creator; the
+ * canonical path is the router's {@link createMarket}, which forwards its user to the gate and
+ * mints the backstop in the same transaction (064).
  */
 export declare function initializeMarket(c: LogswapClient, a: {
     key: PoolKey;
     x0: bigint;
+    mintFee?: bigint;
     account: Address;
 }): Promise<`0x${string}`>;

package/dist/pools.js

@@ -16,29 +16,28 @@ import { logswapLensAbi, cPoolManagerAbi } from "./generated.js";
 import { signerFor } from "./write.js";
 import { readCachedToken, registerCacheClear, writeCachedToken } from "./tokencache.js";
 import { poolId } from "./keys.js";
-/** Read a market's full state by key. */
+import { presetMintFee } from "./positions.js";
+/** Read a market's full state by key, through the lens (`getPools`; C version 7). All zero, `initialized` false, for a market nobody opened. */
 export async function getPool(c, key) {
-    const v = await c.public.readContract({
-        address: c.addresses.cPoolManager,
-        abi: cPoolManagerAbi,
-        functionName: "getPool",
-        args: [poolId(key)],
-    });
-    return v;
+    const v = (await c.public.readContract({
+        address: c.addresses.lens,
+        abi: logswapLensAbi,
+        functionName: "getPools",
+        args: [[poolId(key)]],
+    }));
+    return v[0];
 }
 /**
- * The market's swap fee: the key's `swapFee` with `0n` resolved to `DEFAULT_FEE` — the manager's
- * `swapFeeOf` (`phiOf` before C version 6). Constant for the market's 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. (`swapFeeOf` in `fees.ts` is the fee one swap paid.)
+ * The market's swap fee — the key's own `swapFee` since C version 7: a fee of 0 is no fee, and
+ * `DEFAULT_FEE` / the manager's `swapFeeOf` are gone (decisions 065). Constant for the market's
+ * life. Still a read: it refuses a key nobody initialized, which `discoverMarkets` relies on to
+ * drop a stale indexer's rows. (`swapFeeOf` in `fees.ts` is the fee one swap paid.)
  */
 export async function marketSwapFee(c, key) {
-    return c.public.readContract({
-        address: c.addresses.cPoolManager,
-        abi: cPoolManagerAbi,
-        functionName: "swapFeeOf",
-        args: [key],
-    });
+    const s = await getPool(c, key);
+    if (!s.initialized)
+        throw new Error(`logswap: market ${poolId(key)} is not initialized`);
+    return key.swapFee;
 }
 /**
  * Price from the stored log-price. **Lossy** — `x` is exact and this is a float, so use it for
@@ -332,16 +331,18 @@ export async function marketOpenedAt(c, m) {
     return b.timestamp;
 }
 /**
- * Create a C market: `initialize(key, x0)` on the manager — a call, not a deployment. Manager-
- * direct by design: creation moves no funds, so the router adds nothing. The pool id is
- * `poolId(key)` (pure) and the market is tradeable immediately; the first mint funds it.
+ * Create a C market: `initialize(key, x0, mintFee)` on the manager — a call, not a deployment, and
+ * no funds move. The mint fee is the creator's pick from the gate's menu (065), preset at twice the
+ * swap fee ({@link presetMintFee}). Under a curated gate the CALLER must be a listed creator; the
+ * canonical path is the router's {@link createMarket}, which forwards its user to the gate and
+ * mints the backstop in the same transaction (064).
  */
 export async function initializeMarket(c, a) {
     const { request } = await c.public.simulateContract({
         address: c.addresses.cPoolManager,
         abi: cPoolManagerAbi,
         functionName: "initialize",
-        args: [a.key, a.x0],
+        args: [a.key, a.x0, a.mintFee ?? presetMintFee(a.key.swapFee)],
         account: signerFor(c, a.account),
     });
     return c.wallet.writeContract(request);

package/dist/positions.d.ts

@@ -19,6 +19,12 @@ export interface PositionClass {
     /** Snapshot of `F_above[floor] − F_above[cap]` at the class's last touch. */
     insideLast: bigint;
 }
+/**
+ * A class's aggregate state, read through `extsload` (C version 7: the manager's public
+ * `positions` mapping is gone behind it, decisions 065). The slot is `CPoolState`'s:
+ * `keccak256(abi.encode(id, POSITIONS_SLOT = 4))`, two words — (L | shares << 128) and
+ * (aps | insideLast << 128). Pinned on chain by the integration suite.
+ */
 export declare function getPositionClass(c: LogswapClient, id: bigint): Promise<PositionClass>;
 /** A holder's share balance in a class. */
 export declare function balanceOf(c: LogswapClient, owner: Address, id: bigint): Promise<bigint>;
@@ -103,17 +109,23 @@ export declare function positionQuote(p: {
     cap: bigint;
     capped: boolean;
 }, x: bigint): bigint;
-/** The manager's `MINT_FEE`: 2 bp of newly-earning L, as a WAD fraction. */
-export declare const MINT_FEE: bigint;
+/**
+ * The mint fee a create form presets: twice the swap fee, capped at {@link FEE_MAX} (decisions 064
+ * (f): guidance, not a contract rule). The creator picks from the gate's or the policy's menu
+ * (065); a listed entry is what the chain accepts — read it with `policyMintFeeMenu`.
+ */
+export declare function presetMintFee(swapFee: bigint): bigint;
 /**
  * The one-time mint fee at log-price `x`, in quote units — the amount `_mintCore` pulls ON TOP of
- * the position's own legs, so a mint's total quote pull is `positionQuote(p, x) + mintFee(p, x)`.
+ * the position's own legs, so a mint's total quote pull is `positionQuote(p, x) + mintFee(p, x, rate)`.
+ * `rate` is the MARKET's mint fee (`getPool(...).mintFee`, WAD of L): per market since C version 7,
+ * the gate's answer at birth (065); there is no global `MINT_FEE` any more.
  *
  * Mirrors the manager's exemption cases: a DORMANT mint pays nothing — floor above spot, or a
- * capped class spot has already passed (`cap <= x`). Anything earning pays `MINT_FEE · L`, all of
- * it the protocol's since C version 6 (decisions 058); with no collector it goes through `F` to the
- * LPs already earning, and with none earning it is not charged. This is NOT the swap fee:
- * that one is charged per unit of |Δ log p| on swaps; this is a flat charge on L, once, at mint.
+ * capped class spot has already passed (`cap <= x`). Anything earning pays `rate · L`, all of it
+ * the protocol's (decisions 058); with no collector it goes through `F` to the LPs already
+ * earning, and with none earning it is not charged. This is NOT the swap fee: that one is charged
+ * per unit of |Δ log p| on swaps; this is a flat charge on L, once, at mint.
  *
  * One rung of imprecision: for a floor or cap exactly AT spot the contract consults its `currentK`
  * pointer (an up-move counts the tick, a down-move does not), which this offline mirror cannot see.
@@ -124,7 +136,7 @@ export declare function mintFee(p: {
     floor: bigint;
     cap: bigint;
     capped: boolean;
-}, x: bigint): bigint;
+}, x: bigint, rate: bigint): bigint;
 /**
  * Every UNCAPPED position `owner` holds in a market, enumerated fully on-chain by the lens — a
  * bitmap walk plus a balance check per live floor. No indexer, no log scan. Capped classes are

package/dist/positions.js

@@ -5,18 +5,30 @@
  * (pool, floor, cap). Holders own ERC-6909 shares of a class; fees are tracked per holder, so two
  * accounts holding the same class can have different claimable amounts.
  */
-import { parseAbiItem } from "viem";
+import { encodeAbiParameters, keccak256, parseAbiItem } from "viem";
 import { logswapLensAbi, cPoolManagerAbi } from "./generated.js";
-import { poolId } from "./keys.js";
+import { FEE_MAX, poolId } from "./keys.js";
+/** `CPoolState.POSITIONS_SLOT`: the manager's `positions` mapping (`forge inspect CPoolManager storageLayout`). */
+const C_POSITIONS_SLOT = 4n;
+const U128 = (1n << 128n) - 1n;
 import { isPosition, NO_CAP, positionId, unpackFloorCap } from "./ids.js";
+/**
+ * A class's aggregate state, read through `extsload` (C version 7: the manager's public
+ * `positions` mapping is gone behind it, decisions 065). The slot is `CPoolState`'s:
+ * `keccak256(abi.encode(id, POSITIONS_SLOT = 4))`, two words — (L | shares << 128) and
+ * (aps | insideLast << 128). Pinned on chain by the integration suite.
+ */
 export async function getPositionClass(c, id) {
-    const r = (await c.public.readContract({
+    const slot = keccak256(encodeAbiParameters([{ type: "uint256" }, { type: "uint256" }], [id, C_POSITIONS_SLOT]));
+    const w = (await c.public.readContract({
         address: c.addresses.cPoolManager,
         abi: cPoolManagerAbi,
-        functionName: "positions",
-        args: [id],
+        functionName: "extsload",
+        args: [slot, 2n],
     }));
-    return { L: r[0], shares: r[1], aps: r[2], insideLast: r[3] };
+    const w0 = BigInt(w[0]), w1 = BigInt(w[1]);
+    const hi = w1 >> 128n;
+    return { L: w0 & U128, shares: w0 >> 128n, aps: w1 & U128, insideLast: hi >= 1n << 127n ? hi - (1n << 128n) : hi };
 }
 /** A holder's share balance in a class. */
 export async function balanceOf(c, owner, id) {
@@ -129,26 +141,35 @@ export function positionQuote(p, x) {
     const upper = p.capped && p.cap <= x ? p.cap : x;
     return (p.L * (upper - p.floor)) / 10n ** 18n;
 }
-/** The manager's `MINT_FEE`: 2 bp of newly-earning L, as a WAD fraction. */
-export const MINT_FEE = 2n * 10n ** 14n;
+/**
+ * The mint fee a create form presets: twice the swap fee, capped at {@link FEE_MAX} (decisions 064
+ * (f): guidance, not a contract rule). The creator picks from the gate's or the policy's menu
+ * (065); a listed entry is what the chain accepts — read it with `policyMintFeeMenu`.
+ */
+export function presetMintFee(swapFee) {
+    const m = 2n * swapFee;
+    return m > FEE_MAX ? FEE_MAX : m;
+}
 /**
  * The one-time mint fee at log-price `x`, in quote units — the amount `_mintCore` pulls ON TOP of
- * the position's own legs, so a mint's total quote pull is `positionQuote(p, x) + mintFee(p, x)`.
+ * the position's own legs, so a mint's total quote pull is `positionQuote(p, x) + mintFee(p, x, rate)`.
+ * `rate` is the MARKET's mint fee (`getPool(...).mintFee`, WAD of L): per market since C version 7,
+ * the gate's answer at birth (065); there is no global `MINT_FEE` any more.
  *
  * Mirrors the manager's exemption cases: a DORMANT mint pays nothing — floor above spot, or a
- * capped class spot has already passed (`cap <= x`). Anything earning pays `MINT_FEE · L`, all of
- * it the protocol's since C version 6 (decisions 058); with no collector it goes through `F` to the
- * LPs already earning, and with none earning it is not charged. This is NOT the swap fee:
- * that one is charged per unit of |Δ log p| on swaps; this is a flat charge on L, once, at mint.
+ * capped class spot has already passed (`cap <= x`). Anything earning pays `rate · L`, all of it
+ * the protocol's (decisions 058); with no collector it goes through `F` to the LPs already
+ * earning, and with none earning it is not charged. This is NOT the swap fee: that one is charged
+ * per unit of |Δ log p| on swaps; this is a flat charge on L, once, at mint.
  *
  * One rung of imprecision: for a floor or cap exactly AT spot the contract consults its `currentK`
  * pointer (an up-move counts the tick, a down-move does not), which this offline mirror cannot see.
  * Preview with it; let the chain be authoritative on that boundary.
  */
-export function mintFee(p, x) {
+export function mintFee(p, x, rate) {
     if (p.floor > x || (p.capped && p.cap <= x))
         return 0n;
-    return (p.L * MINT_FEE) / 10n ** 18n;
+    return (p.L * rate) / 10n ** 18n;
 }
 export async function positionsOf(c, key, owner) {
     const rows = (await c.public.readContract({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logswap/sdk",
-  "version": "0.5.73",
+  "version": "0.5.74",
   "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",

package/src/admin.ts

@@ -9,7 +9,8 @@
  * is the policy's (`PadPolicy.setSchedule`), capped by the manager at `POT_CUT_MAX`.
  */
 
-import type { Address, Hash } from "viem";
+import type { Address, Hash, Hex } from "viem";
+import type { PoolKey } from "./keys.js";
 import type { LogswapClient } from "./client.js";
 import { cPoolManagerAbi, fPoolManagerAbi, padPolicyAbi, polPolicyAbi, policyRegistryAbi, publicPolicyAbi } from "./generated.js";
 import { bytes32ToText, fPolicyBaseAbi, fPoolKeyOfPool, fPoolKindOfPolicy, textToBytes32, type FPoolKey, type FPoolKind } from "./fpool.js";
@@ -258,6 +259,127 @@ export async function policyFeeAllowed(c: LogswapClient, policy: Address, fee: b
   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: LogswapClient, policy: Address, mintFee: bigint, listed: boolean): Promise<Hash> {
+  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: LogswapClient, policy: Address, curated: boolean): Promise<Hash> {
+  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: LogswapClient, policy: Address, candidates: readonly bigint[]): Promise<{ curated: boolean; listed: bigint[] }> {
+  const rd = (functionName: string, args: readonly unknown[] = []) =>
+    c.public.readContract({ address: policy, abi: fPolicyBaseAbi, functionName, args } as never) as Promise<boolean>;
+  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: LogswapClient, policy: Address, who: Address, listed: boolean): Promise<Hash> {
+  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: LogswapClient, policy: Address, curated: boolean): Promise<Hash> {
+  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: LogswapClient, policy: Address, base: Address, quote: Address, listed: boolean): Promise<Hash> {
+  return write(c, policy, publicPolicyAbi, "setPairListed", [base, quote, listed]);
+}
+
+/** `PublicPolicy.setPairCurated` (064). */
+export async function gateSetPairCurated(c: LogswapClient, policy: Address, curated: boolean): Promise<Hash> {
+  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: LogswapClient, policy: Address, tickSpacing: bigint, listed: boolean): Promise<Hash> {
+  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: LogswapClient, policy: Address, forwarder: Address, trusted: boolean): Promise<Hash> {
+  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: LogswapClient, gate: Address): Promise<Hash> {
+  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: LogswapClient): Promise<Address> {
+  return c.public.readContract({ address: c.addresses.cPoolManager, abi: cPoolManagerAbi, functionName: "gate" } as never) as 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 async function cGateRules(c: LogswapClient, a: { key: PoolKey; creator: Address; router?: Address; gate?: Address }): Promise<CGateRules> {
+  const g = a.gate ?? (c.addresses.publicPolicy as Address);
+  const rd = <T>(functionName: string, args: readonly unknown[] = []) =>
+    c.public.readContract({ address: g, abi: publicPolicyAbi, functionName, args } as never) as Promise<T>;
+  const { key } = a;
+  const [creatorCurated, creatorListed, quoteCurated, quoteListed, pairCurated, pairListed, feeCurated, feeListed, spacingListed, market, routerTrusted] =
+    await Promise.all([
+      rd<boolean>("creatorCurated"),
+      rd<boolean>("creatorListed", [a.creator]),
+      rd<boolean>("quoteCurated"),
+      rd<boolean>("quoteListed", [key.quote]),
+      rd<boolean>("pairCurated"),
+      rd<boolean>("pairListed", [key.base, key.quote]),
+      rd<boolean>("feeCurated"),
+      rd<boolean>("feeListed", [key.swapFee]),
+      rd<boolean>("spacingListed", [key.tickSpacing]),
+      rd<Hex>("cMarketOf", [key.base, key.quote, key.swapFee]),
+      rd<boolean>("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"),
+] as const;
+
 /** `PublicPolicy.setListed`: an asset a curated seed may hold. */
 export async function publicSetListed(c: LogswapClient, policy: Address, token: Address, listed: boolean): Promise<Hash> {
   return write(c, policy, publicPolicyAbi, "setListed", [token, listed]);

package/src/client.ts

@@ -113,8 +113,15 @@ function guardChain(wallet: WalletClient, pub: PublicClient): WalletClient {
  * (`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).
@@ -191,8 +198,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: LogswapClient, expected = EXPECTED_VERSION): Promise<void> {
   const { cPoolManagerAbi, fPoolManagerAbi } = await import("./generated.js");

package/src/fpool.ts

@@ -50,6 +50,7 @@ export const fPolicyBaseAbi = polPolicyAbi;
 import type { LogswapClient } from "./client.js";
 import { fallBackUnlessRejected, signerFor } from "./write.js";
 import { getEventLogs } from "./history.js";
+import { presetMintFee } from "./positions.js";
 
 const WAD = 10n ** 18n;
 const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000" as const;
@@ -72,8 +73,10 @@ export interface FPoolState {
   Q: bigint;
   /** Total exposure. Grows on mint, shrinks on burn; never moves on a swap. */
   L: bigint;
-  /** The swap fee, WAD (`phi` before F version 25, decisions 059). At or above `FEE_MIN` — a zero-fee basket is not constructible. */
+  /** The swap fee, WAD (`phi` before F version 25, decisions 059). 0 is no fee (F version 26, decisions 065), admitted only if the policy lists it. */
   swapFee: bigint;
+  /** The pool's mint fee, WAD of newly-minted L: proposed at birth, the policy's answer from its menu (F version 26, decisions 065). */
+  mintFee: bigint;
   /** θ₀, the reference log floor: where the floor stood at the seed (re-based by a capital harvest and at each step); income is counted from it. `theta0` before F version 25. */
   refLogFloor: bigint;
   /** θ = X − Q/L, the log of the pool's current floor price: where the bid runs out. Derived, never stored. `theta` before F version 25. */
@@ -163,6 +166,7 @@ export async function getFPool(c: LogswapClient, poolId: Hex): Promise<FPoolStat
     Q: p.Q,
     L: p.L,
     swapFee: p.swapFee,
+    mintFee: p.mintFee,
     refLogFloor: p.refLogFloor,
     logFloor: v.logFloor,
     compositeX: v.compositeX,
@@ -996,6 +1000,12 @@ export interface FPoolCreateArgs {
   weights: bigint[];
   /** The swap fee, WAD (`phi` before F version 25). The base-for-base fee is pinned at 2φ on-chain. A curated policy admits only its listed tiers (decisions 059). */
   swapFee: bigint;
+  /**
+   * The pool's mint fee, WAD of newly-minted L — the creator's pick from the policy's menu (F version
+   * 26, decisions 065; a curated menu refuses anything else with `MintFeeNotListed`). Defaults to
+   * {@link presetMintFee}: twice the swap fee, capped at `FEE_MAX`.
+   */
+  mintFee?: bigint;
   /**
    * The common cap (decisions 061): d = ln(cap price / floor price) in 1e-6 log units, a key field;
    * 0 or absent is uncapped. From a leverage λ: {@link fPoolCapOfLeverage}.
@@ -1119,7 +1129,7 @@ export async function fPoolInitialize(c: LogswapClient, a: FPoolCreateArgs) {
     address: c.addresses.fPoolManager!,
     abi: fPoolManagerAbi,
     functionName: "initialize",
-    args: [key],
+    args: [key, a.mintFee ?? presetMintFee(a.swapFee)],
     account: wallet.account,
   } as never);
   return c.wallet!.writeContract(request as never);
@@ -1437,7 +1447,7 @@ export function fPoolLaunchCalls(
   const enc = (functionName: string, args: unknown[]) =>
     encodeFunctionData({ abi: fPoolManagerAbi, functionName, args } as never) as Hex;
   const calls: Hex[] = [];
-  if (!a.initialized) calls.push(enc("initialize", [key]));
+  if (!a.initialized) calls.push(enc("initialize", [key, a.mintFee ?? presetMintFee(a.swapFee)]));
   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.