@logswap/sdk 0.5.73 → 0.5.74

package/README.md

@@ -44,6 +44,31 @@ 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`.
+
 ## 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

@@ -75,8 +75,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 +95,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/fpool.d.ts

@@ -90,6 +90,30 @@ export declare const fPolicyBaseAbi: readonly [{
         readonly type: "address";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "creatorCurated";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly name: "creatorListed";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly inputs: readonly [];
@@ -219,6 +243,30 @@ export declare const fPolicyBaseAbi: readonly [{
         readonly type: "uint256";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "mintFeeCurated";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "mintFeeListed";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -276,12 +324,20 @@ export declare const fPolicyBaseAbi: readonly [{
             readonly internalType: "uint24";
             readonly type: "uint24";
         }];
+    }, {
+        readonly name: "mintFee";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
     }];
     readonly name: "onInitialize";
     readonly outputs: readonly [{
         readonly name: "";
         readonly internalType: "uint8";
         readonly type: "uint8";
+    }, {
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
     }];
     readonly stateMutability: "nonpayable";
 }, {
@@ -438,6 +494,30 @@ export declare const fPolicyBaseAbi: readonly [{
         readonly type: "bool";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "curated";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly name: "setCreatorCurated";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "who";
+        readonly internalType: "address";
+        readonly type: "address";
+    }, {
+        readonly name: "listed";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly name: "setCreatorListed";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -462,6 +542,30 @@ export declare const fPolicyBaseAbi: readonly [{
     readonly name: "setFeeListed";
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "curated";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly name: "setMintFeeCurated";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "mintFee";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        readonly name: "listed";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly name: "setMintFeeListed";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -554,6 +658,31 @@ export declare const fPolicyBaseAbi: readonly [{
         readonly indexed: true;
     }];
     readonly name: "AuthoritySet";
+}, {
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "curated";
+        readonly internalType: "bool";
+        readonly type: "bool";
+        readonly indexed: false;
+    }];
+    readonly name: "CreatorCuratedSet";
+}, {
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "creator";
+        readonly internalType: "address";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "listed";
+        readonly internalType: "bool";
+        readonly type: "bool";
+        readonly indexed: false;
+    }];
+    readonly name: "CreatorListed";
 }, {
     readonly type: "event";
     readonly anonymous: false;
@@ -579,6 +708,31 @@ export declare const fPolicyBaseAbi: readonly [{
         readonly indexed: false;
     }];
     readonly name: "FeeListed";
+}, {
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "curated";
+        readonly internalType: "bool";
+        readonly type: "bool";
+        readonly indexed: false;
+    }];
+    readonly name: "MintFeeCuratedSet";
+}, {
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "mintFee";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+        readonly indexed: true;
+    }, {
+        readonly name: "listed";
+        readonly internalType: "bool";
+        readonly type: "bool";
+        readonly indexed: false;
+    }];
+    readonly name: "MintFeeListed";
 }, {
     readonly type: "event";
     readonly anonymous: false;
@@ -642,6 +796,14 @@ export declare const fPolicyBaseAbi: readonly [{
     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 [{
@@ -650,6 +812,14 @@ export declare const fPolicyBaseAbi: readonly [{
         readonly type: "uint256";
     }];
     readonly name: "FeeNotListed";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "mintFee";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "MintFeeNotListed";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
@@ -709,8 +879,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. */
@@ -1154,6 +1326,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}.