@logswap/sdk 0.5.38 → 0.5.40

package/dist/fpool.d.ts

@@ -464,7 +464,7 @@ export declare const fPoolManagerAbi: readonly [{
             readonly internalType: "int256";
             readonly type: "int256";
         }, {
-            readonly name: "leverTheta";
+            readonly name: "harvestedTheta";
             readonly internalType: "int256";
             readonly type: "int256";
         }, {
@@ -1357,26 +1357,6 @@ export declare const fPoolManagerAbi: readonly [{
         readonly indexed: true;
     }];
     readonly name: "CollectorProposed";
-}, {
-    readonly type: "event";
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly name: "poolId";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-        readonly indexed: true;
-    }, {
-        readonly name: "from";
-        readonly internalType: "address";
-        readonly type: "address";
-        readonly indexed: true;
-    }, {
-        readonly name: "amount";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-        readonly indexed: false;
-    }];
-    readonly name: "Deepen";
 }, {
     readonly type: "event";
     readonly anonymous: false;
@@ -2343,20 +2323,6 @@ export declare const fPoolManagerAbi: readonly [{
         readonly type: "uint8";
     }];
     readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly inputs: readonly [{
-        readonly name: "poolId";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-    }, {
-        readonly name: "amount";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-    }];
-    readonly name: "deepen";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -3070,26 +3036,6 @@ export declare const fPoolManagerAbi: readonly [{
         readonly indexed: true;
     }];
     readonly name: "CollectorProposed";
-}, {
-    readonly type: "event";
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly name: "poolId";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-        readonly indexed: true;
-    }, {
-        readonly name: "from";
-        readonly internalType: "address";
-        readonly type: "address";
-        readonly indexed: true;
-    }, {
-        readonly name: "amount";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-        readonly indexed: false;
-    }];
-    readonly name: "Deepen";
 }, {
     readonly type: "event";
     readonly anonymous: false;
@@ -3963,12 +3909,6 @@ export declare function fPoolClaim(c: LogswapClient, a: {
 export declare function fPoolDividendOf(c: LogswapClient, poolId: Hex, holder: Address, gen?: bigint | number): Promise<bigint>;
 /** The lever's floor: `harvest` may not take Q/L under ln 1.25 — the floor stays ≥ 20% below the mark (decisions 025). */
 export declare const LEVER_FLOOR = 223143551314209755n;
-/** Commit quote, deepening θ — the other sign of `harvest`, the same word as the C floor edit (decisions 011). The mark does not move: governance may write θ, never x. */
-export declare function fPoolDeepen(c: LogswapClient, a: {
-    poolId: Hex;
-    amount: bigint;
-    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`? */
@@ -4131,6 +4071,82 @@ export declare function fPoolRelaunch(c: LogswapClient, a: {
     x0: bigint[];
     weights: bigint[];
 })): Promise<`0x${string}`>;
+/** ERC-6909 shares sent here are locked for good — the seed's custody (custody.md §4(b)). */
+export declare const DEAD_ADDRESS: Address;
+/** The manager's `MIN_SHARES`: the seed mints this much to 0xdead itself, the rest to the seeder. */
+export declare const F_MIN_SHARES = 1000n;
+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. */
+    Q0: bigint;
+    /**
+     * Send every share the seed mints to the creator (`L0 − MIN_SHARES`) to 0xdead in the same
+     * batch: the float and the raise can never be burned out from under the buyers. The lever
+     * (harvest) is the authority's and survives it; the exit does not. A pad's default posture.
+     */
+    lockSeed?: boolean;
+    /**
+     * An opening buy of leg `j` (an index into `bases` AS GIVEN) for `amountIn` of quote, ON THE
+     * MANAGER — the same sender, a plain allowance to the manager, the router nowhere near it. A
+     * pad seeds at Q = 0, so until someone trades it the mark sits at p₀; buying inside the launch
+     * gives it a price that has moved and a buffer under it. Nothing can trade between the seed and
+     * this buy — they are one transaction — so `minOut` is safe at its default of 0.
+     */
+    openBuy?: {
+        j: number;
+        amountIn: bigint;
+        minOut?: bigint;
+    };
+    /** The pool's label, set in the batch (≤ 31 bytes of UTF-8). */
+    name?: string;
+    /** Gate minting, list the creator, appoint them operator (decisions 021) — three calls, in the batch. */
+    privatePool?: boolean;
+    /**
+     * The pool already exists (a previous launch got as far as `initialize` and no further — a seed
+     * that reverted, a closed tab, before the launch was one transaction), so `initialize` is left
+     * out: the key is a pure function of the arguments and a second `initialize` can only revert.
+     */
+    initialized?: boolean;
+    /** Anything else, pre-encoded against {@link fPoolManagerAbi}, appended after the above. */
+    extra?: Hex[];
+    account: Address;
+}
+/**
+ * The launch's calls, in order — the batch {@link fPoolLaunch} sends. Pure, so a form can show
+ * what it is about to send, and a test can decode it. Legs are sorted here with their weights and
+ * reserves (the key's canonical order; `openBuy.j` is re-indexed to match), and the weights are
+ * checked here, where the message is readable.
+ */
+export declare function fPoolLaunchCalls(poolId: Hex, a: FPoolLaunchArgs & ({
+    r0: bigint[];
+} | {
+    x0: bigint[];
+})): Hex[];
+/**
+ * Create a pool as ONE transaction: `initialize`, `seed`, the seed lock, the opening buy, the
+ * name, the private-pool gates — the manager's `multicall`, the creator as sender throughout.
+ * Either every call lands or none does; there is no half-built pool to resume.
+ *
+ * Why the manager and not the router: every one of these entries authenticates by `msg.sender`
+ * (`seed` is authority-only, so is everything after it). Routed, the router would be the sender
+ * — the authority, the holder of the seed shares — and the handover back is two-step, so it
+ * could not even close in the same transaction. `multicall` is delegatecall-to-self, so the
+ * sender survives, which is what the manager's own doc says a router cannot do.
+ *
+ * What the batch PULLS, by plain allowance to the manager (never Permit2): `r0[j]` of each base,
+ * `Q0` of quote, plus `openBuy.amountIn` of quote. Grant those first — one `approve` per token,
+ * once ever ({@link approveTokenForFPoolManager}, {@link fPoolManagerAllowanceOk}).
+ *
+ * Returns the hash and the pool's id (the key's hash, {@link fPoolIdOf}).
+ */
+export declare function fPoolLaunch(c: LogswapClient, a: FPoolLaunchArgs & ({
+    r0: bigint[];
+} | {
+    x0: bigint[];
+})): Promise<{
+    hash: Hash;
+    poolId: Hex;
+}>;
 /**
  * Propose the next authority — step one of two (contracts `2aa6b7b`, decisions 020). Nothing moves
  * until `next` accepts; proposing again (the zero address included) cancels a pending proposal.
@@ -4271,7 +4287,7 @@ export declare function fPoolShareHolders(c: LogswapClient, poolIdHex: Hex, opts
     holder: Address;
     shares: bigint;
 }>>;
-/** Every F pool's state in one lens call (the raw manager struct: quote, phi, authority, lockStrike, seeded, gen, n, Q, L, shares, theta0, bigSigma, leverTheta). */
+/** Every F pool's state in one lens call (the raw manager struct: quote, phi, authority, lockStrike, seeded, gen, n, Q, L, shares, theta0, bigSigma, harvestedTheta). */
 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>;

package/dist/fpool.js

@@ -269,10 +269,6 @@ export async function fPoolDividendOf(c, poolId, holder, gen) {
 }
 /** The lever's floor: `harvest` may not take Q/L under ln 1.25 — the floor stays ≥ 20% below the mark (decisions 025). */
 export const LEVER_FLOOR = 223143551314209755n;
-/** Commit quote, deepening θ — the other sign of `harvest`, the same word as the C floor edit (decisions 011). The mark does not move: governance may write θ, never x. */
-export async function fPoolDeepen(c, a) {
-    return writeFPool(c, a.poolId, "deepen", [a.amount], a.account);
-}
 // ─── internals ────────────────────────────────────────────────────────────────
 function defaultDeadline() {
     return BigInt(Math.floor(Date.now() / 1000) + 1800);
@@ -629,6 +625,71 @@ export async function fPoolRelaunch(c, a) {
     ];
     return writeFPool0(c, "multicall", [calls], a.account);
 }
+/** ERC-6909 shares sent here are locked for good — the seed's custody (custody.md §4(b)). */
+export const DEAD_ADDRESS = "0x000000000000000000000000000000000000dEaD";
+/** The manager's `MIN_SHARES`: the seed mints this much to 0xdead itself, the rest to the seeder. */
+export const F_MIN_SHARES = 1000n;
+/**
+ * The launch's calls, in order — the batch {@link fPoolLaunch} sends. Pure, so a form can show
+ * what it is about to send, and a test can decode it. Legs are sorted here with their weights and
+ * reserves (the key's canonical order; `openBuy.j` is re-indexed to match), and the weights are
+ * checked here, where the message is readable.
+ */
+export function fPoolLaunchCalls(poolId, a) {
+    const sum = a.weights.reduce((x, y) => x + y, 0n);
+    if (sum !== WAD)
+        throw new Error(`logswap: weights sum to ${sum}, expected 1e18`);
+    const given = "r0" in a ? a.r0 : a.x0.map((x, j) => fPoolReserveAt((a.weights[j] * a.L0) / WAD, x));
+    if (given.length !== a.bases.length)
+        throw new Error(`logswap: ${given.length} reserves for ${a.bases.length} legs`);
+    const { bases, companions } = sortFPoolLegs(a.bases, a.weights, given);
+    const key = { quote: a.quote, bases, weights: companions[0], phi: a.phi, lockStrike: a.lockStrike, authority: a.authority, salt: a.salt ?? ZERO_SALT };
+    const enc = (functionName, args) => encodeFunctionData({ abi: fPoolManagerAbi, functionName, args });
+    const calls = [];
+    if (!a.initialized)
+        calls.push(enc("initialize", [key]));
+    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`
+    if (a.lockSeed)
+        calls.push(enc("transfer", [DEAD_ADDRESS, fPoolShareId(poolId, 0), a.L0 - F_MIN_SHARES]));
+    if (a.openBuy) {
+        const j = bases.indexOf(a.bases[a.openBuy.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]));
+    }
+    if (a.name)
+        calls.push(enc("setName", [poolId, textToBytes32(a.name)]));
+    if (a.privatePool) {
+        calls.push(enc("setGates", [poolId, true, false]));
+        calls.push(enc("setAllowed", [poolId, [a.account], true]));
+        calls.push(enc("appointOperator", [poolId, a.account]));
+    }
+    calls.push(...(a.extra ?? []));
+    return calls;
+}
+/**
+ * Create a pool as ONE transaction: `initialize`, `seed`, the seed lock, the opening buy, the
+ * name, the private-pool gates — the manager's `multicall`, the creator as sender throughout.
+ * Either every call lands or none does; there is no half-built pool to resume.
+ *
+ * Why the manager and not the router: every one of these entries authenticates by `msg.sender`
+ * (`seed` is authority-only, so is everything after it). Routed, the router would be the sender
+ * — the authority, the holder of the seed shares — and the handover back is two-step, so it
+ * could not even close in the same transaction. `multicall` is delegatecall-to-self, so the
+ * sender survives, which is what the manager's own doc says a router cannot do.
+ *
+ * What the batch PULLS, by plain allowance to the manager (never Permit2): `r0[j]` of each base,
+ * `Q0` of quote, plus `openBuy.amountIn` of quote. Grant those first — one `approve` per token,
+ * once ever ({@link approveTokenForFPoolManager}, {@link fPoolManagerAllowanceOk}).
+ *
+ * Returns the hash and the pool's id (the key's hash, {@link fPoolIdOf}).
+ */
+export async function fPoolLaunch(c, a) {
+    const poolId = await fPoolIdOf(c, a);
+    const hash = await writeFPool0(c, "multicall", [fPoolLaunchCalls(poolId, a)], a.account);
+    return { hash, poolId };
+}
 /**
  * Propose the next authority — step one of two (contracts `2aa6b7b`, decisions 020). Nothing moves
  * until `next` accepts; proposing again (the zero address included) cancels a pending proposal.
@@ -804,7 +865,7 @@ export async function fPoolShareHolders(c, poolIdHex, opts = {}) {
         .map(([holder, shares]) => ({ holder: holder, shares }))
         .sort((a, b) => (b.shares > a.shares ? 1 : -1));
 }
-/** Every F pool's state in one lens call (the raw manager struct: quote, phi, authority, lockStrike, seeded, gen, n, Q, L, shares, theta0, bigSigma, leverTheta). */
+/** Every F pool's state in one lens call (the raw manager struct: quote, phi, authority, lockStrike, seeded, gen, n, Q, L, shares, theta0, bigSigma, harvestedTheta). */
 export async function getFPoolsRaw(c, poolIds) {
     const { logswapLensAbi } = await import("./generated.js");
     return (await c.public.readContract({ address: c.addresses.lens, abi: logswapLensAbi, functionName: "getFPools", args: [poolIds] }));

package/dist/generated.d.ts

@@ -2223,7 +2223,7 @@ export declare const fPoolManagerAbi: readonly [{
             readonly internalType: "int256";
             readonly type: "int256";
         }, {
-            readonly name: "leverTheta";
+            readonly name: "harvestedTheta";
             readonly internalType: "int256";
             readonly type: "int256";
         }, {
@@ -3116,26 +3116,6 @@ export declare const fPoolManagerAbi: readonly [{
         readonly indexed: true;
     }];
     readonly name: "CollectorProposed";
-}, {
-    readonly type: "event";
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly name: "poolId";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-        readonly indexed: true;
-    }, {
-        readonly name: "from";
-        readonly internalType: "address";
-        readonly type: "address";
-        readonly indexed: true;
-    }, {
-        readonly name: "amount";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-        readonly indexed: false;
-    }];
-    readonly name: "Deepen";
 }, {
     readonly type: "event";
     readonly anonymous: false;
@@ -4103,20 +4083,6 @@ export declare const fPoolSponsorAbi: readonly [{
         readonly type: "uint8";
     }];
     readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly inputs: readonly [{
-        readonly name: "poolId";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-    }, {
-        readonly name: "amount";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-    }];
-    readonly name: "deepen";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -4830,26 +4796,6 @@ export declare const fPoolSponsorAbi: readonly [{
         readonly indexed: true;
     }];
     readonly name: "CollectorProposed";
-}, {
-    readonly type: "event";
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly name: "poolId";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-        readonly indexed: true;
-    }, {
-        readonly name: "from";
-        readonly internalType: "address";
-        readonly type: "address";
-        readonly indexed: true;
-    }, {
-        readonly name: "amount";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-        readonly indexed: false;
-    }];
-    readonly name: "Deepen";
 }, {
     readonly type: "event";
     readonly anonymous: false;
@@ -5859,7 +5805,7 @@ export declare const logswapLensAbi: readonly [{
             readonly internalType: "int256";
             readonly type: "int256";
         }, {
-            readonly name: "leverTheta";
+            readonly name: "harvestedTheta";
             readonly internalType: "int256";
             readonly type: "int256";
         }, {

package/dist/generated.js

@@ -1299,7 +1299,7 @@ export const fPoolManagerAbi = [
                     { name: 'L', internalType: 'uint256', type: 'uint256' },
                     { name: 'shares', internalType: 'uint256', type: 'uint256' },
                     { name: 'theta0', internalType: 'int256', type: 'int256' },
-                    { name: 'leverTheta', internalType: 'int256', type: 'int256' },
+                    { name: 'harvestedTheta', internalType: 'int256', type: 'int256' },
                     {
                         name: 'pendingAuthority',
                         internalType: 'address',
@@ -1845,26 +1845,6 @@ export const fPoolManagerAbi = [
         ],
         name: 'CollectorProposed',
     },
-    {
-        type: 'event',
-        anonymous: false,
-        inputs: [
-            {
-                name: 'poolId',
-                internalType: 'bytes32',
-                type: 'bytes32',
-                indexed: true,
-            },
-            { name: 'from', internalType: 'address', type: 'address', indexed: true },
-            {
-                name: 'amount',
-                internalType: 'uint256',
-                type: 'uint256',
-                indexed: false,
-            },
-        ],
-        name: 'Deepen',
-    },
     {
         type: 'event',
         anonymous: false,
@@ -2589,16 +2569,6 @@ export const fPoolSponsorAbi = [
         outputs: [{ name: '', internalType: 'uint8', type: 'uint8' }],
         stateMutability: 'view',
     },
-    {
-        type: 'function',
-        inputs: [
-            { name: 'poolId', internalType: 'bytes32', type: 'bytes32' },
-            { name: 'amount', internalType: 'uint256', type: 'uint256' },
-        ],
-        name: 'deepen',
-        outputs: [],
-        stateMutability: 'nonpayable',
-    },
     {
         type: 'function',
         inputs: [
@@ -3083,26 +3053,6 @@ export const fPoolSponsorAbi = [
         ],
         name: 'CollectorProposed',
     },
-    {
-        type: 'event',
-        anonymous: false,
-        inputs: [
-            {
-                name: 'poolId',
-                internalType: 'bytes32',
-                type: 'bytes32',
-                indexed: true,
-            },
-            { name: 'from', internalType: 'address', type: 'address', indexed: true },
-            {
-                name: 'amount',
-                internalType: 'uint256',
-                type: 'uint256',
-                indexed: false,
-            },
-        ],
-        name: 'Deepen',
-    },
     {
         type: 'event',
         anonymous: false,
@@ -3823,7 +3773,7 @@ export const logswapLensAbi = [
                     { name: 'L', internalType: 'uint256', type: 'uint256' },
                     { name: 'shares', internalType: 'uint256', type: 'uint256' },
                     { name: 'theta0', internalType: 'int256', type: 'int256' },
-                    { name: 'leverTheta', internalType: 'int256', type: 'int256' },
+                    { name: 'harvestedTheta', internalType: 'int256', type: 'int256' },
                     {
                         name: 'pendingAuthority',
                         internalType: 'address',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logswap/sdk",
-  "version": "0.5.38",
+  "version": "0.5.40",
   "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/fpool.ts

@@ -128,7 +128,7 @@ export async function getFPool(c: LogswapClient, poolId: Hex): Promise<FPoolStat
     shares: bigint;
     theta0: bigint;
     bigSigma: bigint;
-    leverTheta: bigint;
+    harvestedTheta: bigint;
     pendingAuthority: Address;
     operator: Address;
     minBuffer: bigint;
@@ -467,11 +467,6 @@ export async function fPoolDividendOf(c: LogswapClient, poolId: Hex, holder: Add
 /** The lever's floor: `harvest` may not take Q/L under ln 1.25 — the floor stays ≥ 20% below the mark (decisions 025). */
 export const LEVER_FLOOR = 223143551314209755n;
 
-/** Commit quote, deepening θ — the other sign of `harvest`, the same word as the C floor edit (decisions 011). The mark does not move: governance may write θ, never x. */
-export async function fPoolDeepen(c: LogswapClient, a: { poolId: Hex; amount: bigint; account: Address }) {
-  return writeFPool(c, a.poolId, "deepen", [a.amount], a.account);
-}
-
 // ─── internals ────────────────────────────────────────────────────────────────
 
 function defaultDeadline(): bigint {
@@ -920,6 +915,108 @@ export async function fPoolRelaunch(
   return writeFPool0(c, "multicall", [calls], a.account);
 }
 
+/** ERC-6909 shares sent here are locked for good — the seed's custody (custody.md §4(b)). */
+export const DEAD_ADDRESS: Address = "0x000000000000000000000000000000000000dEaD";
+/** The manager's `MIN_SHARES`: the seed mints this much to 0xdead itself, the rest to the seeder. */
+export const F_MIN_SHARES = 1000n;
+
+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. */
+  Q0: bigint;
+  /**
+   * Send every share the seed mints to the creator (`L0 − MIN_SHARES`) to 0xdead in the same
+   * batch: the float and the raise can never be burned out from under the buyers. The lever
+   * (harvest) is the authority's and survives it; the exit does not. A pad's default posture.
+   */
+  lockSeed?: boolean;
+  /**
+   * An opening buy of leg `j` (an index into `bases` AS GIVEN) for `amountIn` of quote, ON THE
+   * MANAGER — the same sender, a plain allowance to the manager, the router nowhere near it. A
+   * pad seeds at Q = 0, so until someone trades it the mark sits at p₀; buying inside the launch
+   * gives it a price that has moved and a buffer under it. Nothing can trade between the seed and
+   * this buy — they are one transaction — so `minOut` is safe at its default of 0.
+   */
+  openBuy?: { j: number; amountIn: bigint; minOut?: bigint };
+  /** The pool's label, set in the batch (≤ 31 bytes of UTF-8). */
+  name?: string;
+  /** Gate minting, list the creator, appoint them operator (decisions 021) — three calls, in the batch. */
+  privatePool?: boolean;
+  /**
+   * The pool already exists (a previous launch got as far as `initialize` and no further — a seed
+   * that reverted, a closed tab, before the launch was one transaction), so `initialize` is left
+   * out: the key is a pure function of the arguments and a second `initialize` can only revert.
+   */
+  initialized?: boolean;
+  /** Anything else, pre-encoded against {@link fPoolManagerAbi}, appended after the above. */
+  extra?: Hex[];
+  account: Address;
+}
+
+/**
+ * The launch's calls, in order — the batch {@link fPoolLaunch} sends. Pure, so a form can show
+ * what it is about to send, and a test can decode it. Legs are sorted here with their weights and
+ * reserves (the key's canonical order; `openBuy.j` is re-indexed to match), and the weights are
+ * checked here, where the message is readable.
+ */
+export function fPoolLaunchCalls(
+  poolId: Hex,
+  a: FPoolLaunchArgs & ({ r0: bigint[] } | { x0: bigint[] }),
+): Hex[] {
+  const sum = a.weights.reduce((x, y) => x + y, 0n);
+  if (sum !== WAD) throw new Error(`logswap: weights sum to ${sum}, expected 1e18`);
+  const given = "r0" in a ? a.r0 : a.x0.map((x, j) => fPoolReserveAt((a.weights[j]! * a.L0) / WAD, x));
+  if (given.length !== a.bases.length) throw new Error(`logswap: ${given.length} reserves for ${a.bases.length} legs`);
+  const { bases, companions } = sortFPoolLegs(a.bases, a.weights, given);
+  const key = { quote: a.quote, bases, weights: companions[0]!, phi: a.phi, lockStrike: a.lockStrike, authority: a.authority, salt: a.salt ?? ZERO_SALT };
+  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]));
+  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`
+  if (a.lockSeed) calls.push(enc("transfer", [DEAD_ADDRESS, fPoolShareId(poolId, 0), a.L0 - F_MIN_SHARES]));
+  if (a.openBuy) {
+    const j = bases.indexOf(a.bases[a.openBuy.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]));
+  }
+  if (a.name) calls.push(enc("setName", [poolId, textToBytes32(a.name)]));
+  if (a.privatePool) {
+    calls.push(enc("setGates", [poolId, true, false]));
+    calls.push(enc("setAllowed", [poolId, [a.account], true]));
+    calls.push(enc("appointOperator", [poolId, a.account]));
+  }
+  calls.push(...(a.extra ?? []));
+  return calls;
+}
+
+/**
+ * Create a pool as ONE transaction: `initialize`, `seed`, the seed lock, the opening buy, the
+ * name, the private-pool gates — the manager's `multicall`, the creator as sender throughout.
+ * Either every call lands or none does; there is no half-built pool to resume.
+ *
+ * Why the manager and not the router: every one of these entries authenticates by `msg.sender`
+ * (`seed` is authority-only, so is everything after it). Routed, the router would be the sender
+ * — the authority, the holder of the seed shares — and the handover back is two-step, so it
+ * could not even close in the same transaction. `multicall` is delegatecall-to-self, so the
+ * sender survives, which is what the manager's own doc says a router cannot do.
+ *
+ * What the batch PULLS, by plain allowance to the manager (never Permit2): `r0[j]` of each base,
+ * `Q0` of quote, plus `openBuy.amountIn` of quote. Grant those first — one `approve` per token,
+ * once ever ({@link approveTokenForFPoolManager}, {@link fPoolManagerAllowanceOk}).
+ *
+ * Returns the hash and the pool's id (the key's hash, {@link fPoolIdOf}).
+ */
+export async function fPoolLaunch(
+  c: LogswapClient,
+  a: FPoolLaunchArgs & ({ r0: bigint[] } | { x0: bigint[] }),
+): Promise<{ hash: Hash; poolId: Hex }> {
+  const poolId = await fPoolIdOf(c, a);
+  const hash = await writeFPool0(c, "multicall", [fPoolLaunchCalls(poolId, a)], a.account);
+  return { hash, poolId };
+}
+
 /**
  * Propose the next authority — step one of two (contracts `2aa6b7b`, decisions 020). Nothing moves
  * until `next` accepts; proposing again (the zero address included) cancels a pending proposal.
@@ -1161,7 +1258,7 @@ export async function fPoolShareHolders(
     .sort((a, b) => (b.shares > a.shares ? 1 : -1));
 }
 
-/** Every F pool's state in one lens call (the raw manager struct: quote, phi, authority, lockStrike, seeded, gen, n, Q, L, shares, theta0, bigSigma, leverTheta). */
+/** Every F pool's state in one lens call (the raw manager struct: quote, phi, authority, lockStrike, seeded, gen, n, Q, L, shares, theta0, bigSigma, harvestedTheta). */
 export async function getFPoolsRaw(c: LogswapClient, poolIds: Hex[]): Promise<readonly unknown[]> {
   const { logswapLensAbi } = await import("./generated.js");
   return (await c.public.readContract({ address: c.addresses.lens, abi: logswapLensAbi, functionName: "getFPools", args: [poolIds] } as never)) as readonly unknown[];

package/src/generated.ts

@@ -1302,7 +1302,7 @@ export const fPoolManagerAbi = [
           { name: 'L', internalType: 'uint256', type: 'uint256' },
           { name: 'shares', internalType: 'uint256', type: 'uint256' },
           { name: 'theta0', internalType: 'int256', type: 'int256' },
-          { name: 'leverTheta', internalType: 'int256', type: 'int256' },
+          { name: 'harvestedTheta', internalType: 'int256', type: 'int256' },
           {
             name: 'pendingAuthority',
             internalType: 'address',
@@ -1848,26 +1848,6 @@ export const fPoolManagerAbi = [
     ],
     name: 'CollectorProposed',
   },
-  {
-    type: 'event',
-    anonymous: false,
-    inputs: [
-      {
-        name: 'poolId',
-        internalType: 'bytes32',
-        type: 'bytes32',
-        indexed: true,
-      },
-      { name: 'from', internalType: 'address', type: 'address', indexed: true },
-      {
-        name: 'amount',
-        internalType: 'uint256',
-        type: 'uint256',
-        indexed: false,
-      },
-    ],
-    name: 'Deepen',
-  },
   {
     type: 'event',
     anonymous: false,
@@ -2594,16 +2574,6 @@ export const fPoolSponsorAbi = [
     outputs: [{ name: '', internalType: 'uint8', type: 'uint8' }],
     stateMutability: 'view',
   },
-  {
-    type: 'function',
-    inputs: [
-      { name: 'poolId', internalType: 'bytes32', type: 'bytes32' },
-      { name: 'amount', internalType: 'uint256', type: 'uint256' },
-    ],
-    name: 'deepen',
-    outputs: [],
-    stateMutability: 'nonpayable',
-  },
   {
     type: 'function',
     inputs: [
@@ -3088,26 +3058,6 @@ export const fPoolSponsorAbi = [
     ],
     name: 'CollectorProposed',
   },
-  {
-    type: 'event',
-    anonymous: false,
-    inputs: [
-      {
-        name: 'poolId',
-        internalType: 'bytes32',
-        type: 'bytes32',
-        indexed: true,
-      },
-      { name: 'from', internalType: 'address', type: 'address', indexed: true },
-      {
-        name: 'amount',
-        internalType: 'uint256',
-        type: 'uint256',
-        indexed: false,
-      },
-    ],
-    name: 'Deepen',
-  },
   {
     type: 'event',
     anonymous: false,
@@ -3830,7 +3780,7 @@ export const logswapLensAbi = [
           { name: 'L', internalType: 'uint256', type: 'uint256' },
           { name: 'shares', internalType: 'uint256', type: 'uint256' },
           { name: 'theta0', internalType: 'int256', type: 'int256' },
-          { name: 'leverTheta', internalType: 'int256', type: 'int256' },
+          { name: 'harvestedTheta', internalType: 'int256', type: 'int256' },
           {
             name: 'pendingAuthority',
             internalType: 'address',