@ixo/openhands-sdk 0.0.0-stage → 0.1.0

package/dist/esm/campaign/pledges.js

@@ -0,0 +1,210 @@
+/**
+ * Who has promised what against which spot.
+ *
+ * **A pledge is not money moved.** It is a capped, expiring, revocable
+ * allowance on the backer's own account, and the campaign draws against it
+ * only at the moment a cleanup ask is posted. So this file records
+ * *allocations* — which spot a backer meant their allowance for — while the
+ * chain remains the authority on how much they can actually cover.
+ *
+ * The split is forced rather than chosen. Cosmos authz keeps **one**
+ * `SendAuthorization` per (granter, grantee, message type): a second grant
+ * overwrites the first, and its `allowList` cannot name an escrow account
+ * that does not exist until posting. So a backer's grant is their *campaign
+ * total*, chain-verified and enumerable, and the per-spot split is ours to
+ * keep — bounded at every turn by what the chain says they still have.
+ *
+ * The recovery path if this ledger is ever lost: every pledge's own
+ * `MsgGrant` carries `<campaign>:pledge:<claimId>` in its memo, so the
+ * allocations can be rebuilt from the chain's own history.
+ */
+export const emptyLedger = () => ({ v: 1, pledges: [] });
+/**
+ * The grant's own receipt, now complete. Three parts said *which spot*; the
+ * chain probe that made this format load-bearing found the fourth was owed:
+ * the authorization inside a MsgGrant is stored as raw proto bytes on the
+ * index, so a rebuilt ledger cannot read amounts out of grant history — and
+ * a backer's grant is a cumulative TOTAL besides. The memo carries the one
+ * number the chain cannot cheaply answer. A memo that lies about it is
+ * self-defeating: every draw is bounded by the live allowance at round time.
+ */
+export const memo = (campaign, claimId, amountBase) => `${campaign}:pledge:${claimId}:${Math.floor(amountBase)}`;
+const MEMO_SHAPE = /^([a-z0-9-]{1,64}):pledge:(bafk[a-z2-7]{20,}):([1-9][0-9]{0,18})$/;
+/** A pledge memo, read back — or null for anything else a memo might say. */
+export function parsePledgeMemo(text) {
+    const found = MEMO_SHAPE.exec((text ?? "").trim());
+    if (!found)
+        return null;
+    const amountBase = Number(found[3]);
+    return Number.isSafeInteger(amountBase) ? { campaign: found[1], claimId: found[2], amountBase } : null;
+}
+/**
+ * A card purchase's receipt, written on the chain that delivered it.
+ *
+ * The webhook's own memory is one serverless instance's `Set`, and Stripe
+ * retries land wherever the platform puts them — so a cold instance would
+ * happily pay a second time for one payment. The chain already remembers
+ * every send the treasury ever made; naming the Stripe session in the memo
+ * turns that history into the idempotency key, durable and free.
+ *
+ * When the purchase was for a spot, the campaign and pin ride along: a
+ * buyer whose tab died between paying and pledging can have the pledge
+ * finished from chain history alone, by them or by an operator.
+ */
+export const boughtMemo = (sessionId, spot) => spot ? `bought:${sessionId}:${spot.campaign}:${spot.claimId}` : `bought:${sessionId}`;
+/**
+ * A backing: money sent to a pin's own pool, and who sent it.
+ *
+ * `bought:` above says PAY was delivered to somebody's key. This says it was
+ * paid into a cleanup's pot, where nobody can take it back — a different
+ * fact, so a different word, and the `by:` tail is what lets a signed-in
+ * backer's credential cite the transaction that proves it. Anonymous
+ * backing is the same memo without the tail, which is why the tail is
+ * optional rather than a second shape.
+ */
+export const backedMemo = (sessionId, spot, backer) => `backed:${sessionId}:${spot.campaign}:${spot.claimId}${backer ? `:by:${backer}` : ""}`;
+/**
+ * The same fact when the money came from a wallet instead of a card.
+ *
+ * A sponsor with PAY in their account sends it into the pool themselves.
+ * There is no Stripe session to name, so the first field carries a nonce
+ * instead — which exists only so two allocations to the same pin from the
+ * same account are distinguishable transactions. It is not a secret and
+ * nothing looks it up.
+ *
+ * **One grammar, not two.** A second memo shape would be a second thing to
+ * keep in step, and this file has watched that go wrong: the `by:` tail is
+ * optional precisely so the card path and this one cannot drift apart. A
+ * wallet backing always names its backer — an organisation's allocation is
+ * never anonymous — but the *grammar* leaves the tail optional, because the
+ * card path still needs it that way.
+ */
+export const walletBackedMemo = (nonce, spot, backer) => `backed:w-${nonce}:${spot.campaign}:${spot.claimId}:by:${backer}`;
+/** Sixteen random bytes as hex — the nonce `walletBackedMemo` wants. */
+export function backingNonce() {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    return [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+const BACKED_SHAPE = /^backed:(cs_(?:test|live)_[A-Za-z0-9]{10,}|w-[0-9a-f]{32}):([a-z0-9-]{1,64}):(bafk[a-z2-7]{20,})(?::by:(ixo1[0-9a-z]{38}))?$/;
+export function parseBackedMemo(text) {
+    const found = BACKED_SHAPE.exec((text ?? "").trim());
+    if (!found)
+        return null;
+    return { sessionId: found[1], campaign: found[2], claimId: found[3], ...(found[4] ? { backer: found[4] } : {}) };
+}
+/**
+ * Money going back out of a pool to the account that put it in.
+ *
+ * Written by the pool pass when a pin's ask has lapsed untried, or the pin
+ * was reported gone, and the rule says the pool is returned. Read by the
+ * sponsor's own dashboard, which asks what came *back* to it — so the memo
+ * names the campaign, the pin and the account, and the reader checks all
+ * three: anybody can send a coin to a sponsor with the word `refund` on it,
+ * and the dashboard must not count that as the campaign returning money.
+ *
+ * Built and parsed here, beside the backing memo it answers, for the reason
+ * that whole file gives: one grammar in one place cannot drift.
+ */
+export const refundMemo = (campaign, claimId, backer) => `refund:${campaign}:${claimId}:${backer}`;
+const REFUND_SHAPE = /^refund:([a-z0-9-]{1,64}):(bafk[a-z2-7]{20,}):(ixo1[0-9a-z]{38})$/;
+export function parseRefundMemo(text) {
+    const found = REFUND_SHAPE.exec((text ?? "").trim());
+    return found ? { campaign: found[1], claimId: found[2], backer: found[3] } : null;
+}
+/**
+ * A card payment contested through the payer's bank, and the money coming
+ * back out of the pot it went into.
+ *
+ * When a dispute lands, whatever that backing still has in the pot is
+ * drawn back to the campaign before it can pay anybody — so we never pay a
+ * cleaner and lose the charge as well. The memo names the Stripe session,
+ * which is the same thing the `backed:` memo named on the way in, so the
+ * two halves of one payment's life can be read off the chain by anybody.
+ *
+ * `restored:` is the other direction: a dispute we won, whose money goes
+ * back into the pot it was taken from. Both are written by the campaign
+ * key in the pool pass — never by the web app, which does not hold it.
+ */
+export const disputeMemo = (sessionId, campaign, claimId) => `dispute:${sessionId}:${campaign}:${claimId}`;
+export const restoredMemo = (sessionId, campaign, claimId) => `restored:${sessionId}:${campaign}:${claimId}`;
+const DISPUTE_SHAPE = /^(dispute|restored):(cs_(?:test|live)_[A-Za-z0-9]{10,}):([a-z0-9-]{1,64}):(bafk[a-z2-7]{20,})$/;
+export function parseDisputeMemo(text) {
+    const found = DISPUTE_SHAPE.exec((text ?? "").trim());
+    return found ? { kind: found[1], sessionId: found[2], campaign: found[3], claimId: found[4] } : null;
+}
+/* Two shapes, one grammar: with a spot and without, the tail optional so the
+   pair can never drift apart. Session ids are Stripe's own alphabet. */
+const BOUGHT_SHAPE = /^bought:(cs_(?:test|live)_[A-Za-z0-9]{10,})(?::([a-z0-9-]{1,64}):(bafk[a-z2-7]{20,}))?$/;
+export function parseBoughtMemo(text) {
+    const found = BOUGHT_SHAPE.exec((text ?? "").trim());
+    if (!found)
+        return null;
+    const sessionId = found[1];
+    return found[2] && found[3] ? { sessionId, campaign: found[2], claimId: found[3] } : { sessionId };
+}
+/**
+ * Taking a backing back.
+ *
+ * The chain keeps ONE `SendAuthorization` per (granter, grantee, message
+ * type), so there is no such thing as revoking one pledge: a backer who has
+ * put money behind three spots holds a single grant covering all of them.
+ * Undoing one of them means signing a *new* grant for the smaller total —
+ * and then saying, in the memo, which allocation the difference came out of.
+ *
+ * Without that sentence the round would see only a shrunken cap and would
+ * have to guess which spot lost its money, which is exactly the guess that
+ * turns "I took back the one I changed my mind about" into "the pass dropped
+ * my oldest pledge instead".
+ *
+ * The same self-defeating arithmetic as a pledge protects it: an unpledge
+ * that lies about its amount only ever reduces what the liar themselves can
+ * cover, and the live allowance still bounds every draw.
+ */
+export const unpledgeMemo = (campaign, claimId, amountBase) => `${campaign}:unpledge:${claimId}:${Math.floor(amountBase)}`;
+const UNPLEDGE_SHAPE = /^([a-z0-9-]{1,64}):unpledge:(bafk[a-z2-7]{20,}):([1-9][0-9]{0,18})$/;
+export function parseUnpledgeMemo(text) {
+    const found = UNPLEDGE_SHAPE.exec((text ?? "").trim());
+    if (!found)
+        return null;
+    const amountBase = Number(found[3]);
+    return Number.isSafeInteger(amountBase) ? { campaign: found[1], claimId: found[2], amountBase } : null;
+}
+/**
+ * The other sentence the grammar speaks: a poster's standing fund for their
+ * own chain. No claimId and no amount, deliberately — the children this
+ * grant will fund do not exist yet, and the chain's live allowance is the
+ * only number that matters at spawn time. The tag is the parent's collection
+ * id, all digits: the namespace K1 reserved is what lets one regex know
+ * this is a chain's fund and not a campaign pledge.
+ */
+export const chainFundMemo = (tag) => `${tag}:chain`;
+const CHAIN_FUND_SHAPE = /^([0-9]{1,20}):chain$/;
+export function parseChainFundMemo(text) {
+    const found = CHAIN_FUND_SHAPE.exec((text ?? "").trim());
+    return found ? { tag: found[1] } : null;
+}
+/** What one backer has allocated and not yet had drawn or lapsed. */
+export function standingFor(ledger, backer) {
+    return ledger.pledges
+        .filter((one) => one.backer === backer && !one.lapsedAt && !one.drawnAt)
+        .reduce((sum, one) => sum + one.amountBase, 0);
+}
+/** What a spot has pledged against it, live. Never called "raised". */
+export function pledgedFor(ledger, claimId) {
+    return ledger.pledges
+        .filter((one) => one.claimId === claimId && !one.lapsedAt)
+        .reduce((sum, one) => sum + one.amountBase, 0);
+}
+/** The backers of one spot, oldest first — the order a draw follows. */
+export const backersFor = (ledger, claimId) => ledger.pledges.filter((one) => one.claimId === claimId && !one.lapsedAt && !one.drawnAt).sort((a, b) => a.at.localeCompare(b.at));
+/**
+ * May this backer allocate this much more?
+ *
+ * `capBase` comes from the chain and is the only authority. Everything else
+ * they have standing counts against it, because one grant covers them all.
+ */
+export function withinCap(ledger, backer, capBase, addBase) {
+    return standingFor(ledger, backer) + addBase <= capBase;
+}
+//# sourceMappingURL=pledges.js.map

package/dist/esm/campaign/pledges.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pledges.js","sourceRoot":"","sources":["../../../src/campaign/pledges.ts"],"names":[],"mappings":"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"}

package/dist/esm/campaign/pledgesChain.d.ts

@@ -0,0 +1,58 @@
+import { type Pledge } from "./pledges.ts";
+/**
+ * The pledge ledger, read from the only store that was ever really holding it.
+ *
+ * The file-backed ledger was built for one machine owning both halves of the
+ * campaign — the web app recording intentions, the funding pass reading them
+ * off the same disk. Deployed, there are three machines and no shared disk:
+ * Vercel's filesystem is read-only, the Worker's KV is written by nobody, and
+ * a backer's signature succeeded while the recording of what it was *for*
+ * quietly failed. Found on funding day of the dress rehearsal, by pledging.
+ *
+ * So the chain is the ledger. Every pledge's grant carries
+ * `<campaign>:pledge:<claimId>:<amountBase>` in its transaction memo — the
+ * recovery path pledges.ts always promised, made primary instead of
+ * emergency. This module derives the allocations from the index; what a
+ * backer can still *cover* stays a live allowance read at round time, exactly
+ * as before. Files demote to journals: worth writing, never load-bearing.
+ *
+ * A memo nobody can verify is a memo somebody will forge, so the arithmetic
+ * is self-defeating for liars: an inflated amount allocates money the live
+ * allowance will refuse to draw, and the round reports the spot short — the
+ * same loud failure a revoked pledge already earns.
+ */
+interface GrantRow {
+    granter: string | null | undefined;
+    memo: string | null | undefined;
+    time: string | null | undefined;
+}
+/**
+ * The pure half: rows in, allocations out — testable without a network.
+ *
+ * Two sentences are read here, in the order the chain wrote them. A pledge
+ * adds an allocation; an **unpledge** takes one back, and takes it from the
+ * OLDEST standing allocation that backer has against that pin. Oldest first
+ * because that is also draw order: money that was going to be spent first is
+ * the money a backer is asking not to spend.
+ *
+ * An unpledge for more than stands is clamped rather than refused. It cannot
+ * make a negative allocation, and there is no honest thing to do with the
+ * remainder — the backer already has nothing left there to take.
+ */
+export declare function pledgesFromGrantRows(rows: GrantRow[], campaign: string): Pledge[];
+/** Who stands behind a chain: granters whose memo names the parent's tag.
+ *  Pure, like its sibling — the rows are the same MsgGrant feed. */
+export declare function chainFundersFromRows(rows: GrantRow[], tag: string): {
+    granter: string;
+    at: string;
+}[];
+/** Every pledge allocation for a campaign, derived from grant memos. */
+export declare function pledgesFromChain(campaign: string, agent: string): Promise<Pledge[]>;
+/** Who stands behind a chain, live — the poster (and any co-sponsor) whose
+    standing grant carries the tag's fund memo. */
+export declare function chainFundersFromChain(tag: string, agent: string): Promise<{
+    granter: string;
+    at: string;
+}[]>;
+export {};
+//# sourceMappingURL=pledgesChain.d.ts.map

package/dist/esm/campaign/pledgesChain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pledgesChain.d.ts","sourceRoot":"","sources":["../../../src/campaign/pledgesChain.ts"],"names":[],"mappings":"AACA,OAAO,EAA0D,KAAK,MAAM,EAAE,MAAM,cAAc,CAAC;AAEnG;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,UAAU,QAAQ;IAChB,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACnC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAChC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CACjC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CA+BjF;AAED;oEACoE;AACpE,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,EAAE,CASrG;AAwCD,wEAAwE;AACxE,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAEzF;AAED;kDACkD;AAClD,wBAAsB,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,EAAE,CAAC,CAElH"}

package/dist/esm/campaign/pledgesChain.js

@@ -0,0 +1,96 @@
+import { gql } from "../data/gql.js";
+import { parseChainFundMemo, parsePledgeMemo, parseUnpledgeMemo } from "./pledges.js";
+/**
+ * The pure half: rows in, allocations out — testable without a network.
+ *
+ * Two sentences are read here, in the order the chain wrote them. A pledge
+ * adds an allocation; an **unpledge** takes one back, and takes it from the
+ * OLDEST standing allocation that backer has against that pin. Oldest first
+ * because that is also draw order: money that was going to be spent first is
+ * the money a backer is asking not to spend.
+ *
+ * An unpledge for more than stands is clamped rather than refused. It cannot
+ * make a negative allocation, and there is no honest thing to do with the
+ * remainder — the backer already has nothing left there to take.
+ */
+export function pledgesFromGrantRows(rows, campaign) {
+    const pledges = [];
+    /* One pass, in chain order, so an unpledge can only ever undo a pledge that
+       was already made — a memo cannot reach backwards past its own block. */
+    const ordered = [...rows].sort((a, b) => (a.time ?? "").localeCompare(b.time ?? ""));
+    for (const row of ordered) {
+        if (!row.granter)
+            continue;
+        const pledged = parsePledgeMemo(row.memo);
+        if (pledged && pledged.campaign === campaign) {
+            pledges.push({ backer: row.granter, claimId: pledged.claimId, amountBase: pledged.amountBase, at: row.time ?? "" });
+            continue;
+        }
+        const taken = parseUnpledgeMemo(row.memo);
+        if (!taken || taken.campaign !== campaign)
+            continue;
+        let owed = taken.amountBase;
+        for (const pledge of pledges) {
+            if (owed <= 0)
+                break;
+            if (pledge.backer !== row.granter || pledge.claimId !== taken.claimId)
+                continue;
+            const off = Math.min(pledge.amountBase, owed);
+            pledge.amountBase -= off;
+            owed -= off;
+        }
+    }
+    /* An allocation reduced to nothing is not an allocation. Dropping it here
+       rather than carrying a zero keeps every reader — the bar, the pass, the
+       backer's own ledger — from having to know about the subtraction at all. */
+    return pledges.filter((pledge) => pledge.amountBase > 0).sort((a, b) => a.at.localeCompare(b.at));
+}
+/** Who stands behind a chain: granters whose memo names the parent's tag.
+ *  Pure, like its sibling — the rows are the same MsgGrant feed. */
+export function chainFundersFromRows(rows, tag) {
+    const funders = [];
+    for (const row of rows) {
+        const parsed = parseChainFundMemo(row.memo);
+        if (!parsed || parsed.tag !== tag || !row.granter)
+            continue;
+        if (funders.some((one) => one.granter === row.granter))
+            continue;
+        funders.push({ granter: row.granter, at: row.time ?? "" });
+    }
+    return funders.sort((a, b) => a.at.localeCompare(b.at));
+}
+/* A campaign is a season; a thousand grants to one agent is an order of
+   magnitude past anything the rehearsal or the launch plan imagines. The
+   count is checked so growth past it is a loud line, not a silent slice. */
+const FIRST = 1000;
+/** One read of every grant made to this agent, as rows both pures accept. */
+async function grantRowsTo(agent) {
+    const data = await gql(`query {
+      messages(
+        filter: {typeUrl: {equalTo: "/cosmos.authz.v1beta1.MsgGrant"}, value: {contains: {grantee: ${JSON.stringify(agent)}}}},
+        orderBy: ID_ASC,
+        first: ${FIRST}
+      ) {
+        totalCount
+        nodes { value transactionByTransactionHash { memo time } }
+      }
+    }`);
+    if (data.messages.totalCount > FIRST) {
+        console.warn(`[pledges] ${data.messages.totalCount} grants to ${agent.slice(0, 12)}…. Past the ${FIRST} this read pages; add paging before trusting this round`);
+    }
+    return data.messages.nodes.map((node) => ({
+        granter: node.value?.granter,
+        memo: node.transactionByTransactionHash?.memo,
+        time: node.transactionByTransactionHash?.time
+    }));
+}
+/** Every pledge allocation for a campaign, derived from grant memos. */
+export async function pledgesFromChain(campaign, agent) {
+    return pledgesFromGrantRows(await grantRowsTo(agent), campaign);
+}
+/** Who stands behind a chain, live — the poster (and any co-sponsor) whose
+    standing grant carries the tag's fund memo. */
+export async function chainFundersFromChain(tag, agent) {
+    return chainFundersFromRows(await grantRowsTo(agent), tag);
+}
+//# sourceMappingURL=pledgesChain.js.map

package/dist/esm/campaign/pledgesChain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pledgesChain.js","sourceRoot":"","sources":["../../../src/campaign/pledgesChain.ts"],"names":[],"mappings":"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"}

package/dist/esm/campaign/pool.d.ts

@@ -0,0 +1,137 @@
+/**
+ * What a cleanup is worth right now — the pool.
+ *
+ * **A pool is an ask's own admin account.** The chain pays an approval from
+ * `Payment.account`, which for every ask this estate posts is the entity's
+ * admin account; so money sent to that address after the ask was posted is
+ * money the next approval can pay out. That one fact is what replaced a
+ * price table: nobody has to guess what a truckload is worth in Lagos, the
+ * pool is whatever people put in it, and the checker pays it.
+ *
+ * The arithmetic here is shared on purpose. The map draws it, the youth app
+ * shows it on a sheet before somebody backs it, and the checker pays from
+ * it — three readers who must never disagree about what a cleaner would get.
+ */
+/** 1 unit = 1e6 base. */
+export declare const MICRO = 1000000;
+export interface PoolReads {
+    /** The admin account's balance in the ask's denom, base units. */
+    balanceBase: number;
+    /**
+     * The collection's quota, and how many of its claims have been decided.
+     *
+     * `evaluated`, not `count`. The chain counts a claim the moment it is
+     * submitted, but a submitted claim has not been paid yet — its legs are
+     * still owed. Reading `count` here made a pool look bigger than it was by
+     * exactly one claim's legs, which is the kind of arithmetic that pays out
+     * money the next verdict then cannot find. Both numbers ride on the
+     * collection; this is the one that means "already paid for".
+     */
+    quota: number;
+    evaluated: number;
+    /** The ask's own legs, read from its `payments` — never from a constant. */
+    checkRewardBase: number;
+    approvalLegBase: number;
+}
+/**
+ * What a cleaner would be paid if the checker approved right now.
+ *
+ * **Not the balance.** The same account pays the evaluation leg of every
+ * claim still undecided, and the approval floor with it. A custom amount
+ * that spent those would make the next verdict fail for want of funds —
+ * the checker would have approved somebody's work into an error. So the
+ * legs of every undecided claim are held back, and what is left is the
+ * pool.
+ *
+ * `quota - evaluated` is the honest reading of "still owed": every slot that
+ * has not been decided may yet cost this account an evaluation leg and an
+ * approval floor, whether its claim has been submitted or is still to come.
+ */
+export declare function poolAvailable(reads: PoolReads): number;
+/**
+ * How a pool divides between the people who cleared patches of one site.
+ *
+ * By count, not by volume: a split by how much waste somebody says they
+ * carried is a split decided by a sentence, and one enormous bag would take
+ * the site. A patch is a patch — you photographed a piece of ground before
+ * and after and the checker agreed. The remainder goes to the last share so
+ * the sum is exactly the pool: base units are indivisible, and money that
+ * stayed behind in the account because of rounding would sit there forever.
+ */
+export declare function shares(poolBase: number, patches: number): number[];
+/**
+ * Split `total` in proportion to `weights` — the shape a refund needs.
+ *
+ * `shares` above divides **equally**, which is right for a site's patches:
+ * one patch is one patch. It is wrong for money going back to the people who
+ * put it in, where somebody who paid forty dollars and somebody who paid two
+ * must not be handed the same amount. Two functions rather than one flag,
+ * because the two callers mean genuinely different things and a boolean
+ * argument at a call site says neither of them out loud.
+ *
+ * Largest remainder: floor every share, then hand the leftover base units out
+ * one at a time, biggest remainder first, ties to whoever came first. The
+ * parts sum to exactly `total` — a refund that strands base units in a pool
+ * leaves a pot that reads as still funded to every screen that looks.
+ *
+ * **In integers, not doubles.** Both `total` and every weight are base units,
+ * and `total × weight` leaves a double's exact range long before the money
+ * is unusual — a pool of a million PAY against a contribution of the same
+ * size is 10²⁴. A floor taken on a rounded product can come out one high,
+ * and then the parts sum to one MORE than the pool, which is a send the
+ * chain refuses or a leg the ask no longer has. BigInt does not round.
+ * Weights that are not whole base units (fractions, NaN, negatives) read as
+ * nothing owed.
+ */
+export declare function sharesBy(total: number, weights: number[]): number[];
+/**
+ * What a send was worth in one denom, base units.
+ *
+ * A `MsgSend` carries a *list* of coins, and reading the first of them — which
+ * is what every reader of the index here used to do — takes whatever happened
+ * to be sent first: one `uixo`, or a token somebody minted for free, and
+ * calls it a backing. Money in a pool is the ask's own denom and nothing
+ * else; a coin in any other denom is worth nothing to the pool, and a memo
+ * on it buys its sender nothing. An amount that is not a whole, safe, positive
+ * integer is not money either.
+ */
+export declare function amountIn(coins: unknown, denom: string): number;
+/**
+ * How much room a site has left, as a sentence's worth of facts.
+ *
+ * "How many of us does this take?" is the first thing somebody asks in front
+ * of a truckload, and the answer moves: a site opens with a band's worth of
+ * patches because every slot is a checker's fee paid up front, and the pool
+ * pass widens it as people turn up. So the three cases are genuinely
+ * different sentences — nobody yet, some room left, none right now — and the
+ * last one is temporary, which is why it is not called "closed".
+ *
+ * Returns the case and its number; the words belong to whichever app is
+ * asking, in its own voice.
+ */
+export declare function crewRoom(reads: {
+    max: number;
+    taken: number;
+}): {
+    room: "all" | "some" | "none";
+    n: number;
+};
+/** The pool as a person would say it — "$12", "40c", "nothing yet". */
+export declare function poolPhrase(poolBase: number): string;
+/**
+ * A pin's pot, read from the chain right now — no cache in the way.
+ *
+ * The map reads every pool in one batch behind a thirty-second cache, which
+ * is right for drawing two hundred pins and wrong for the one screen a
+ * person is looking at while their own money lands. A card payment reaches
+ * the pool in under a minute and the sheet showed the old number until it
+ * was reloaded by hand; that is the whole reason this exists separately.
+ *
+ * Two reads and no fold: the collection for its legs and counters, the bank
+ * for the balance. Cheap enough to do on every open sheet.
+ */
+export declare function livePool(collectionId: string): Promise<{
+    poolBase: number;
+    poolAddress: string;
+} | null>;
+//# sourceMappingURL=pool.d.ts.map

package/dist/esm/campaign/pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../../../src/campaign/pool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,yBAAyB;AACzB,eAAO,MAAM,KAAK,UAAY,CAAC;AAE/B,MAAM,WAAW,SAAS;IACxB,kEAAkE;IAClE,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;;;;;OASG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,4EAA4E;IAC5E,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAItD;AAED;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAMlE;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAyBnE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAS9D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAM5G;AAED,uEAAuE;AACvE,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAInD;AAGD;;;;;;;;;;;GAWG;AACH,wBAAsB,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAmC9G"}