@logswap/sdk 0.5.70 → 0.5.72

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: "feeCurated";
+    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: "feeListed";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly inputs: readonly [];
@@ -232,7 +256,7 @@ export declare const fPolicyBaseAbi: readonly [{
             readonly internalType: "uint256[]";
             readonly type: "uint256[]";
         }, {
-            readonly name: "phi";
+            readonly name: "swapFee";
             readonly internalType: "uint256";
             readonly type: "uint256";
         }, {
@@ -247,6 +271,10 @@ export declare const fPolicyBaseAbi: readonly [{
             readonly name: "salt";
             readonly internalType: "bytes32";
             readonly type: "bytes32";
+        }, {
+            readonly name: "cap";
+            readonly internalType: "uint24";
+            readonly type: "uint24";
         }];
     }];
     readonly name: "onInitialize";
@@ -410,6 +438,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: "setFeeCurated";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "fee";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        readonly name: "listed";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly name: "setFeeListed";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -502,6 +554,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: "FeeCuratedSet";
+}, {
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "fee";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+        readonly indexed: true;
+    }, {
+        readonly name: "listed";
+        readonly internalType: "bool";
+        readonly type: "bool";
+        readonly indexed: false;
+    }];
+    readonly name: "FeeListed";
 }, {
     readonly type: "event";
     readonly anonymous: false;
@@ -565,6 +642,14 @@ export declare const fPolicyBaseAbi: readonly [{
     readonly type: "error";
     readonly inputs: readonly [];
     readonly name: "BadRate";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "fee";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "FeeNotListed";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
@@ -624,14 +709,21 @@ export interface FPoolState {
     Q: bigint;
     /** Total exposure. Grows on mint, shrinks on burn; never moves on a swap. */
     L: bigint;
-    /** Fixed fee, WAD. At or above `FEE_MIN` — a zero-fee basket is not constructible. */
-    phi: bigint;
-    /** The strike: θ at seeding, and the fees-only harvest bound. */
-    theta0: bigint;
-    /** θ = X − Q/L, the shared floor. Derived from the holdings, never stored. */
-    theta: bigint;
+    /** The swap fee, WAD (`phi` before F version 25, decisions 059). At or above `FEE_MIN` — a zero-fee basket is not constructible. */
+    swapFee: 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. */
+    logFloor: bigint;
     /** X = Σ w_j x_j, the composite index. */
     compositeX: bigint;
+    /** This generation's income still in the pool, quote: L·(θ₀ − θ). */
+    unharvested: bigint;
+    /**
+     * The common cap (decisions 061): d = ln(cap price / floor price) in 1e-6 log units, from the key;
+     * 0 is uncapped. Leverage at the floor is 1/(1 − e^{−d}): {@link fPoolLeverageOfCap}.
+     */
+    cap: number;
     /** Σ = ∫ Σ_j w_j (dx_j)², accrued even though the fee is fixed — the kernel stays calculable. */
     bigSigma: bigint;
     /**
@@ -662,8 +754,12 @@ export interface FPoolState {
     totalSupply: bigint;
     /** What the pool holds of each base — the STATE; the mark `x` is derived from it. */
     reserves: bigint[];
+    /** The reserve every price reads: `reserves[j] + L_j·κ_j` on a capped pool (061), `reserves[j]` otherwise. */
+    virtualReserves: bigint[];
+    /** κ_j = e^{−μ_j}, WAD: each leg's phantom reserve per unit of its liquidity. 0 uncapped. */
+    kappa: bigint[];
 }
-/** Read a basket pool whole. Batched — viem multicalls these when the transport allows. */
+/** Read a basket pool whole: one lens call (`fPool`, F version 25) plus the policy's kind and name. */
 export declare function getFPool(c: LogswapClient, poolId: Hex): Promise<FPoolState>;
 /**
  * The kind of pool — the POLICY's self-description (the manager knows no kind; the
@@ -739,7 +835,11 @@ export interface FPoolDescription {
 export declare function describeFPool(c: LogswapClient, s: FPoolState): Promise<FPoolDescription>;
 /** `p_j = e^{x_j}`, lossy the way any float conversion is. Compare in log space when it matters. */
 export declare function fPoolPriceOf(x: bigint, scale?: number): number;
-/** Value per share at the pool's own marks. `V = L + Q`, so this is just that, pro-rated. */
+/**
+ * Value per share at the pool's own marks, WAD. Uncapped, `V = L + Q`. Capped (decisions 061), leg
+ * j's base is worth `L_j·R_j/R̃_j`, less than `L_j` by the phantom the cap removed — the lens's
+ * `shareValue`, without the call.
+ */
 export declare function fPoolShareValue(s: FPoolState): bigint;
 export interface FPoolSwapArgs {
     poolId: Hex;
@@ -916,8 +1016,65 @@ export declare function fPoolClaim(c: LogswapClient, a: {
     to?: Address;
     account: Address;
 }): Promise<`0x${string}`>;
-/** A holder's dividend as of now on generation `gen` (the live one by default) — banked plus pending on the current balance. */
+/**
+ * A holder's claimable dividend as of now on generation `gen` (the live one by default) — banked
+ * plus pending on the current balance; under a lien, the free fraction's only: the locked
+ * fraction's is the lien's ({@link fPoolLienOf}, decisions 063).
+ */
 export declare function fPoolDividendOf(c: LogswapClient, poolId: Hex, holder: Address, gen?: bigint | number): Promise<bigint>;
+/** A lien on one share id: the locker, the amount locked, and the dividend the lien holds (banked). */
+export interface FPoolLien {
+    locker: Address;
+    amount: bigint;
+    owed: bigint;
+}
+/**
+ * The lien on `owner`'s shares of `poolId`'s generation `gen` (the live one by default). `owed` counts
+ * what has been banked into it; the locked fraction of the owner's pending since its last bank is
+ * not yet in it — {@link fPoolBankLien} banks it.
+ */
+export declare function fPoolLienOf(c: LogswapClient, poolId: Hex, owner: Address, gen?: bigint | number): Promise<FPoolLien>;
+/**
+ * Lock `amount` of `owner`'s shares for the caller, the locker (`account`). Paid with the owner's
+ * per-id allowance to the locker — the owner first sends `approve(locker, shareId, amount)` on the
+ * F manager ({@link fPoolApproveShares}) — or an operator grant. One locker per (id, owner) while a
+ * lien stands. In practice the lending contract calls `lock` itself; this is the EOA path.
+ */
+export declare function fPoolLock(c: LogswapClient, a: {
+    poolId: Hex;
+    owner: Address;
+    amount: bigint;
+    gen?: bigint | number;
+    account: Address;
+}): Promise<`0x${string}`>;
+/**
+ * The locker's `unlock`: `amount` of the lien lifted with its share of the lien's dividend, credited
+ * to `to` — the owner (a release) or anyone else (a seizure, the shares moving to `to`). It banks
+ * first. The locker's alone.
+ */
+export declare function fPoolUnlock(c: LogswapClient, a: {
+    poolId: Hex;
+    owner: Address;
+    amount: bigint;
+    to: Address;
+    gen?: bigint | number;
+    account: Address;
+}): Promise<`0x${string}`>;
+/** Bank the owner's pending into the lien now — `unlock(id, owner, 0, owner)`: dividends bank lazily. The locker's. */
+export declare function fPoolBankLien(c: LogswapClient, a: {
+    poolId: Hex;
+    owner: Address;
+    gen?: bigint | number;
+    account: Address;
+}): Promise<`0x${string}`>;
+/** The owner's per-id allowance to a locker on the F manager's ERC-6909 shares — what `lock` spends. */
+export declare function fPoolApproveShares(c: LogswapClient, a: {
+    poolId: Hex;
+    spender: Address;
+    amount: bigint;
+    gen?: bigint | number;
+    account: Address;
+}): Promise<`0x${string}`>;
 /** Plain ERC-20 approval to the F manager — the allowance every DIRECT call pulls against. */
 export declare function approveTokenForFPoolManager(c: LogswapClient, token: Address): Promise<Hash>;
 /** Does `owner` have enough allowance on `token` for the MANAGER to pull `need`? */
@@ -995,8 +1152,13 @@ export interface FPoolCreateArgs {
     bases: Address[];
     /** WAD each; must sum to 1e18 — validated here so the revert is readable. */
     weights: bigint[];
-    /** Fixed fee, WAD. The base-for-base fee is pinned at 2φ on-chain. */
-    phi: 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 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}.
+     */
+    cap?: number;
     /**
      * Which of the protocol's four the pool is — see {@link FPoolKind}. NOT a key field (decisions
      * 049: the manager knows no kind): it selects the deployment's policy of that kind when `policy`
@@ -1040,11 +1202,13 @@ export interface FPoolKey {
     bases: Address[];
     /** WAD, aligned with `bases`, summing to 1e18. */
     weights: bigint[];
-    phi: bigint;
+    swapFee: bigint;
     /** The policy AT BIRTH — not the live one after a move. */
     policy: Address;
     creator: Address;
     salt: Hex;
+    /** The common cap, d in 1e-6 log units; 0 uncapped (decisions 061). Appended in F version 25: every pool id moved. */
+    cap: number;
 }
 /**
  * An F pool's id: `keccak256(abi.encode(key))`, offline — what `initialize` computes inline. The
@@ -1079,7 +1243,17 @@ export declare function fPoolKeyOfPool(c: LogswapClient, poolId: Hex, opts?: {
  * precision (~1e-16 relative) is what a seed needs: any reserve is a legal seed, and the mark
  * the pool derives from it is the one the sponsor meant to within that.
  */
-export declare function fPoolReserveAt(Lj: bigint, x: bigint): bigint;
+export declare function fPoolReserveAt(Lj: bigint, x: bigint, k?: number): bigint;
+/**
+ * The seed's cap constant k = e^{Q0/L0 − d} (decisions 061): every leg's phantom is c_j = r_j·k/(1 − k).
+ * 0 on an uncapped pool. Throws when the seed would be priced at or above its cap (Q0/L0 ≥ d), which
+ * the manager refuses.
+ */
+export declare function fPoolCapK(cap: number, Q0: bigint, L0: bigint): number;
+/** The cap d (1e-6 log units) for a leverage λ > 1 at the floor: d = ln(λ/(λ − 1)) (decisions 061). λ = 2 puts the cap at twice the floor. */
+export declare function fPoolCapOfLeverage(lambda: number): number;
+/** The leverage at the floor λ = 1/(1 − e^{−d}) for a cap d in 1e-6 log units; Infinity is impossible, 1 is uncapped. */
+export declare function fPoolLeverageOfCap(cap: number): number;
 /**
  * Arm the pool: deposit `r0[j]` of each base plus `Q0` of quote against exposure `L0`. Pass either
  * the reserves outright (`r0`) or the marks the pool should open at (`x0`, converted here with
@@ -1141,8 +1315,9 @@ export declare function fPoolEmptyingHarvests(c: LogswapClient, poolId: Hex): Pr
  *   and redeems it with {@link fPoolRedeem} / rolls it with {@link fPoolRollIn} (`gen: g`); their
  *   dividends on `g` stay claimable ({@link fPoolClaim} with `gen: g`). {@link fPoolClaimsOf}
  *   lists them;
- * - the pot: `toPayee` to the payee, `protocolCut` to the collector, the rest bought in as dead
- *   shares of `g + 1`; then the burn.
+ * - the pot, all in quote (decisions 057): `toPayee` to the payee, `protocolCut` to the collector,
+ *   `burn` spent buying base at the curve and burning it (the price up, the floor held), and the
+ *   rest into the bid (the floor down). No share is minted; L does not move.
  *
  * A pad's gate is `threshold(gen)` (`PadPolicy.NotGraduated` below it); POL and private carry the
  * authority and send it the whole pot; a public pool refuses (`Refused`). A carried holder with no
@@ -1450,7 +1625,9 @@ export interface DiscoveredFPool {
     quote: Address;
     bases: Address[];
     weights: bigint[];
-    phi: bigint;
+    swapFee: bigint;
+    /** The common cap, d in 1e-6 log units; 0 uncapped (decisions 061). */
+    cap: number;
     kind: FPoolKind;
     /** The pool's policy AT BIRTH — the contract the key names. The LIVE one is {@link getFPool}'s `policy`: the registry's owner may have moved the pool (046, `PolicyMigrated`). */
     policy: Address;
@@ -1473,7 +1650,7 @@ export interface DiscoveredFPool {
 /**
  * Every F pool ever created, from `Initialize` logs alone — plus one `kind()` read per distinct
  * policy, cached. Possible only because the event carries the full key preimage (bases,
- * weights, phi, policy) — the poolId is a hash and could never be inverted; contracts PR #17
+ * weights, swapFee, policy, cap) — the poolId is a hash and could never be inverted; contracts PR #17
  * exists for exactly this call. With `indexer`, the logs come from it (the node when it fails):
  * a scan from block 0 per call is what made the first load wait on the node.
  */
@@ -1500,10 +1677,10 @@ export type FPoolRules = {
     /** The pot the next graduation needs: `PadPolicy.threshold(gen)`. */
     threshold: bigint;
     pot: bigint;
-    /** This pad's split, recorded at its birth from the key's salt and never changed (decisions 056): the creator's cut of the pot, the protocol's, and the burn per rung. The rest of the pot is bought in. */
+    /** This pad's split, recorded at its birth from the key's salt and never changed (decisions 056, 057): the creator's cut of the pot, the protocol's, and the burn — all fractions of the pot. The rest deepens the bid. */
     creatorShare: bigint;
     protocolShare: bigint;
-    burnPerRung: bigint;
+    burnShare: bigint;
     /** The ranges the collector's policy holds NOW for the pads born after this read: what a new creator may choose. */
     ranges: PadRanges;
 } | {
@@ -1519,7 +1696,7 @@ export type FPoolRules = {
     gateSwap: boolean;
     operator: Address;
 };
-/** The collector's ranges on a pad's creator choices (`PadPolicy`, decisions 056), WAD fractions: of the pot, and of every reserve per rung. */
+/** The collector's ranges on a pad's creator choices (`PadPolicy`, decisions 056, 057), WAD fractions of the pot. */
 export interface PadRanges {
     /** The protocol's share of the pot, recorded into each pad at birth. */
     protocolShare: bigint;
@@ -1529,19 +1706,19 @@ export interface PadRanges {
     burnMax: bigint;
 }
 /**
- * The salt that carries a pad's split (`PadPolicy.pack`, decisions 056): `creatorShare` in the top 64 bits, `burnPerRung` in
- * the next 64 (WAD fractions), a nonce in the low 128 that tells two otherwise identical pads apart. It is part of the pool's
+ * The salt that carries a pad's split (`PadPolicy.pack`, decisions 056, 057): `creatorShare` in the top 64 bits, `burnShare` in
+ * the next 64 (WAD fractions of the pot), a nonce in the low 128 that tells two otherwise identical pads apart. It is part of the pool's
  * identity, so it is chosen at launch (`FPoolLaunchArgs.salt`) and never changes; the policy refuses a split outside its ranges.
  */
 export declare function padSalt(s: {
     creatorShare: bigint;
-    burnPerRung: bigint;
+    burnShare: bigint;
     nonce?: bigint;
 }): Hex;
 /** The inverse of {@link padSalt}. */
 export declare function padSplitOfSalt(salt: Hex): {
     creatorShare: bigint;
-    burnPerRung: bigint;
+    burnShare: bigint;
     nonce: bigint;
 };
 /** The policy's terms for one pool, by its kind. */
@@ -1558,11 +1735,14 @@ export declare function fPoolsControlledBy(c: LogswapClient, who: Address, opts?
 /**
  * Every holder of a pool's shares, from the ERC-6909 Transfer stream — the id is an indexed
  * topic, so one filtered log query aggregates the whole ledger. The 0xdead entry is the
- * MIN_SHARES lock from seeding; callers usually label rather than hide it.
+ * MIN_SHARES lock from seeding; callers usually label rather than hide it. Pass `indexer`: a node
+ * prunes its logs (anvil keeps about a day), and a ledger rebuilt from a pruned stream loses every
+ * holder minted before the cut.
  */
 export declare function fPoolShareHolders(c: LogswapClient, poolIdHex: Hex, opts?: {
     fromBlock?: bigint;
     gen?: bigint | number;
+    indexer?: string;
 }): Promise<Array<{
     holder: Address;
     shares: bigint;
@@ -1578,7 +1758,7 @@ export interface FPolicyTerms {
     burn: bigint;
     carried: Address;
 }
-/** Every F pool's state in one lens call (the raw manager struct: quote, phi, authority, kind, seeded, gen, n, Q, L, shares, theta0, bigSigma, harvestedTheta). */
+/** Every F pool's raw state in one lens call (the manager's `Pool` struct: quote, swapFee, policy, seeded, gen, n, restructureBlock, asks, cap, Q, bigSigma, L, shares, refLogFloor). */
 export declare function getFPoolsRaw(c: LogswapClient, poolIds: Hex[]): Promise<readonly unknown[]>;
 /** Share value from the lens — (L + Q)/shares, WAD per share — the same figure as `fPoolShareValue`, from one source. */
 export declare function shareValueOnChain(c: LogswapClient, poolId: Hex): Promise<bigint>;