@logswap/sdk 0.5.69 → 0.5.70

package/dist/admin.d.ts

@@ -7,7 +7,7 @@
  * One vocabulary: both managers call the protocol's cut of the mint fee
  * `MINT_FEE_PROTOCOL_CUT`; C sets it through `setFeeParams(uint256)`, F holds it as a constant
  * (049). The harvest's cut is the policy's answer at every harvest, set on the
- * policy (`setHarvestCut`) and capped by the manager (`HARVEST_CUT_MAX`); the release's
+ * policy (`PadPolicy.setSchedule`: the protocol's pot share and the ranges a creator chooses inside) and capped by the manager (`POT_CUT_MAX`, `BURN_MAX`; a harvest has no cut, decisions 056); the release's
  * protocol share likewise (`POT_CUT_MAX`).
  */
 import type { Address, Hash } from "viem";
@@ -89,17 +89,21 @@ export declare function fPoolMigrate(c: LogswapClient, a: {
  * answer. "" for a policy the registry never approved (or a deployment with no registry).
  */
 export declare function registryKindOf(c: LogswapClient, policy: Address): Promise<FPoolKind | "">;
-/** The protocol's rate on the income part of every harvest under `policy`, WAD ≤ `HARVEST_CUT_MAX`. */
-export declare function setHarvestCut(c: LogswapClient, policy: Address, rateWad: bigint): Promise<Hash>;
-/** `PadPolicy.setSchedule`: `T(0)`, the rung's growth, the creator's and the protocol's shares of the pot (≤ `POT_CUT_MAX`), the burn per rung (≤ `BURN_MAX`). The rung is the pool's generation since F version 21. */
+/**
+ * `PadPolicy.setSchedule` (decisions 056): `T(0)`, the rung's growth, the protocol's share of the pot (≤ `POT_CUT_MAX`,
+ * recorded into each pad at birth), and the RANGES a creator chooses inside at creation — his cut of the pot and the burn per
+ * rung (≤ `BURN_MAX`). A change applies to pads born after it. The rung is the pool's generation since F version 21.
+ */
 export declare function padSetSchedule(c: LogswapClient, policy: Address, s: {
     thresholdBase: bigint;
     thresholdGrowth: bigint;
-    creatorShare: bigint;
     protocolShare: bigint;
-    burnPerRung: bigint;
+    creatorShareMin: bigint;
+    creatorShareMax: bigint;
+    burnMin: bigint;
+    burnMax: bigint;
 }): Promise<Hash>;
-/** `PolPolicy.setRules`: what every harvest leaves in the bid and what a relaunch's seed must bring, WAD fractions of L. */
+/** `PolPolicy.setRules`: the reserve a harvest must leave in the bid (`may(Harvest)` refuses less) and what a relaunch's seed must bring, WAD fractions of the pool's L. */
 export declare function polSetRules(c: LogswapClient, policy: Address, s: {
     keepQuote: bigint;
     minQuoteAtSeed: bigint;

package/dist/admin.js

@@ -7,7 +7,7 @@
  * One vocabulary: both managers call the protocol's cut of the mint fee
  * `MINT_FEE_PROTOCOL_CUT`; C sets it through `setFeeParams(uint256)`, F holds it as a constant
  * (049). The harvest's cut is the policy's answer at every harvest, set on the
- * policy (`setHarvestCut`) and capped by the manager (`HARVEST_CUT_MAX`); the release's
+ * policy (`PadPolicy.setSchedule`: the protocol's pot share and the ranges a creator chooses inside) and capped by the manager (`POT_CUT_MAX`, `BURN_MAX`; a harvest has no cut, decisions 056); the release's
  * protocol share likewise (`POT_CUT_MAX`).
  */
 import { cPoolManagerAbi, fPoolManagerAbi, padPolicyAbi, polPolicyAbi, policyRegistryAbi, publicPolicyAbi } from "./generated.js";
@@ -140,15 +140,23 @@ export async function registryKindOf(c, policy) {
     return bytes32ToText(word);
 }
 // ─── the policies' numbers (the collector's; each bounded where it reaches the manager) ─────
-/** The protocol's rate on the income part of every harvest under `policy`, WAD ≤ `HARVEST_CUT_MAX`. */
-export async function setHarvestCut(c, policy, rateWad) {
-    return write(c, policy, fPolicyBaseAbi, "setHarvestCut", [rateWad]);
-}
-/** `PadPolicy.setSchedule`: `T(0)`, the rung's growth, the creator's and the protocol's shares of the pot (≤ `POT_CUT_MAX`), the burn per rung (≤ `BURN_MAX`). The rung is the pool's generation since F version 21. */
+/**
+ * `PadPolicy.setSchedule` (decisions 056): `T(0)`, the rung's growth, the protocol's share of the pot (≤ `POT_CUT_MAX`,
+ * recorded into each pad at birth), and the RANGES a creator chooses inside at creation — his cut of the pot and the burn per
+ * rung (≤ `BURN_MAX`). A change applies to pads born after it. The rung is the pool's generation since F version 21.
+ */
 export async function padSetSchedule(c, policy, s) {
-    return write(c, policy, padPolicyAbi, "setSchedule", [s.thresholdBase, s.thresholdGrowth, s.creatorShare, s.protocolShare, s.burnPerRung]);
+    return write(c, policy, padPolicyAbi, "setSchedule", [
+        s.thresholdBase,
+        s.thresholdGrowth,
+        s.protocolShare,
+        s.creatorShareMin,
+        s.creatorShareMax,
+        s.burnMin,
+        s.burnMax,
+    ]);
 }
-/** `PolPolicy.setRules`: what every harvest leaves in the bid and what a relaunch's seed must bring, WAD fractions of L. */
+/** `PolPolicy.setRules`: the reserve a harvest must leave in the bid (`may(Harvest)` refuses less) and what a relaunch's seed must bring, WAD fractions of the pool's L. */
 export async function polSetRules(c, policy, s) {
     return write(c, policy, polPolicyAbi, "setRules", [s.keepQuote, s.minQuoteAtSeed]);
 }

package/dist/client.d.ts

@@ -83,7 +83,7 @@ export declare const EXPECTED_VERSION = 5n;
  * 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 = 21n;
+export declare const EXPECTED_F_VERSION = 23n;
 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

@@ -133,7 +133,9 @@ export const EXPECTED_VERSION = 5n;
 // (the bid: `getPool().Q` when L > 0), `idOf(FPoolKey)` (hashed locally, `fPoolIdOfKey`) and
 // `reserveOf` (`legOf`'s fourth word). `PadPolicy.rung` is gone: the pad's rung is `gen`, the
 // next threshold `threshold(gen)`. A pad never retires; a public pool refuses `regenerate`.
-export const EXPECTED_F_VERSION = 21n;
+// 23: a harvest asks `may(Harvest)` and takes no terms and no cut (decisions 056): `onHarvest`, `HARVEST_CUT_MAX`,
+// `harvestCut`, `setHarvestCut` are gone; a pad's split (creator's cut, token burn) rides in the key's salt.
+export const EXPECTED_F_VERSION = 23n;
 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

@@ -40,8 +40,8 @@ import { fPoolManagerAbi, padPolicyAbi, polPolicyAbi, privatePolicyAbi, publicPo
  */
 export { fPoolManagerAbi, padPolicyAbi, polPolicyAbi, privatePolicyAbi, publicPolicyAbi };
 /**
- * What every protocol policy shares (`FPolicyBase`): the roles and their handover, `harvestCut`,
- * `maxHarvest`. `polPolicyAbi` is a superset of it and carries nothing that collides, so it stands
+ * What every protocol policy shares (`FPolicyBase`): the roles and their handover and the
+ * `maxHarvest` readout (a harvest has no cut, decisions 056). `polPolicyAbi` is a superset of it and carries nothing that collides, so it stands
  * in for the base — a call through it to any of the four policies decodes the base's functions.
  */
 export declare const fPolicyBaseAbi: readonly [{
@@ -90,16 +90,6 @@ export declare const fPolicyBaseAbi: readonly [{
         readonly type: "address";
     }];
     readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly inputs: readonly [];
-    readonly name: "harvestCut";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly inputs: readonly [];
@@ -219,61 +209,6 @@ export declare const fPolicyBaseAbi: readonly [{
         readonly type: "bytes32";
     }];
     readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly inputs: readonly [{
-        readonly name: "a";
-        readonly internalType: "struct IFPolicy.Ask";
-        readonly type: "tuple";
-        readonly components: readonly [{
-            readonly name: "poolId";
-            readonly internalType: "bytes32";
-            readonly type: "bytes32";
-        }, {
-            readonly name: "gen";
-            readonly internalType: "uint256";
-            readonly type: "uint256";
-        }, {
-            readonly name: "action";
-            readonly internalType: "enum IFPolicy.Action";
-            readonly type: "uint8";
-        }, {
-            readonly name: "who";
-            readonly internalType: "address";
-            readonly type: "address";
-        }, {
-            readonly name: "amount";
-            readonly internalType: "uint256";
-            readonly type: "uint256";
-        }, {
-            readonly name: "income";
-            readonly internalType: "uint256";
-            readonly type: "uint256";
-        }, {
-            readonly name: "Q";
-            readonly internalType: "uint256";
-            readonly type: "uint256";
-        }, {
-            readonly name: "L";
-            readonly internalType: "uint256";
-            readonly type: "uint256";
-        }, {
-            readonly name: "n";
-            readonly internalType: "uint256";
-            readonly type: "uint256";
-        }];
-    }];
-    readonly name: "onHarvest";
-    readonly outputs: readonly [{
-        readonly name: "amount";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-    }, {
-        readonly name: "cut";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -475,16 +410,6 @@ export declare const fPolicyBaseAbi: readonly [{
         readonly type: "bool";
     }];
     readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly inputs: readonly [{
-        readonly name: "_harvestCut";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-    }];
-    readonly name: "setHarvestCut";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -577,16 +502,6 @@ export declare const fPolicyBaseAbi: readonly [{
         readonly indexed: true;
     }];
     readonly name: "AuthoritySet";
-}, {
-    readonly type: "event";
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly name: "harvestCut";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-        readonly indexed: false;
-    }];
-    readonly name: "HarvestCutSet";
 }, {
     readonly type: "event";
     readonly anonymous: false;
@@ -1150,7 +1065,7 @@ export declare function fPoolIdOf(c: LogswapClient, a: Omit<FPoolCreateArgs, "ac
 /**
  * Rebuild a live pool's KEY from its id: the `FInitialize` log carries every field but the salt,
  * which is taken from `opts.salt` (zero by default — every pool the SDK's create flow makes
- * without naming one). The result is checked against the id, so a wrong salt throws rather than
+ * 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 declare function fPoolKeyOfPool(c: LogswapClient, poolId: Hex, opts?: {
@@ -1578,7 +1493,6 @@ export interface FPoolControlled {
 /** What a pool's policy says about it, by kind: the terms a buyer reads before entering. */
 export type FPoolRules = {
     kind: "pad";
-    harvestCut: bigint;
     /** The pad's graduation count: the pool's generation (F version 21 — `PadPolicy.rung` is gone). */
     gen: number;
     /** @deprecated Equal to {@link gen} since F version 21, kept for callers; read `gen`. */
@@ -1586,25 +1500,50 @@ 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. */
     creatorShare: bigint;
     protocolShare: bigint;
     burnPerRung: bigint;
+    /** The ranges the collector's policy holds NOW for the pads born after this read: what a new creator may choose. */
+    ranges: PadRanges;
 } | {
     kind: "pol";
-    harvestCut: bigint;
     keepQuote: bigint;
     minQuoteAtSeed: bigint;
 } | {
     kind: "public";
-    harvestCut: bigint;
     curated: boolean;
 } | {
     kind: "private";
-    harvestCut: bigint;
     gateMint: boolean;
     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. */
+export interface PadRanges {
+    /** The protocol's share of the pot, recorded into each pad at birth. */
+    protocolShare: bigint;
+    creatorShareMin: bigint;
+    creatorShareMax: bigint;
+    burnMin: bigint;
+    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
+ * 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;
+    nonce?: bigint;
+}): Hex;
+/** The inverse of {@link padSalt}. */
+export declare function padSplitOfSalt(salt: Hex): {
+    creatorShare: bigint;
+    burnPerRung: bigint;
+    nonce: bigint;
+};
 /** The policy's terms for one pool, by its kind. */
 export declare function getFPoolRules(c: LogswapClient, s: Pick<FPoolState, "poolId" | "policy" | "kind" | "gen">, roles?: FPoolRoles): Promise<FPoolRules>;
 /**
@@ -1629,8 +1568,7 @@ export declare function fPoolShareHolders(c: LogswapClient, poolIdHex: Hex, opts
     shares: bigint;
 }>>;
 /**
- * What a policy answers `onRegenerate` with (and `onHarvest`'s split, the first four words):
- * `IFPolicy.Terms`. `carried` is F version 21's fifth word — the holder the next generation
+ * What a policy answers `onRegenerate` with: `IFPolicy.Terms`. `carried` is F version 21's fifth word — the holder the next generation
  * carries beside the dead shares; the reply is exactly 160 bytes.
  */
 export interface FPolicyTerms {

package/dist/fpool.js

@@ -40,8 +40,8 @@ import { fPoolManagerAbi, logswapRouterAbi, padPolicyAbi, polPolicyAbi, policyRe
  */
 export { fPoolManagerAbi, padPolicyAbi, polPolicyAbi, privatePolicyAbi, publicPolicyAbi };
 /**
- * What every protocol policy shares (`FPolicyBase`): the roles and their handover, `harvestCut`,
- * `maxHarvest`. `polPolicyAbi` is a superset of it and carries nothing that collides, so it stands
+ * What every protocol policy shares (`FPolicyBase`): the roles and their handover and the
+ * `maxHarvest` readout (a harvest has no cut, decisions 056). `polPolicyAbi` is a superset of it and carries nothing that collides, so it stands
  * in for the base — a call through it to any of the four policies decodes the base's functions.
  */
 export const fPolicyBaseAbi = polPolicyAbi;
@@ -733,7 +733,7 @@ export async function fPoolIdOf(c, a) {
 /**
  * Rebuild a live pool's KEY from its id: the `FInitialize` log carries every field but the salt,
  * which is taken from `opts.salt` (zero by default — every pool the SDK's create flow makes
- * without naming one). The result is checked against the id, so a wrong salt throws rather than
+ * 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, poolId, opts = {}) {
@@ -758,6 +758,18 @@ export async function fPoolKeyOfPool(c, poolId, opts = {}) {
         creator: a.creator,
         salt: opts.salt ?? ZERO_SALT,
     };
+    if (fPoolIdOfKey(key).toLowerCase() !== poolId.toLowerCase() && opts.salt === undefined) {
+        // a pad's salt carries its split (decisions 056): rebuild it from the policy's record with the default nonce
+        try {
+            const [creatorShare, burnPerRung] = (await c.public.readContract({ address: a.policy, abi: padPolicyAbi, functionName: "splitOf", args: [poolId] }));
+            const padKey = { ...key, salt: padSalt({ creatorShare, burnPerRung }) };
+            if (fPoolIdOfKey(padKey).toLowerCase() === poolId.toLowerCase())
+                return padKey;
+        }
+        catch {
+            /* not a pad: fall through to the error */
+        }
+    }
     if (fPoolIdOfKey(key).toLowerCase() !== poolId.toLowerCase()) {
         throw new Error(`logswap: F pool ${poolId} was not born with salt ${key.salt} — pass its salt, or its whole key`);
     }
@@ -1256,34 +1268,58 @@ export async function discoverFPools(c, opts = {}) {
         };
     }));
 }
+const MAX_U64 = (1n << 64n) - 1n;
+const MAX_U128 = (1n << 128n) - 1n;
+/**
+ * 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
+ * identity, so it is chosen at launch (`FPoolLaunchArgs.salt`) and never changes; the policy refuses a split outside its ranges.
+ */
+export function padSalt(s) {
+    const nonce = s.nonce ?? 0n;
+    if (s.creatorShare < 0n || s.creatorShare > MAX_U64 || s.burnPerRung < 0n || s.burnPerRung > MAX_U64)
+        throw new Error("logswap: a pad's split is a WAD fraction that fits 64 bits");
+    if (nonce < 0n || nonce > MAX_U128)
+        throw new Error("logswap: a pad salt's nonce fits 128 bits");
+    return `0x${((s.creatorShare << 192n) | (s.burnPerRung << 128n) | nonce).toString(16).padStart(64, "0")}`;
+}
+/** The inverse of {@link padSalt}. */
+export function padSplitOfSalt(salt) {
+    const v = BigInt(salt);
+    return { creatorShare: v >> 192n, burnPerRung: (v >> 128n) & MAX_U64, nonce: v & MAX_U128 };
+}
 /** The policy's terms for one pool, by its kind. */
 export async function getFPoolRules(c, s, roles) {
     const rd = (abi, functionName, args = []) => c.public.readContract({ address: s.policy, abi, functionName, args });
-    const harvestCut = await rd(fPolicyBaseAbi, "harvestCut");
     switch (s.kind) {
         case "pad": {
             // the rung is the manager's generation (F version 21): a move carries it, nothing to ask the policy
             const gen = s.gen;
-            const [creatorShare, protocolShare, burnPerRung, pot, threshold] = await Promise.all([
-                rd(padPolicyAbi, "creatorShare"),
-                rd(padPolicyAbi, "protocolShare"),
-                rd(padPolicyAbi, "burnPerRung"),
+            const [split, pot, threshold, protocolNow, creatorShareMin, creatorShareMax, burnMin, burnMax] = await Promise.all([
+                rd(padPolicyAbi, "splitOf", [s.poolId]),
                 fPoolDividendOf(c, s.poolId, DEAD_ADDRESS, gen),
                 rd(padPolicyAbi, "threshold", [BigInt(gen)]),
+                rd(padPolicyAbi, "protocolShare"),
+                rd(padPolicyAbi, "creatorShareMin"),
+                rd(padPolicyAbi, "creatorShareMax"),
+                rd(padPolicyAbi, "burnMin"),
+                rd(padPolicyAbi, "burnMax"),
             ]);
-            return { kind: "pad", harvestCut, gen, rung: gen, threshold, pot, creatorShare, protocolShare, burnPerRung };
+            const [creatorShare, burnPerRung, protocolShare] = split;
+            const ranges = { protocolShare: protocolNow, creatorShareMin, creatorShareMax, burnMin, burnMax };
+            return { kind: "pad", gen, rung: gen, threshold, pot, creatorShare, protocolShare, burnPerRung, ranges };
         }
         case "pol": {
             const [keepQuote, minQuoteAtSeed] = await Promise.all([rd(polPolicyAbi, "keepQuote"), rd(polPolicyAbi, "minQuoteAtSeed")]);
-            return { kind: "pol", harvestCut, keepQuote, minQuoteAtSeed };
+            return { kind: "pol", keepQuote, minQuoteAtSeed };
         }
         case "public": {
             const curated = await rd(publicPolicyAbi, "curated");
-            return { kind: "public", harvestCut, curated };
+            return { kind: "public", curated };
         }
         case "private": {
             const r = roles ?? (await getFPoolRoles(c, s.poolId, s));
-            return { kind: "private", harvestCut, gateMint: r.gateMint, gateSwap: r.gateSwap, operator: fPoolOperatorOf(r) };
+            return { kind: "private", gateMint: r.gateMint, gateSwap: r.gateSwap, operator: fPoolOperatorOf(r) };
         }
     }
 }