@logswap/sdk 0.5.73 → 0.5.75

package/dist/positions.js

@@ -5,18 +5,31 @@
  * (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";
+import { getEventLogs } from "./history.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 +142,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({
@@ -170,9 +192,9 @@ const ID_REGISTERED = parseAbiItem("event IdRegistered(uint256 indexed id, bytes
  * holder's slice is L · shares_owner / shares_class, and fees from the lens. One log query plus
  * a read per registered class; fine for a pool's lifetime of classes.
  */
-export async function holdingsOf(c, key, owner, fromBlock = 0n) {
+export async function holdingsOf(c, key, owner, fromBlock = 0n, opts = {}) {
     const pool = poolId(key);
-    const logs = await c.public.getLogs({ address: c.addresses.cPoolManager, event: ID_REGISTERED, args: { poolId: pool }, fromBlock, toBlock: "latest" });
+    const { logs } = await getEventLogs(c, { indexer: opts.indexer, address: c.addresses.cPoolManager, event: ID_REGISTERED, args: { poolId: pool }, fromBlock });
     const ids = logs.map((l) => l.args.id ?? 0n).filter((id) => id !== 0n);
     if (ids.length === 0)
         return [];

package/package.json

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

@@ -37,6 +37,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;
 }
@@ -113,8 +115,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 +200,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/fees.ts

@@ -14,6 +14,7 @@
 import type { LogswapClient } from "./client.js";
 import { cPoolManagerAbi } from "./generated.js";
 import type { DiscoveredMarket } from "./pools.js";
+import { getEventLogs } from "./history.js";
 
 const WAD = 10n ** 18n;
 const YEAR_SECONDS = 31_536_000;
@@ -85,7 +86,7 @@ export async function blockAtOrAfter(c: LogswapClient, t: bigint, lo: bigint, hi
 export async function swapFees(
   c: LogswapClient,
   m: DiscoveredMarket,
-  opts: { since?: bigint; fromBlock?: bigint; toBlock?: bigint } = {},
+  opts: { since?: bigint; fromBlock?: bigint; toBlock?: bigint; /** The rindexer GraphQL endpoint: the Swap rows from there, the node otherwise. */ indexer?: string } = {},
 ): Promise<SwapFeeWindow> {
   const toBlock = opts.toBlock ?? (await c.public.getBlockNumber());
   const [opened, last] = await Promise.all([
@@ -112,11 +113,11 @@ export async function swapFees(
 
   const logs = fromBlock > toBlock
     ? []
-    : await c.public.getLogs({ address: c.addresses.cPoolManager, event: ev, args: { poolId: m.poolId }, fromBlock, toBlock });
+    : (await getEventLogs<{ fee: bigint }>(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) fees += l.args.fee!;
+  for (const l of logs) fees += l.args.fee;
 
   const to = last.timestamp;
   return { fromBlock, toBlock, from, to, seconds: to > from ? to - from : 0n, swapFees: fees, swaps: logs.length };

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);
@@ -1140,19 +1150,13 @@ export async function fPoolIdOf(c: LogswapClient, a: Omit<FPoolCreateArgs, "acco
  * without naming one; a pad's carries its split, so it is rebuilt from the policy's record with nonce 0 — pass `opts.salt` for another nonce). The result is checked against the id, so a wrong salt throws rather than
  * returning a key that names another pool. What {@link fPoolMigrate} needs when handed an id.
  */
-export async function fPoolKeyOfPool(c: LogswapClient, poolId: Hex, opts: { salt?: Hex; fromBlock?: bigint } = {}): Promise<FPoolKey> {
+export async function fPoolKeyOfPool(c: LogswapClient, poolId: Hex, opts: { salt?: Hex; fromBlock?: bigint; /** The rindexer GraphQL endpoint: `FInitialize` from there, the node otherwise. The salt is in neither (the event does not carry it). */ indexer?: string } = {}): Promise<FPoolKey> {
   type Ev = Extract<(typeof fPoolManagerAbi)[number], { type: "event"; name: "FInitialize" }>;
   const ev = fPoolManagerAbi.find((x): x is Ev => x.type === "event" && x.name === "FInitialize")!;
-  const logs = await c.public.getLogs({
-    address: c.addresses.fPoolManager!,
-    event: ev,
-    args: { poolId },
-    fromBlock: opts.fromBlock ?? 0n,
-    toBlock: "latest",
-  });
+  const { logs } = await getEventLogs(c, { indexer: opts.indexer, address: c.addresses.fPoolManager!, event: ev as never, args: { poolId }, fromBlock: opts.fromBlock ?? 0n });
   const l = logs[0];
   if (!l) throw new Error(`logswap: no FInitialize for F pool ${poolId}`);
-  const a = l.args as { quote: Address; creator: Address; bases: readonly Address[]; weights: readonly bigint[]; swapFee: bigint; policy: Address; cap: number };
+  const a = l.args as unknown as { quote: Address; creator: Address; bases: readonly Address[]; weights: readonly bigint[]; swapFee: bigint; policy: Address; cap: number | bigint };
   const key: FPoolKey = {
     quote: a.quote,
     bases: [...a.bases],
@@ -1437,7 +1441,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.