@logswap/sdk 0.5.68 → 0.5.69

package/dist/fpool.d.ts

@@ -1273,6 +1273,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 +1310,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 +1345,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 +1405,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

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`,
@@ -907,11 +907,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 +919,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 +1025,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 ─────────────────────────────────────────────
 //

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logswap/sdk",
-  "version": "0.5.68",
+  "version": "0.5.69",
   "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

@@ -30,7 +30,7 @@
  * `addresses.router`.
  */
 
-import { encodeAbiParameters, encodeFunctionData, keccak256, toFunctionSelector, type Address, type Hash, type Hex } from "viem";
+import { decodeAbiParameters, encodeAbiParameters, encodeFunctionData, erc20Abi, keccak256, toFunctionSelector, type Address, type Hash, type Hex } from "viem";
 import { fPoolManagerAbi, logswapRouterAbi, padPolicyAbi, polPolicyAbi, policyRegistryAbi, privatePolicyAbi, publicPolicyAbi } from "./generated.js";
 
 /**
@@ -1252,6 +1252,29 @@ export const DEAD_ADDRESS: Address = "0x000000000000000000000000000000000000dEaD
 /** 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 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. */
@@ -1264,6 +1287,18 @@ export interface FPoolLaunchArgs extends Omit<FPoolCreateArgs, "account"> {
    * this buy — they are one transaction — so `minOut` is safe at its default of 0.
    */
   openBuy?: { j: number; 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;
   /**
@@ -1301,10 +1336,10 @@ export function fPoolLaunchCalls(
   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]!);
-    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]));
+  for (const row of fPoolGenesisRows(a)) {
+    const j = bases.indexOf(a.bases[row.j]!);
+    if (j < 0) 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
@@ -1313,6 +1348,87 @@ export function fPoolLaunchCalls(
   return calls;
 }
 
+/** The genesis rows in the order they run: `openBuy` first when given, then `openBatch`. Legs as given. */
+export function fPoolGenesisRows(a: Pick<FPoolLaunchArgs, "openBuy" | "openBatch">): FPoolGenesisRow[] {
+  return [...(a.openBuy ? [{ side: "buy" as const, ...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: LogswapClient,
+  poolId: Hex,
+  a: FPoolLaunchArgs & ({ r0: bigint[] } | { x0: bigint[] }),
+): Promise<bigint[]> {
+  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),
+  } as never);
+  const results = result as readonly Hex[];
+  const first = (a.initialized ? 0 : 1) + 1; // [initialize] · seed · rows
+  return rows.map((_, i) => decodeAbiParameters([{ type: "uint256" }], results[first + i]!)[0] as 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 function fPoolGenesisTransfers(
+  a: Pick<FPoolLaunchArgs, "quote" | "bases" | "openBuy" | "openBatch">,
+  outs: bigint[],
+): FPoolGenesisTransfer[] {
+  const out = new Map<string, FPoolGenesisTransfer>();
+  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: LogswapClient, a: { transfers: FPoolGenesisTransfer[]; account: Address }): Promise<Hash[]> {
+  const wallet = requireWallet(c);
+  const hashes: Hash[] = [];
+  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),
+    } as never);
+    hashes.push(await wallet.writeContract(request as never));
+  }
+  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: LogswapClient, account: Address): Promise<boolean> {
+  try {
+    const wallet = requireWallet(c);
+    const chainId = wallet.chain?.id;
+    const caps = (await wallet.getCapabilities({ account, chainId })) as { atomic?: { status?: string } };
+    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.
@@ -1346,13 +1462,42 @@ export async function fPoolDeskOpening(c: LogswapClient, a: { poolId: Hex; accou
 export async function fPoolLaunch(
   c: LogswapClient,
   a: FPoolLaunchArgs & ({ r0: bigint[] } | { x0: bigint[] }),
-): Promise<{ hash: Hash; poolId: Hex }> {
+): Promise<{ hash: Hash; poolId: Hex; transfers: FPoolGenesisTransfer[]; delivered: boolean }> {
   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: FPoolGenesisTransfer[] = [];
+  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: 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] } as never) },
+        ...transfers.map((t) => ({ to: t.token, data: encodeFunctionData({ abi: erc20Abi, functionName: "transfer", args: [t.to, t.amount] }) })),
+      ],
+    } as never);
+    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 ─────────────────────────────────────────────