@logswap/sdk 0.5.73 → 0.5.74

package/src/indexer.ts

@@ -258,12 +258,7 @@ export async function poolPositionsFromChain(c: LogswapClient, key: PoolKey, x:
         functionName: "idOf",
         args: [key, floor],
       } as never)) as bigint;
-      const [L, shares] = (await c.public.readContract({
-        address: c.addresses.cPoolManager,
-        abi: cPoolManagerAbi,
-        functionName: "positions",
-        args: [id],
-      } as never)) as readonly [bigint, bigint, bigint, bigint];
+      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 } as PoolPosition;
     }),

package/src/keys.ts

@@ -15,7 +15,9 @@ import { encodeAbiParameters, keccak256, 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.
@@ -34,7 +36,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.
@@ -57,10 +60,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: PoolKey): Hex {
   return keccak256(

package/src/liquidity.ts

@@ -27,7 +27,7 @@ import { logswapLensAbi, logswapRouterAbi } from "./generated.js";
 import type { LogswapClient } from "./client.js";
 import type { PoolKey } from "./keys.js";
 import { NO_CAP } from "./ids.js";
-import { describeId, getPositionClass } from "./positions.js";
+import { describeId, getPositionClass, presetMintFee } from "./positions.js";
 import {
   execute,
   OPEN_DELTA,
@@ -105,6 +105,11 @@ 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;
@@ -112,7 +117,9 @@ export interface CreateMarketArgs extends WriteOptions {
 
 /**
  * Create a market ATOMICALLY: `initialize` at `x0` plus the backstop-establishing first mint in
- * one transaction — the canonical creation path. 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
@@ -125,6 +132,7 @@ export async function createMarket(c: LogswapClient, a: CreateMarketArgs): Promi
     args: [
       a.key,
       a.x0,
+      a.mintFee ?? presetMintFee(a.key.swapFee),
       a.targetFloor,
       a.L,
       a.maxBaseIn,

package/src/pools.ts

@@ -18,8 +18,12 @@ import type { LogswapClient } from "./client.js";
 import { signerFor } from "./write.js";
 import { readCachedToken, registerCacheClear, writeCachedToken } from "./tokencache.js";
 import { poolId, type PoolKey } from "./keys.js";
+import { presetMintFee } from "./positions.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;
@@ -37,32 +41,31 @@ 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 async function getPool(c: LogswapClient, key: PoolKey): Promise<PoolState> {
-  const v = await c.public.readContract({
-    address: c.addresses.cPoolManager,
-    abi: cPoolManagerAbi,
-    functionName: "getPool",
-    args: [poolId(key)],
-  });
-  return v as unknown as PoolState;
+  const v = (await c.public.readContract({
+    address: c.addresses.lens,
+    abi: logswapLensAbi,
+    functionName: "getPools",
+    args: [[poolId(key)]],
+  })) as readonly unknown[];
+  return v[0] as 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 async function marketSwapFee(c: LogswapClient, key: PoolKey): Promise<bigint> {
-  return c.public.readContract({
-    address: c.addresses.cPoolManager,
-    abi: cPoolManagerAbi,
-    functionName: "swapFeeOf",
-    args: [key],
-  }) as Promise<bigint>;
+  const s = await getPool(c, key);
+  if (!s.initialized) throw new Error(`logswap: market ${poolId(key)} is not initialized`);
+  return key.swapFee;
 }
 
 /**
@@ -417,16 +420,18 @@ export async function marketOpenedAt(c: LogswapClient, m: DiscoveredMarket): Pro
 }
 
 /**
- * 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: LogswapClient, a: { key: PoolKey; x0: bigint; account: Address }) {
+export async function initializeMarket(c: LogswapClient, a: { key: PoolKey; x0: bigint; mintFee?: bigint; account: Address }) {
   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),
   } as never);
   return c.wallet!.writeContract(request as never);

package/src/positions.ts

@@ -6,11 +6,15 @@
  * accounts holding the same class can have different claimable amounts.
  */
 
-import { parseAbiItem } from "viem";
-import type { Address } from "viem";
+import { encodeAbiParameters, keccak256, parseAbiItem } from "viem";
+import type { Address, Hex } from "viem";
 import { logswapLensAbi, cPoolManagerAbi } from "./generated.js";
 import type { LogswapClient } from "./client.js";
-import { poolId, type PoolKey } from "./keys.js";
+import { FEE_MAX, poolId, type PoolKey } 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 — the whole class, not one holder's slice. */
@@ -25,14 +29,23 @@ export interface PositionClass {
   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 async function getPositionClass(c: LogswapClient, id: bigint): Promise<PositionClass> {
-  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],
-  })) as readonly [bigint, bigint, bigint, bigint];
-  return { L: r[0], shares: r[1], aps: r[2], insideLast: r[3] };
+    functionName: "extsload",
+    args: [slot, 2n],
+  } as never)) as readonly Hex[];
+  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. */
@@ -183,18 +196,27 @@ export function positionQuote(
   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: bigint): bigint {
+  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.
@@ -203,9 +225,10 @@ export const MINT_FEE = 2n * 10n ** 14n;
 export function mintFee(
   p: { L: bigint; floor: bigint; cap: bigint; capped: boolean },
   x: bigint,
+  rate: bigint,
 ): bigint {
   if (p.floor > x || (p.capped && p.cap <= x)) return 0n;
-  return (p.L * MINT_FEE) / 10n ** 18n;
+  return (p.L * rate) / 10n ** 18n;
 }
 
 /**