@logswap/sdk 0.5.35

package/dist/client.js

@@ -0,0 +1,68 @@
+/**
+ * client.ts — the SDK handle: addresses + viem clients.
+ *
+ * Construct once and pass to every helper. `wallet` is optional: read helpers need only `public`.
+ *
+ * **Three addresses, permanently.** Not three per market — every market lives in the one manager,
+ * and a market is an `initialize(key, x0)` call rather than a deployment. So this is a constant of
+ * the protocol, not configuration that grows.
+ */
+export function createLogswapClient(args) {
+    return { public: args.public, wallet: args.wallet, addresses: args.addresses };
+}
+/**
+ * Assert the deployment matches the ABI this build was generated against.
+ *
+ * Cheap insurance worth taking at construction: without it, a manager from a different deployment
+ * decodes into plausible-looking garbage rather than failing. `version` is bumped on any tier-1 or
+ * tier-2 change (docs/app.md).
+ *
+ * **2** since 2026-09-01. It sat at 1 across a read surface that changed underneath it — the nine
+ * `public constant` getters left the manager for `CParams`, `move` gained its settlement bounds,
+ * `createMarket` arrived — so a 1 answered for two incompatible ABIs and this check passed against
+ * a manager it should have rejected. Observed, not theorised: a local chain running a pre-trim
+ * manager sailed through `assertVersion` while `FEE_MAX()` still answered on it. Move this in the
+ * same change as `CParams.VERSION`, never after it.
+ *
+ * **3** since 2026-09-03 (contracts `d8406fb`): `burnById` and `update` take an `owner`, `update`
+ * mints to `to`, `positions()` returns `aps` as uint128 — and a returned quote flow now carries the
+ * swept fees (decisions 018), which is why `exit`'s settle-to-one-asset math changed with it.
+ */
+export const EXPECTED_VERSION = 3n;
+/**
+ * The F manager's own tag (contracts 25a7bcf: 5 — the key's salt, pool names, the sponsor registry;
+ * 4 was the income-only harvest cut).
+ *
+ * A FLOOR, not an equality — unlike `EXPECTED_VERSION` above. The F primitive is iterating fast and
+ * its bumps are mostly additive (6 is `multicall`, which nothing this SDK calls goes near), so an
+ * exact match meant each one bricked every app on the deployment until the SDK was republished — a
+ * version wall in front of a change that broke nothing. The cost is that a genuinely breaking bump
+ * 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 const EXPECTED_F_VERSION = 5n;
+export async function assertVersion(c, expected = EXPECTED_VERSION) {
+    const { cPoolManagerAbi } = await import("./generated.js");
+    const got = await c.public.readContract({
+        address: c.addresses.cPoolManager,
+        abi: cPoolManagerAbi,
+        functionName: "version",
+    });
+    if (got !== expected) {
+        throw new Error(`logswap: manager at ${c.addresses.cPoolManager} reports version ${got}, but this SDK was built ` +
+            `against version ${expected}. Upgrade the SDK or point at the matching deployment.`);
+    }
+    // the F manager carries its own tag since contracts c782811; assert it the same way when deployed
+    if (c.addresses.fPoolManager) {
+        const { fPoolManagerAbi } = await import("./generated.js");
+        const gotF = await c.public.readContract({
+            address: c.addresses.fPoolManager,
+            abi: fPoolManagerAbi,
+            functionName: "version",
+        });
+        if (gotF < EXPECTED_F_VERSION) {
+            throw new Error(`logswap: F manager at ${c.addresses.fPoolManager} reports version ${gotF}, but this SDK needs ` +
+                `at least F version ${EXPECTED_F_VERSION}. Upgrade the deployment or point at a newer one.`);
+        }
+    }
+}

package/dist/fpool.d.ts

@@ -0,0 +1,416 @@
+/**
+ * fpool.ts — the `FPoolManager` surface: n bases, one quote, one shared floor.
+ *
+ * The other primitive. `CPoolManager` gives every position its own floor on a tick ladder;
+ * `FPoolManager` gives every share the SAME floor and deletes the ladder, the accumulators and the
+ * per-position accounting with it. Reading the two side by side is the fastest way to understand
+ * either (logswap-docs:docs/multi/f-pool.md).
+ *
+ * **A pool is an ID, not an address.** Both primitives are singletons now, so neither has a
+ * per-pool deployment — but they are addressed differently and for a reason. The C manager rides
+ * its whole `PoolKey` in calldata because that key is small, fixed and wholly needed. An F-pool
+ * key is variable-length and only ever partially needed (no swap path is O(n)), so it is stored
+ * once at `initialize` and every later call names `(poolId, j)`. Callers hold a `bytes32`.
+ *
+ * **Two products, one contract.** The basket (n > 1, public authority) and the launch (n = 1, the
+ * creator alone on the lever) are the same bytecode under different settings — what separates them
+ * is who holds `authority` and how many bases there are, and nothing in the maths. `describeFPool`
+ * below reports which shape a given pool is, because a UI has to decide what to render.
+ *
+ * **Zaps live on the ROUTER, not here.** Permit2 is AllowanceTransfer mode, whose standing
+ * allowance is keyed by spender, so a second router would cost the user an allowance per token
+ * twice, forever. One router is one spender — see `fPoolZapIn`/`fPoolZapOut` below, which target
+ * `addresses.router`.
+ */
+import { type Address, type Hash, type Hex } from "viem";
+import type { LogswapClient } from "./client.js";
+/** Everything scalar about a basket pool, in one round trip's worth of reads. */
+export interface FPoolState {
+    /** The pool's id — the hash of its key. There is no per-pool address. */
+    poolId: Hex;
+    quote: Address;
+    bases: Address[];
+    /** WAD weights, summing to WAD. `L_j = w_j · L`. */
+    weights: bigint[];
+    /** Per-asset log prices, WAD. Price is derived; `x` is the state. */
+    x: bigint[];
+    /** Quote reserve. The one leg a base→quote swap can exhaust. */
+    Q: bigint;
+    /** Total exposure. Grows on mint, shrinks on burn; never moves on a swap. */
+    L: bigint;
+    /** Fixed fee, WAD. At or above `FEE_MIN` — a zero-fee basket is not constructible. */
+    phi: bigint;
+    /** The strike: θ at seeding, and the fees-only harvest bound. */
+    theta0: bigint;
+    /** θ = X − Q/L, the shared floor. Derived from the holdings, never stored. */
+    theta: bigint;
+    /** X = Σ w_j x_j, the composite index. */
+    compositeX: bigint;
+    /** Σ = ∫ Σ_j w_j (dx_j)², accrued even though the fee is fixed — the kernel stays calculable. */
+    bigSigma: bigint;
+    /** Creator (private) or a governance contract (public). Holds the floor lever. */
+    authority: Address;
+    /** The proposed next authority, until it accepts — zero when nothing is pending (decisions 020). */
+    pendingAuthority: Address;
+    /** The desk's hot key (`ma-private.md` §6): may reshape composition, never move value out. Zero when none. */
+    operator: Address;
+    /** The sponsor's own label for this pool, mutable and never identity. "" when unnamed. */
+    name: string;
+    /** `harvest` may not take Q/L under this (WAD log-distance); raise-only (decisions 021). */
+    minBuffer: bigint;
+    /** Only `allowed` accounts may receive minted shares. */
+    gateMint: boolean;
+    /** Only `allowed` takers may swap. */
+    gateSwap: boolean;
+    /** The block of the last lever / composition action: no swap runs in it. */
+    restructureBlock: number;
+    /** Whether harvest is bounded by θ ≤ θ₀ — income only, never the floor's backing. */
+    feesOnly: boolean;
+    seeded: boolean;
+    dissolved: boolean;
+    totalSupply: bigint;
+    /** Base holdings the state implies, `R_j = w_j·L·e^{−x_j}`. */
+    reserves: bigint[];
+}
+/** Read a basket pool whole. Batched — viem multicalls these when the transport allows. */
+export declare function getFPool(c: LogswapClient, poolId: Hex): Promise<FPoolState>;
+/** Which of the two products a pool is configured as. A UI has to choose what to render. */
+export type FPoolShape = "launch" | "basket";
+export interface FPoolDescription {
+    shape: FPoolShape;
+    /** n = 1 with a private authority is the launch shape (f-pool §6.5). */
+    legs: number;
+    /** True when the pool holds no quote: an all-base resting ask. base→quote is the one blocked path. */
+    atFloor: boolean;
+    /** Fee income earned per unit L so far, `θ₀ − θ` with the lever's displacement backed out. */
+    feePerL: bigint;
+    /** The model-free LP edge, `F − ½Σ`. Exact at any n: V is separable in the logs. */
+    edgePerL: bigint;
+}
+export declare function describeFPool(c: LogswapClient, s: FPoolState): Promise<FPoolDescription>;
+/** `p_j = e^{x_j}`, lossy the way any float conversion is. Compare in log space when it matters. */
+export declare function fPoolPriceOf(x: bigint, scale?: number): number;
+/** Value per share at the pool's own marks. `V = L + Q`, so this is just that, pro-rated. */
+export declare function fPoolShareValue(s: FPoolState): bigint;
+export interface FPoolSwapArgs {
+    poolId: Hex;
+    /** Leg index into `bases`. */
+    j: number;
+    amountIn: bigint;
+    minOut?: bigint;
+    /** Who receives the out leg. Defaults to the account. */
+    to?: Address;
+    /** Absolute unix seconds. Defaulted to a bounded window, as every router write is. */
+    deadline?: bigint;
+    account: Address;
+}
+export declare function fPoolSwapQuoteIn(c: LogswapClient, a: FPoolSwapArgs): Promise<`0x${string}`>;
+export declare function fPoolSwapBaseIn(c: LogswapClient, a: FPoolSwapArgs): Promise<`0x${string}`>;
+/**
+ * Base j → base k. Needs no quote, works at Q = 0, and cannot cross the floor: X is held
+ * exactly up to the in-kind fee. Note it moves BOTH quote prices — p_j down, p_k up — because the
+ * pool has one coordinate per asset and every trade moves at least one.
+ */
+export declare function fPoolSwapBaseForBase(c: LogswapClient, a: FPoolSwapArgs & {
+    k: number;
+}): Promise<`0x${string}`>;
+/** Deposit dL/L of every reserve, receive shares ∝ dL. θ is untouched by construction. */
+export declare function fPoolMint(c: LogswapClient, a: {
+    poolId: Hex;
+    dL: bigint;
+    maxQuoteIn?: bigint;
+    account: Address;
+    to?: Address;
+}): Promise<`0x${string}`>;
+/**
+ * Burn shares for the pro-rata slice of every reserve. Available at any Q, and after dissolution.
+ * By owner since contracts `c782811` (decisions 019): the account burns its own shares; an
+ * operator may pass another owner's address, as on the C manager's `burnById`.
+ */
+export declare function fPoolBurn(c: LogswapClient, a: {
+    poolId: Hex;
+    shares: bigint;
+    minQuoteOut?: bigint;
+    account: Address;
+    owner?: Address;
+}): Promise<`0x${string}`>;
+/**
+ * Quote needed to zap into exposure `dL`. An UPPER bound: buying each leg raises its mark, so the
+ * mint consumes less base than was bought for it and every zap ends with a refund. Size from this
+ * and expect change back — do not treat it as exact.
+ */
+export declare function fPoolPreviewZapIn(c: LogswapClient, poolId: Hex, dL: bigint): Promise<bigint>;
+/**
+ * Buy `dL` of the basket with quote alone.
+ *
+ * The imbalanced part goes through the pool's own curve before anything is minted. That is not a
+ * penalty: minting against a quote-only deposit would be a zero-slippage, zero-fee swap at stale
+ * spot, paid for by the existing LPs — 27.4% in f-pool §6's worked example. Routing it through
+ * the curve deletes the subsidy and hands the fee and impact to the incumbents instead.
+ */
+export declare function fPoolZapIn(c: LogswapClient, a: {
+    poolId: Hex;
+    dL: bigint;
+    maxQuoteIn: bigint;
+    minShares?: bigint;
+    to?: Address;
+    account: Address;
+    deadline?: bigint;
+}): Promise<`0x${string}`>;
+/**
+ * Sell shares into ONE token — the quote, or any base.
+ *
+ * Into a base the other legs route through `swapBaseForBase`, which needs no quote and cannot
+ * cross the floor; only the burn's own quote slice touches the quote leg. Into the quote every
+ * base leg is sold, which is the one path a drained quote leg can block.
+ */
+export declare function fPoolZapOut(c: LogswapClient, a: {
+    poolId: Hex;
+    shares: bigint;
+    tokenOut: Address;
+    minOut?: bigint;
+    to?: Address;
+    account: Address;
+    deadline?: bigint;
+}): Promise<`0x${string}`>;
+/**
+ * Remove quote, lifting θ — price-neutral, pro-rata, no base moves. Under `feesOnly` the lift
+ * stops at θ₀, so the authority extracts income and never the proceeds backing the floor.
+ */
+export declare function fPoolHarvest(c: LogswapClient, a: {
+    poolId: Hex;
+    amount: bigint;
+    to?: Address;
+    account: Address;
+}): Promise<`0x${string}`>;
+/** 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`? */
+export declare function fPoolManagerAllowanceOk(c: LogswapClient, token: Address, owner: Address, need: bigint): Promise<boolean>;
+export declare function isRouterOperatorForFPool(c: LogswapClient, owner: Address): Promise<boolean>;
+/** Approve the router to move this account's F-pool shares. Needed once, before any `fPoolZapOut`. */
+export declare function approveRouterForFPool(c: LogswapClient, account: Address): Promise<`0x${string}`>;
+/** The ERC-6909 id carrying a pool's shares. Bit 255 set. */
+export declare function fPoolShareId(poolId: Hex): bigint;
+/** The ERC-6909 id carrying claims on a token. Bit 255 clear, so it can never meet a share id. */
+export declare function fPoolClaimId(token: Address): bigint;
+export declare function fPoolShareBalance(c: LogswapClient, poolId: Hex, owner: Address): Promise<bigint>;
+export declare function fPoolClaimBalance(c: LogswapClient, token: Address, owner: Address): Promise<bigint>;
+export declare enum FPoolQuoteKind {
+    QuoteIn = 0,
+    BaseIn = 1,
+    BaseForBase = 2
+}
+/**
+ * An EXACT quote — what execution returns, not an estimate.
+ *
+ * `quoteSwap` runs the real swap and reverts with the answer, so the value has to be decoded out
+ * of the revert rather than returned. That is the point of the pattern: there is no second pricing
+ * path to drift from the first. It needs no tokens, no approvals and no balance, so it works from
+ * a disconnected wallet — unlike `fPoolPreviewZapIn`, which is a genuine upper bound.
+ */
+export declare function fPoolQuoteSwap(c: LogswapClient, a: {
+    poolId: Hex;
+    kind: FPoolQuoteKind;
+    j: number;
+    k?: number;
+    amountIn: bigint;
+    taker?: Address;
+}): Promise<bigint>;
+export interface FPoolCreateArgs {
+    quote: Address;
+    /** Legs in any order; sorted (with weights and marks kept aligned) before the call. */
+    bases: Address[];
+    /** WAD each; must sum to 1e18 — validated here so the revert is readable. */
+    weights: bigint[];
+    /** Fixed fee, WAD. The base-for-base fee is pinned at 2φ on-chain. */
+    phi: bigint;
+    /** true: the authority's harvest stops at the seed strike θ₀ (the launch posture). */
+    feesOnly: boolean;
+    authority: Address;
+    /**
+     * The differentiator, and nothing else. Identity is the key's hash, so one sponsor cannot run
+     * two pools of the same shape without varying it — the second `initialize` would land on the
+     * first pool's id. Defaults to zero, which is the first book of any shape. A pool's NAME is not
+     * this: names are mutable state (`fPoolSetName`), so a rename forks nothing.
+     */
+    salt?: Hex;
+    account: Address;
+}
+/** `bytes32` ⇄ short UTF-8 text, for the pool and sponsor labels. */
+export declare function textToBytes32(text: string): Hex;
+export declare function bytes32ToText(word: Hex): string;
+/** Sort legs by base address (the key's canonical order), carrying companion arrays along. */
+export declare function sortFPoolLegs<T>(bases: Address[], ...companions: T[][]): {
+    bases: Address[];
+    companions: T[][];
+};
+/** Create the pool (no funds move — `seed` arms it). Returns the tx hash; read the id with `fPoolIdOf`. */
+export declare function fPoolInitialize(c: LogswapClient, a: FPoolCreateArgs): Promise<`0x${string}`>;
+/** The pool id is the key's hash — pure, so it can be read before or after creation. */
+export declare function fPoolIdOf(c: LogswapClient, a: Omit<FPoolCreateArgs, "account">): Promise<Hex>;
+/**
+ * Arm the pool: deposit the full basket at marks `x0` plus `Q0` of quote. Authority-only on-chain
+ * (an open seed lets anyone front-run the creator for the strike). `x0` must align with the
+ * SORTED bases — use {@link sortFPoolLegs} on (bases, weights, x0) together when building forms.
+ */
+export declare function fPoolSeed(c: LogswapClient, a: {
+    poolId: Hex;
+    L0: bigint;
+    x0: bigint[];
+    Q0: bigint;
+    account: Address;
+}): Promise<`0x${string}`>;
+/** End of life. Gated on-chain to the authority and to Q at dust (the raise is not abortable). */
+export declare function fPoolDissolve(c: LogswapClient, a: {
+    poolId: Hex;
+    account: Address;
+}): Promise<`0x${string}`>;
+/**
+ * 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.
+ * Indexed on-chain via AuthorityProposed.
+ */
+export declare function fPoolProposeAuthority(c: LogswapClient, a: {
+    poolId: Hex;
+    next: Address;
+    account: Address;
+}): Promise<`0x${string}`>;
+/** Accept a pending proposal — step two; only the proposed address can. Indexed via AuthoritySet. */
+export declare function fPoolAcceptAuthority(c: LogswapClient, a: {
+    poolId: Hex;
+    account: Address;
+}): Promise<`0x${string}`>;
+/** `setLegL`'s "keep the stored mark" sentinel — the only legal `x` for a live leg. */
+export declare const NO_X: bigint;
+/** Turn the mint / swap gates on or off (authority). `burn` is never gated. */
+export declare function fPoolSetGates(c: LogswapClient, a: {
+    poolId: Hex;
+    gateMint: boolean;
+    gateSwap: boolean;
+    account: Address;
+}): Promise<`0x${string}`>;
+/** Add to or remove from the pool's list, in one call (authority). */
+export declare function fPoolSetAllowed(c: LogswapClient, a: {
+    poolId: Hex;
+    who: readonly Address[];
+    allowed: boolean;
+    account: Address;
+}): Promise<`0x${string}`>;
+/** Whether `who` is on the pool's list (consulted only while a gate is on). */
+export declare function fPoolIsAllowed(c: LogswapClient, poolId: Hex, who: Address): Promise<boolean>;
+/** Label the pool — the sponsor's own words, mutable, never identity. At most 31 bytes of UTF-8. */
+export declare function fPoolSetName(c: LogswapClient, a: {
+    poolId: Hex;
+    name: string;
+    account: Address;
+}): Promise<`0x${string}`>;
+/**
+ * What the PROTOCOL says an address is — "Keyrock". Only `feeCollector` may write it, which is
+ * what makes it an attestation rather than a claim anyone could make about themselves.
+ */
+export declare function fPoolSetSponsorName(c: LogswapClient, a: {
+    who: Address;
+    name: string;
+    account: Address;
+}): Promise<`0x${string}`>;
+/** The protocol's attestation for an address, or "" when unattested — which most addresses are. */
+export declare function fPoolSponsorName(c: LogswapClient, who: Address): Promise<string>;
+/** Appoint (or clear, with the zero address) the operator — the hot key that reshapes and never moves value out. */
+export declare function fPoolAppointOperator(c: LogswapClient, a: {
+    poolId: Hex;
+    operator: Address;
+    account: Address;
+}): Promise<`0x${string}`>;
+/**
+ * Raise the floor guard: `harvest` may not take Q/L under `minBuffer` (WAD log-distance; 20% below
+ * spot is ln 1.25 ≈ 0.223e18). Raise-only — a commitment the authority cannot walk back.
+ */
+export declare function fPoolRaiseMinBuffer(c: LogswapClient, a: {
+    poolId: Hex;
+    minBuffer: bigint;
+    account: Address;
+}): Promise<`0x${string}`>;
+/**
+ * Set leg `j`'s liquidity (operator, sole LP only): grow, shrink, retire (`newLj = 0`), or re-admit
+ * a retired leg at a named mark `x`. For a live leg leave `x` undefined — its mark is the market's.
+ * The base moves single-sidedly through the lock; shares adjust to hold the share value.
+ */
+export declare function fPoolSetLegL(c: LogswapClient, a: {
+    poolId: Hex;
+    j: number;
+    newLj: bigint;
+    x?: bigint;
+    account: Address;
+}): Promise<`0x${string}`>;
+/** Admit a base the pool has never held, at a named mark, with liquidity `Lj` (operator, sole LP only). */
+export declare function fPoolAdmitLeg(c: LogswapClient, a: {
+    poolId: Hex;
+    base: Address;
+    Lj: bigint;
+    x: bigint;
+    account: Address;
+}): Promise<`0x${string}`>;
+/**
+ * Move shares (ERC-6909 `transfer`) — to another holder, or to `0xdead` to lock them for good.
+ * Burning to the dead address is a sponsor's way to make its liquidity permanent: the shares can
+ * never be redeemed, and they never count against the sole-LP precondition.
+ */
+export declare function fPoolTransferShares(c: LogswapClient, a: {
+    poolId: Hex;
+    to: Address;
+    shares: bigint;
+    account: Address;
+}): Promise<`0x${string}`>;
+export interface DiscoveredFPool {
+    poolId: Hex;
+    quote: Address;
+    bases: Address[];
+    weights: bigint[];
+    phi: bigint;
+    feesOnly: boolean;
+    authority: Address;
+    /** The block the pool was initialized in — its age, for annualising realized income. */
+    block: bigint;
+    /** Whether `seed` has run; an unseeded pool has no floor and no float, so nothing to show. */
+    seeded: boolean;
+    /** The quote the pool was born with. Zero is the launchpad's signature (launchpad.md §3). */
+    q0: bigint;
+    /**
+     * The PRODUCT the pool is, by the spec's definition rather than a guess: a LAUNCH is one asset
+     * born at Q = 0 — a resting ask under a token, nothing raised, the creator alone on the lever;
+     * everything else is a liquidity BASKET (public, quote-funded). Read from the Seeded log, so a
+     * one-asset pool seeded WITH quote files correctly as liquidity, not as a pad.
+     */
+    shape: FPoolShape;
+}
+/**
+ * Every F pool ever created, from `Initialize` logs alone. Possible only because the event
+ * carries the full key preimage (bases, weights, phi, feesOnly) — the poolId is a hash and could
+ * never be inverted; contracts PR #17 exists for exactly this call.
+ */
+export declare function discoverFPools(c: LogswapClient, opts?: {
+    fromBlock?: bigint;
+    toBlock?: bigint;
+}): Promise<DiscoveredFPool[]>;
+/**
+ * Every holder of a pool's shares, from the ERC-6909 Transfer stream — the id is an indexed
+ * topic, so one filtered log query aggregates the whole ledger. The 0xdead entry is the
+ * MIN_SHARES lock from seeding; callers usually label rather than hide it.
+ */
+export declare function fPoolShareHolders(c: LogswapClient, poolIdHex: Hex, opts?: {
+    fromBlock?: bigint;
+}): Promise<Array<{
+    holder: Address;
+    shares: bigint;
+}>>;
+/** Every F pool's state in one lens call (the raw manager struct: quote, phi, authority, feesOnly, seeded, dissolved, n, Q, L, shares, theta0, bigSigma, leverTheta). */
+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>;