@logswap/sdk 0.5.68 → 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?: {
@@ -1273,6 +1188,27 @@ export declare function fPoolRelaunch(c: LogswapClient, a: {
 export declare const DEAD_ADDRESS: Address;
 /** The manager's `MIN_SHARES`: the seed mints this much to 0xdead on every pool, the rest to the seeder — or, on a pad, to 0xdead too. */
 export declare const F_MIN_SHARES = 1000n;
+/**
+ * One genesis transaction: a swap the creator sends right after the seed, inside the launch's
+ * `multicall`. A `buy` spends `amountIn` of quote for leg `j` (an index into `bases` AS GIVEN); a
+ * `sell` spends `amountIn` of that leg for quote. The creator pays and is paid — the manager settles
+ * to its sender — so a `recipient` is paid by an ERC-20 transfer of the row's output
+ * ({@link fPoolGenesisTransfers}); without one the output stays with the creator.
+ */
+export interface FPoolGenesisRow {
+    side: "buy" | "sell";
+    j: number;
+    amountIn: bigint;
+    /** Defaults to 0. With a `recipient`, {@link fPoolLaunch} pins it to the simulated output, which is what the transfer pays. */
+    minOut?: bigint;
+    recipient?: Address;
+}
+/** An ERC-20 transfer owed to a genesis recipient: one per (token, recipient), rows summed. */
+export interface FPoolGenesisTransfer {
+    token: Address;
+    to: Address;
+    amount: bigint;
+}
 export interface FPoolLaunchArgs extends Omit<FPoolCreateArgs, "account"> {
     L0: bigint;
     /** Quote the seed pulls. A pad seeds at 0 — pure float, a resting ask, nothing raised. */
@@ -1289,6 +1225,18 @@ export interface FPoolLaunchArgs extends Omit<FPoolCreateArgs, "account"> {
         amountIn: bigint;
         minOut?: bigint;
     };
+    /**
+     * The genesis transactions: an ordered list of swaps right after the seed, each with an optional
+     * recipient ({@link FPoolGenesisRow}). The same batch as `openBuy`, which stays as the one-buy
+     * case and runs first when both are given. See `specs/f-pools/opening.md`.
+     */
+    openBatch?: FPoolGenesisRow[];
+    /**
+     * How a row's recipient is paid. `auto` (default): in the launch's own transaction when the
+     * wallet batches atomically (EIP-5792), else left to {@link fPoolSendGenesisTransfers};
+     * `followup`: always left to it. Ignored when no row names a recipient.
+     */
+    deliver?: "auto" | "followup";
     /** The pool's label (≤ 31 bytes of UTF-8) — the policy's word (049), written right after the batch by {@link fPoolLaunch}; not in the batch. */
     name?: string;
     /**
@@ -1312,6 +1260,32 @@ export declare function fPoolLaunchCalls(poolId: Hex, a: FPoolLaunchArgs & ({
 } | {
     x0: bigint[];
 })): Hex[];
+/** The genesis rows in the order they run: `openBuy` first when given, then `openBatch`. Legs as given. */
+export declare function fPoolGenesisRows(a: Pick<FPoolLaunchArgs, "openBuy" | "openBatch">): FPoolGenesisRow[];
+/**
+ * What each genesis row returned, read by simulating the launch's `multicall` on the chain — the
+ * contract's own rounding, no re-implementation. Exact at send time: the pool is new, and nothing
+ * can trade between the seed and the rows. Needs the creator's funds and allowances, as the launch
+ * does. One output per row, in {@link fPoolGenesisRows} order: base for a buy, quote for a sell.
+ */
+export declare function fPoolGenesisOutputs(c: LogswapClient, poolId: Hex, a: FPoolLaunchArgs & ({
+    r0: bigint[];
+} | {
+    x0: bigint[];
+})): Promise<bigint[]>;
+/**
+ * The transfers that pay the recipients: each row's output (`outs`, aligned with
+ * {@link fPoolGenesisRows}) to its `recipient`, summed per (token, recipient), zero amounts dropped.
+ * The token is the leg's base for a buy and the quote for a sell. Pure.
+ */
+export declare function fPoolGenesisTransfers(a: Pick<FPoolLaunchArgs, "quote" | "bases" | "openBuy" | "openBatch">, outs: bigint[]): FPoolGenesisTransfer[];
+/** Pay genesis recipients with plain ERC-20 transfers, one transaction each, in order. For a launch that did not deliver itself. */
+export declare function fPoolSendGenesisTransfers(c: LogswapClient, a: {
+    transfers: FPoolGenesisTransfer[];
+    account: Address;
+}): Promise<Hash[]>;
+/** Whether the wallet runs a batch of calls atomically (EIP-5792 `atomic` capability), on the client's chain. A wallet without it, or one that errors, says no. */
+export declare function fPoolWalletBatchesAtomically(c: LogswapClient, account: Address): Promise<boolean>;
 /**
  * The desk's opening posture, on its policy: gated minting, the creator a
  * minter. No appointment: the authority is the operator until one is appointed.
@@ -1346,6 +1320,8 @@ export declare function fPoolLaunch(c: LogswapClient, a: FPoolLaunchArgs & ({
 })): Promise<{
     hash: Hash;
     poolId: Hex;
+    transfers: FPoolGenesisTransfer[];
+    delivered: boolean;
 }>;
 /**
  * Propose the next authority — step one of two, on the pool's policy. Nothing moves
@@ -1517,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`. */
@@ -1525,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>;
 /**
@@ -1568,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

@@ -29,7 +29,7 @@
  * twice, forever. One router is one spender — see `fPoolZapIn`/`fPoolZapOut` below, which target
  * `addresses.router`.
  */
-import { encodeAbiParameters, encodeFunctionData, keccak256, toFunctionSelector } from "viem";
+import { decodeAbiParameters, encodeAbiParameters, encodeFunctionData, erc20Abi, keccak256, toFunctionSelector } from "viem";
 import { fPoolManagerAbi, logswapRouterAbi, padPolicyAbi, polPolicyAbi, policyRegistryAbi, privatePolicyAbi, publicPolicyAbi } from "./generated.js";
 /**
  * One contract, one ABI (F version 12): `harvest`, `claim`, `retire`, `regenerate`,
@@ -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`);
     }
@@ -907,11 +919,11 @@ export function fPoolLaunchCalls(poolId, a) {
     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.
-    if (a.openBuy) {
-        const j = bases.indexOf(a.bases[a.openBuy.j]);
+    for (const row of fPoolGenesisRows(a)) {
+        const j = bases.indexOf(a.bases[row.j]);
         if (j < 0)
-            throw new Error(`logswap: openBuy.j = ${a.openBuy.j} is not a leg`);
-        calls.push(enc("swapQuoteIn", [poolId, BigInt(j), a.openBuy.amountIn, a.openBuy.minOut ?? 0n, a.account]));
+            throw new Error(`logswap: genesis row j = ${row.j} is not a leg`);
+        calls.push(enc(row.side === "buy" ? "swapQuoteIn" : "swapBaseIn", [poolId, BigInt(j), row.amountIn, row.minOut ?? 0n, a.account]));
     }
     // the name, the desk's gates and its list are the POLICY's, not the
     // manager's: they cannot ride in this batch — `fPoolLaunch` and `fPoolDeskOpening` send them
@@ -919,6 +931,80 @@ export function fPoolLaunchCalls(poolId, a) {
     calls.push(...(a.extra ?? []));
     return calls;
 }
+/** The genesis rows in the order they run: `openBuy` first when given, then `openBatch`. Legs as given. */
+export function fPoolGenesisRows(a) {
+    return [...(a.openBuy ? [{ side: "buy", ...a.openBuy }] : []), ...(a.openBatch ?? [])];
+}
+/**
+ * What each genesis row returned, read by simulating the launch's `multicall` on the chain — the
+ * contract's own rounding, no re-implementation. Exact at send time: the pool is new, and nothing
+ * can trade between the seed and the rows. Needs the creator's funds and allowances, as the launch
+ * does. One output per row, in {@link fPoolGenesisRows} order: base for a buy, quote for a sell.
+ */
+export async function fPoolGenesisOutputs(c, poolId, a) {
+    const rows = fPoolGenesisRows(a);
+    if (rows.length === 0)
+        return [];
+    const calls = fPoolLaunchCalls(poolId, a);
+    const { result } = await c.public.simulateContract({
+        address: c.addresses.fPoolManager,
+        abi: fPoolManagerAbi,
+        functionName: "multicall",
+        args: [calls],
+        account: signerFor(c, a.account),
+    });
+    const results = result;
+    const first = (a.initialized ? 0 : 1) + 1; // [initialize] · seed · rows
+    return rows.map((_, i) => decodeAbiParameters([{ type: "uint256" }], results[first + i])[0]);
+}
+/**
+ * The transfers that pay the recipients: each row's output (`outs`, aligned with
+ * {@link fPoolGenesisRows}) to its `recipient`, summed per (token, recipient), zero amounts dropped.
+ * The token is the leg's base for a buy and the quote for a sell. Pure.
+ */
+export function fPoolGenesisTransfers(a, outs) {
+    const out = new Map();
+    fPoolGenesisRows(a).forEach((row, i) => {
+        if (!row.recipient || !outs[i])
+            return;
+        const token = row.side === "buy" ? a.bases[row.j] : a.quote;
+        const k = `${token.toLowerCase()}:${row.recipient.toLowerCase()}`;
+        const t = out.get(k);
+        if (t)
+            t.amount += outs[i];
+        else
+            out.set(k, { token, to: row.recipient, amount: outs[i] });
+    });
+    return [...out.values()];
+}
+/** Pay genesis recipients with plain ERC-20 transfers, one transaction each, in order. For a launch that did not deliver itself. */
+export async function fPoolSendGenesisTransfers(c, a) {
+    const wallet = requireWallet(c);
+    const hashes = [];
+    for (const t of a.transfers) {
+        const { request } = await c.public.simulateContract({
+            address: t.token,
+            abi: erc20Abi,
+            functionName: "transfer",
+            args: [t.to, t.amount],
+            account: signerFor(c, a.account),
+        });
+        hashes.push(await wallet.writeContract(request));
+    }
+    return hashes;
+}
+/** Whether the wallet runs a batch of calls atomically (EIP-5792 `atomic` capability), on the client's chain. A wallet without it, or one that errors, says no. */
+export async function fPoolWalletBatchesAtomically(c, account) {
+    try {
+        const wallet = requireWallet(c);
+        const chainId = wallet.chain?.id;
+        const caps = (await wallet.getCapabilities({ account, chainId }));
+        return caps?.atomic?.status === "supported" || caps?.atomic?.status === "ready";
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * The desk's opening posture, on its policy: gated minting, the creator a
  * minter. No appointment: the authority is the operator until one is appointed.
@@ -951,11 +1037,42 @@ export async function fPoolDeskOpening(c, a) {
 export async function fPoolLaunch(c, a) {
     const poolId = await fPoolIdOf(c, a);
     const policy = a.policy ?? fPoolPolicyFor(c, a.kind);
-    const calls = fPoolLaunchCalls(poolId, { ...a, policy });
-    const hash = await writeFPool0(c, "multicall", [calls], a.account);
+    let args = { ...a, policy };
+    // With recipients, each row's minOut is pinned to its simulated output and the transfers pay
+    // exactly that: a row that returns less reverts the launch, a wei of surplus stays with the creator.
+    let transfers = [];
+    const rows = fPoolGenesisRows(a);
+    if (rows.some((r) => r.recipient)) {
+        const outs = await fPoolGenesisOutputs(c, poolId, args);
+        args = { ...args, openBuy: undefined, openBatch: rows.map((r, i) => ({ ...r, minOut: outs[i] })) };
+        transfers = fPoolGenesisTransfers(args, outs);
+    }
+    const calls = fPoolLaunchCalls(poolId, args);
+    let hash;
+    let delivered = transfers.length === 0;
+    if (transfers.length > 0 && a.deliver !== "followup" && (await fPoolWalletBatchesAtomically(c, a.account))) {
+        const wallet = requireWallet(c);
+        const { id } = await wallet.sendCalls({
+            account: signerFor(c, a.account),
+            forceAtomic: true,
+            calls: [
+                { to: c.addresses.fPoolManager, data: encodeFunctionData({ abi: fPoolManagerAbi, functionName: "multicall", args: [calls] }) },
+                ...transfers.map((t) => ({ to: t.token, data: encodeFunctionData({ abi: erc20Abi, functionName: "transfer", args: [t.to, t.amount] }) })),
+            ],
+        });
+        const status = await wallet.waitForCallsStatus({ id });
+        const receipt = status.receipts?.[0];
+        if (status.status !== "success" || !receipt)
+            throw new Error("logswap: the launch batch did not succeed — nothing was created");
+        hash = receipt.transactionHash;
+        delivered = true;
+    }
+    else {
+        hash = await writeFPool0(c, "multicall", [calls], a.account);
+    }
     if (a.name)
         await fPoolSetName(c, { poolId, name: a.name, account: a.account, policy });
-    return { hash, poolId };
+    return { hash, poolId, transfers, delivered };
 }
 // ─── the roles, on the policy ─────────────────────────────────────────────
 //
@@ -1151,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) };
         }
     }
 }