@peddles/sdk 0.2.0

package/dist/artDex.d.ts.map

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

package/dist/artDex.js

@@ -0,0 +1,155 @@
+import { encodeAbiParameters, keccak256 } from 'viem';
+import { nftBondingGraduationOrchestratorAbi, nftCollectionAbi, nftFactoryAbi, nftFeeDistributorAbi, nftFeeDistributorFactoryAbi, nftStockGraduationOrchestratorAbi, } from './abis.js';
+/**
+ * Art->DEX: a Peddles NFT collection launches ONE coin, paired to WETH or a tokenised stock, and may
+ * commit — permanently — a share of the creator's fee streams to its NFT holders.
+ *
+ * The commitment is the collection's write-once `holderRewards` binding to its canonical
+ * `PeddlesNftFeeDistributor` (made by `PeddlesNftFeeDistributorFactory`), plus the `holderShareBps`
+ * the creator passes at launch (0..10000). Nobody can change either afterwards.
+ *
+ * Addresses are parameters here rather than looked up from `DEPLOYMENTS`: the distributor factory ships
+ * with the Art->DEX deployment, and an address book that predates it has no entry to look up.
+ */
+const ZERO = /^0x0{40}$/i;
+const BPS = 10_000;
+/** Bps bound shared by every holder-share argument. Throws rather than letting the chain revert. */
+function assertBps(name, v) {
+    if (!Number.isInteger(v) || v < 0 || v > BPS)
+        throw new RangeError(`${name} must be an integer 0..10000, got ${v}`);
+}
+/**
+ * `relayParamsHash` computed off chain — `keccak256(abi.encode(chainid, orchestrator, collection, name,
+ * symbol, quote, holderShareBps))`, exactly as the orchestrator hashes it. The collection owner signs
+ * `setStockGraduationOptIn(collection, hash)`; a relay whose parameters hash to anything else reverts.
+ * Chain id and orchestrator are part of it, so consent never carries across chains or deployments.
+ */
+export function relayParamsHash(p) {
+    assertBps('holderShareBps', p.holderShareBps);
+    return keccak256(encodeAbiParameters([{ type: 'uint256' }, { type: 'address' }, { type: 'address' }, { type: 'string' }, { type: 'string' }, { type: 'address' }, { type: 'uint16' }], [BigInt(p.chainId), p.orchestrator, p.collection, p.name, p.symbol, p.quote, p.holderShareBps]));
+}
+/** Request for `setStockGraduationOptIn(collection, relayParamsHash(p))` (collection owner only). Zero revokes. */
+export function stockGraduationOptInRequest(p) {
+    return {
+        address: p.orchestrator,
+        abi: nftStockGraduationOrchestratorAbi,
+        functionName: 'setStockGraduationOptIn',
+        args: [p.collection, relayParamsHash(p)],
+    };
+}
+/** Request for `graduateToStockWithTerms` (collection owner only). */
+export function graduateToStockWithTermsRequest(l) {
+    assertBps('holderShareBps', l.holderShareBps);
+    assertBps('excessToCreatorBps', l.excessToCreatorBps);
+    return {
+        address: l.orchestrator,
+        abi: nftStockGraduationOrchestratorAbi,
+        functionName: 'graduateToStockWithTerms',
+        args: [
+            {
+                collection: l.collection,
+                name: l.name,
+                symbol: l.symbol,
+                quote: l.quote,
+                creatorTaxBps: l.creatorTaxBps,
+                excessToCreatorBps: l.excessToCreatorBps,
+                holderShareBps: l.holderShareBps,
+                devBuyQuoteIn: l.devBuyQuoteIn,
+                minTokensOut: l.minTokensOut,
+            },
+        ],
+        value: l.launchFee,
+    };
+}
+/**
+ * Request for `graduateAndBuy(input, holderShareBps, devBuyValue, minTokensOut)` — the ONLY WETH-path
+ * entry since 94d6564 (`graduate` was removed). A plain launch is `holderShareBps = 0, devBuyValue = 0,
+ * minTokensOut = 0`. `value` must cover the orchestrator's `launchFee()` (read it live —
+ * `readOrchestratorLaunchFee` in `@peddles/sdk/launch`) `+ input.factoryValue + devBuyValue`; a relay of
+ * a committed graduation carries exactly `launchFee()` (`RELAY_FEE_ONLY`).
+ *
+ * `input` is the orchestrator's `GraduateInput` tuple, built by the launch kit exactly as for any V20
+ * launch; this helper only positions the Art->DEX arguments around it.
+ */
+export function graduateAndBuyRequest(p) {
+    assertBps('holderShareBps', p.holderShareBps);
+    if (p.devBuyValue > p.value)
+        throw new RangeError('devBuyValue exceeds value');
+    return {
+        address: p.orchestrator,
+        abi: nftBondingGraduationOrchestratorAbi,
+        functionName: 'graduateAndBuy',
+        args: [p.input, p.holderShareBps, p.devBuyValue, p.minTokensOut],
+        value: p.value,
+    };
+}
+/* ------------------------------ reads ------------------------------ */
+/** The canonical distributor address for `collection` (CREATE2; exists or not). */
+export async function predictDistributor(client, distributorFactory, collection) {
+    return (await client.readContract({ address: distributorFactory, abi: nftFeeDistributorFactoryAbi, functionName: 'predict', args: [collection] }));
+}
+/**
+ * Whether a collection's creator streams are committed to its holders — the same three reads the
+ * orchestrators make: `holderRewards()`, `factory.isDistributor(d)`, `d.collection() == collection`.
+ * Also reports factory provenance, which the orchestrators do NOT check.
+ */
+export async function getHolderCommitment(client, a) {
+    const [holderRewards, peddlesCollection] = await Promise.all([
+        client.readContract({ address: a.collection, abi: nftCollectionAbi, functionName: 'holderRewards' }),
+        client.readContract({ address: a.nftFactory, abi: nftFactoryAbi, functionName: 'isPeddlesCollection', args: [a.collection] }),
+    ]);
+    if (ZERO.test(holderRewards))
+        return { committed: false, holderRewards, peddlesCollection };
+    const isDistributor = (await client.readContract({
+        address: a.distributorFactory,
+        abi: nftFeeDistributorFactoryAbi,
+        functionName: 'isDistributor',
+        args: [holderRewards],
+    }));
+    if (!isDistributor)
+        return { committed: false, holderRewards, peddlesCollection };
+    const bound = (await client.readContract({ address: holderRewards, abi: nftFeeDistributorAbi, functionName: 'collection' }));
+    return { committed: bound.toLowerCase() === a.collection.toLowerCase(), holderRewards, peddlesCollection };
+}
+export async function getDistributorState(client, distributor) {
+    const base = { address: distributor, abi: nftFeeDistributorAbi };
+    const [collection, quote, token, holderShareBps, assetsInitialized, creatorShareOwed, owedToHolders, mirrorComplete] = await client.multicall({
+        allowFailure: false,
+        contracts: [
+            { ...base, functionName: 'collection' },
+            { ...base, functionName: 'quote' },
+            { ...base, functionName: 'token' },
+            { ...base, functionName: 'holderShareBps' },
+            { ...base, functionName: 'assetsInitialized' },
+            { ...base, functionName: 'creatorShareOwed' },
+            { ...base, functionName: 'owedToHolders' },
+            { ...base, functionName: 'mirrorComplete' },
+        ],
+    });
+    const [cq, ct] = creatorShareOwed;
+    const [hq, ht] = owedToHolders;
+    return {
+        distributor,
+        collection: collection,
+        quote: quote,
+        token: token,
+        holderShareBps: Number(holderShareBps),
+        assetsInitialized: assetsInitialized,
+        creatorShareOwed: { quote: cq, token: ct },
+        owedToHolders: { quote: hq, token: ht },
+        mirrorComplete: mirrorComplete,
+    };
+}
+export async function holderClaimable(client, distributor, collection, holder) {
+    const [pending, shares, pieces] = await client.multicall({
+        allowFailure: false,
+        contracts: [
+            { address: distributor, abi: nftFeeDistributorAbi, functionName: 'pending', args: [holder] },
+            { address: distributor, abi: nftFeeDistributorAbi, functionName: 'sharesOf', args: [holder] },
+            { address: collection, abi: nftCollectionAbi, functionName: 'balanceOf', args: [holder] },
+        ],
+    });
+    const [quote, token] = pending;
+    return { quote, token, shares: shares, pieces: pieces, needsSync: shares !== pieces };
+}
+//# sourceMappingURL=artDex.js.map

package/dist/artDex.js.map

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

package/dist/client.d.ts

@@ -0,0 +1,10 @@
+import type { PublicClient } from 'viem';
+/**
+ * The client every SDK read takes: any viem client that can `readContract`, `multicall` and
+ * `getBalance`. Narrower than `PublicClient` on purpose — a `PublicClient` built for a chain with its
+ * own formatters (Base and every OP-stack chain add `deposit` transactions) is NOT assignable to the
+ * generic `PublicClient`, so typing parameters that way made `createPublicClient({ chain: base })`
+ * a compile error for every Base integrator. Only the three methods the SDK calls are required.
+ */
+export type ReadClient = Pick<PublicClient, 'readContract' | 'multicall' | 'getBalance'>;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAEzC;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,IAAI,CAAC,YAAY,EAAE,cAAc,GAAG,WAAW,GAAG,YAAY,CAAC,CAAC"}

package/dist/client.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":""}

package/dist/clog.d.ts

@@ -0,0 +1,75 @@
+import type { ReadClient } from './client.js';
+import type { Address } from 'viem';
+/**
+ * The Clog launch type, read from the chain.
+ *
+ * A clog withholds a share of a launch's supply in a `PeddlesClogVault` and
+ * sells it into that launch's own pool a capped slice at a time. The proceeds
+ * (native) STAY IN THE VAULT until the creator calls `withdrawProceeds`, and a
+ * creator-set release floor bounds the price a release may sell at. It funds marketing without the creator putting up
+ * capital — and it only ever extracts from volume that actually arrived, since
+ * a sale into an empty book returns nothing and reverts.
+ */
+/** A launch type's declared economics. Write-once at variant registration. */
+export interface VariantAllocation {
+    readonly liquidityBps: number;
+    readonly airdropBps: number;
+    readonly vestingBps: number;
+    readonly burnBps: number;
+    readonly clogBps: number;
+    /** Per-release cap, in bps OF TOTAL SUPPLY — not of the allocation. */
+    readonly clogSliceBps: number;
+    readonly clogMinIntervalSeconds: bigint;
+}
+/** One clog vault's live state. */
+export interface ClogState {
+    readonly vault: Address;
+    readonly token: Address;
+    readonly creator: Address;
+    readonly router: Address;
+    /** Raw units still held, i.e. not yet sold. */
+    readonly held: bigint;
+    /** Raw units sold to date, across every release. */
+    readonly totalSold: bigint;
+    /** Max raw units one release may sell. */
+    readonly sliceCap: bigint;
+    readonly minIntervalSeconds: bigint;
+    /** What `release` would sell right now. */
+    readonly nextSlice: bigint;
+    /** Unix seconds at which `release` stops reverting `TooSoon`. */
+    readonly readyAt: bigint;
+    /** Native proceeds held by the vault, owed to the creator (`withdrawProceeds`). */
+    readonly proceedsOwed: bigint;
+    /** The creator's minimum release price, 1e18-scaled quote per token; 0 = none. */
+    readonly releaseFloorX18: bigint;
+}
+/**
+ * Read a launch type's allocation.
+ *
+ * `registerVariant` is write-once, so this is the deal a creator and every
+ * buyer of their token accepted — it cannot be changed under them afterwards.
+ * Read it rather than assuming: the shares differ per launch type, and a clog
+ * type is not 100% liquidity.
+ */
+export declare function getVariantAllocation(client: ReadClient, chainId: number, variant: number): Promise<VariantAllocation>;
+/** The clog vault a launch's orchestrator created for `token`, or null. */
+export declare function getClogVault(client: ReadClient, chainId: number, token: Address): Promise<Address | null>;
+/** Everything about one clog vault, in a single multicall. */
+export declare function getClogState(client: ReadClient, vault: Address): Promise<ClogState>;
+/**
+ * What share of INFLOWS a clog routes to the creator, given its share of supply.
+ *
+ * THESE ARE NOT THE SAME NUMBER, and the second is the one that matters to a
+ * buyer. The allocation is a share of supply, but it is sold into the pool the
+ * buyer is buying from, so it captures a much larger share of the money coming
+ * in. Surface it wherever the allocation is shown: a launch page that says "5%"
+ * and stops has told the buyer the smaller of two true numbers.
+ *
+ * The model (exact, bigint, documented in `clogInflow.ts`) lives in its own
+ * import-free module and is re-exported here.
+ */
+export { CLOG_MODEL_FLOW_MULTIPLE, CLOG_TABLE_SLICE_BPS, clogShareOfInflows, clogShareOfInflowsFromBps, clogInflowShareBps, inflowShareBps, } from './clogInflow.js';
+export type { ShareOfInflows, ClogModelInput } from './clogInflow.js';
+/** True when `release` would not revert `TooSoon`. */
+export declare function isReleaseReady(state: ClogState, nowSeconds: bigint): boolean;
+//# sourceMappingURL=clog.d.ts.map

package/dist/clog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clog.d.ts","sourceRoot":"","sources":["../src/clog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAIpC;;;;;;;;;GASG;AAEH,8EAA8E;AAC9E,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,uEAAuE;IACvE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;CACzC;AAED,mCAAmC;AACnC,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oDAAoD;IACpD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,0CAA0C;IAC1C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,2CAA2C;IAC3C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,iEAAiE;IACjE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,mFAAmF;IACnF,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,kFAAkF;IAClF,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAED;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,iBAAiB,CAAC,CAyB5B;AAED,2EAA2E;AAC3E,wBAAsB,YAAY,CAChC,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAQzB;AAED,8DAA8D;AAC9D,wBAAsB,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,SAAS,CAAC,CAqCzF;AAED;;;;;;;;;;;GAWG;AACH,OAAO,EACL,wBAAwB,EACxB,oBAAoB,EACpB,kBAAkB,EAClB,yBAAyB,EACzB,kBAAkB,EAClB,cAAc,GACf,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtE,sDAAsD;AACtD,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAE5E"}

package/dist/clog.js

@@ -0,0 +1,91 @@
+import { clogVaultAbi, clogVaultFactoryAbi, erc20Abi, factoryAbi } from './abis.js';
+import { addressOf } from './deployments.js';
+/**
+ * Read a launch type's allocation.
+ *
+ * `registerVariant` is write-once, so this is the deal a creator and every
+ * buyer of their token accepted — it cannot be changed under them afterwards.
+ * Read it rather than assuming: the shares differ per launch type, and a clog
+ * type is not 100% liquidity.
+ */
+export async function getVariantAllocation(client, chainId, variant) {
+    const a = (await client.readContract({
+        address: addressOf(chainId, 'PeddlesFactoryV20'),
+        abi: factoryAbi,
+        functionName: 'variantAllocation',
+        args: [variant],
+    }));
+    return {
+        liquidityBps: a.liquidityBps,
+        airdropBps: a.airdropBps,
+        vestingBps: a.vestingBps,
+        burnBps: a.burnBps,
+        clogBps: a.clogBps,
+        clogSliceBps: a.clogSliceBps,
+        clogMinIntervalSeconds: a.clogMinInterval,
+    };
+}
+/** The clog vault a launch's orchestrator created for `token`, or null. */
+export async function getClogVault(client, chainId, token) {
+    const vault = (await client.readContract({
+        address: addressOf(chainId, 'PeddlesClogVaultFactory'),
+        abi: clogVaultFactoryAbi,
+        functionName: 'vaultOf',
+        args: [addressOf(chainId, 'PeddlesLaunchOrchestratorV20'), token],
+    }));
+    return /^0x0{40}$/i.test(vault) ? null : vault;
+}
+/** Everything about one clog vault, in a single multicall. */
+export async function getClogState(client, vault) {
+    const base = { address: vault, abi: clogVaultAbi };
+    const [token, creator, router, sliceCap, minInterval, totalSold, preview, releaseFloorX18] = await client.multicall({
+        allowFailure: false,
+        contracts: [
+            { ...base, functionName: 'token' },
+            { ...base, functionName: 'creator' },
+            { ...base, functionName: 'router' },
+            { ...base, functionName: 'sliceCap' },
+            { ...base, functionName: 'minInterval' },
+            { ...base, functionName: 'totalSold' },
+            { ...base, functionName: 'previewRelease' },
+            { ...base, functionName: 'releaseFloorX18' },
+        ],
+    });
+    const [held, proceedsOwed] = await Promise.all([
+        client.readContract({ address: token, abi: erc20Abi, functionName: 'balanceOf', args: [vault] }),
+        client.getBalance({ address: vault }),
+    ]);
+    const [nextSlice, readyAt] = preview;
+    return {
+        vault,
+        token: token,
+        creator: creator,
+        router: router,
+        held,
+        totalSold: totalSold,
+        sliceCap: sliceCap,
+        minIntervalSeconds: minInterval,
+        nextSlice,
+        readyAt,
+        proceedsOwed,
+        releaseFloorX18: releaseFloorX18,
+    };
+}
+/**
+ * What share of INFLOWS a clog routes to the creator, given its share of supply.
+ *
+ * THESE ARE NOT THE SAME NUMBER, and the second is the one that matters to a
+ * buyer. The allocation is a share of supply, but it is sold into the pool the
+ * buyer is buying from, so it captures a much larger share of the money coming
+ * in. Surface it wherever the allocation is shown: a launch page that says "5%"
+ * and stops has told the buyer the smaller of two true numbers.
+ *
+ * The model (exact, bigint, documented in `clogInflow.ts`) lives in its own
+ * import-free module and is re-exported here.
+ */
+export { CLOG_MODEL_FLOW_MULTIPLE, CLOG_TABLE_SLICE_BPS, clogShareOfInflows, clogShareOfInflowsFromBps, clogInflowShareBps, inflowShareBps, } from './clogInflow.js';
+/** True when `release` would not revert `TooSoon`. */
+export function isReleaseReady(state, nowSeconds) {
+    return nowSeconds >= state.readyAt;
+}
+//# sourceMappingURL=clog.js.map

package/dist/clog.js.map

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

package/dist/clogInflow.d.ts

@@ -0,0 +1,136 @@
+/**
+ * What share of the money buyers put in a clog routes to the creator.
+ *
+ * A clog allocation is a share of SUPPLY, but it is sold into the pool buyers are
+ * buying from, so it captures a far larger share of the money coming in. That
+ * second number is the one a buyer is accepting, and it must be stated wherever
+ * the allocation is. This module derives it; nothing here is a lookup table.
+ *
+ * Pure: no imports, bigint only, no floating point at any step. Every step is
+ * exact rational arithmetic, so the result is a fraction `num / den`; the only
+ * rounding is in `clogInflowShareBps`, once, at the end.
+ *
+ * SINGLE SOURCE OF TRUTH. `apps/web/src/features/launch/clogInflow.ts` carries a
+ * copy (the web app does not depend on this package). `__tests__/clogInflow.test.ts`
+ * imports that copy and holds the two to identical fractions over a grid, so a
+ * change to one without the other fails the SDK's tests.
+ *
+ * ── THE MODEL ───────────────────────────────────────────────────────────────
+ * Pure buy flow — nobody but the clog ever sells. That is the most favourable
+ * case for the design: any real selling makes the clog sell into a weaker pool.
+ *
+ *   The pool. A Peddles launch opens a single-sided position from the launch
+ *   price upward holding the liquidity share `x0 = supply - clog`. For such a
+ *   position, token reserve `x` and quote `y` satisfy
+ *
+ *       x · (y + x0·p0) = x0² · p0          (a constant product, k)
+ *
+ *   i.e. constant product against a virtual quote reserve `x0·p0`. Write
+ *   `q = y + x0·p0`, so `q0 = x0·p0` and `k = x0·q0`.
+ *
+ *   One round. Buyers spend `B` (a buy never changes k):   q  ←  q + B
+ *   then the clog sells `s = min(slice, remaining)` tokens:
+ *
+ *       q  ←  k · q / (k + s · q)           (x ← x + s,  q = k / x)
+ *
+ *   Rounds repeat until the clog is empty. After `n` rounds buyers have put in
+ *   `n·B`, and the pool holds `q_n − q0` of it; everything else was paid out to
+ *   the creator. So, exactly:
+ *
+ *       share of inflows  =  1 − (q_n − q0) / (n · B)
+ *
+ *   Buy flow per round — THE ONE ASSUMPTION. `B = flowMultiple × slice × p0`:
+ *   buyers spend between releases `flowMultiple` times what a slice was worth at
+ *   the launch price. Default `CLOG_MODEL_FLOW_MULTIPLE` (100).
+ *
+ *   p0 cancels. Measuring quote in units of `p0` makes every term an integer
+ *   count of tokens (`q0 = x0`, `k = x0²`, `B = flowMultiple × slice`), so the
+ *   result depends only on (supply, clog, slice) and the flow multiple — never
+ *   on the launch price, which is why it can be stated before the pool exists.
+ *
+ *   The floor. A single-sided position holds no quote below its launch price, so
+ *   a release can never take the price under `p0`. If a round's sale would, the
+ *   model does not apply and the functions return null rather than a number from
+ *   a pool that cannot exist. At flowMultiple = 100 this cannot happen anywhere
+ *   in the range the factory accepts (clog ≤ `PeddlesFactoryV20.CLOG_BPS_MAX`,
+ *   25%): a round starts at `q ≥ q0`, its buys take at least `x0·B / (x0 + B)`
+ *   tokens out of the pool, and a sale `s ≤ clog` fits back under the floor
+ *   whenever `99·x0 ≥ 100·s` — true for every `x0 ≥ 75%` and `s ≤ 25%`.
+ *
+ * ── REFERENCE ───────────────────────────────────────────────────────────────
+ * With slices of 1% of supply (`CLOG_TABLE_SLICE_BPS`) and flowMultiple = 100
+ * this reproduces the policy table in CLAUDE.md at its 0.1% resolution
+ * (5% → 16.5%, 10% → 37.1%, 15% → 54.6%, 25% → 75.0%). A launch type's real
+ * slice is smaller — the live Sepolia Clog type sells 5% in 0.25% slices, which
+ * is ≈14.2% — so pass the slice the chain reports, never the table's.
+ */
+/**
+ * Buyer spend between two clog releases, as a multiple of what one slice was
+ * worth at the launch price. The one assumption in the model; see the header.
+ */
+export declare const CLOG_MODEL_FLOW_MULTIPLE = 100n;
+/** The slice (1% of supply) at which the model reproduces the CLAUDE.md policy table. */
+export declare const CLOG_TABLE_SLICE_BPS = 100n;
+export interface ShareOfInflows {
+    /**
+     * Share of all buyer money paid out to the creator, as `num / den` (0 ≤ share < 1).
+     * Not reduced to lowest terms — compare two shares by cross-multiplying.
+     */
+    readonly num: bigint;
+    readonly den: bigint;
+    /** How many releases it takes to sell the whole clog. */
+    readonly releases: bigint;
+}
+export interface ClogModelInput {
+    /** Total supply, in any unit — basis points (10000) or raw token units. */
+    readonly supply: bigint;
+    /** The clog allocation, in the same unit. */
+    readonly clog: bigint;
+    /** The most one release sells, in the same unit. */
+    readonly slice: bigint;
+    /** Defaults to `CLOG_MODEL_FLOW_MULTIPLE`. */
+    readonly flowMultiple?: bigint;
+}
+/**
+ * The share of buyer money a clog routes to the creator, as an exact fraction,
+ * or null when the model does not apply (a malformed input, or a release that
+ * would breach the floor). A zero clog captures nothing:
+ * `{ num: 0n, den: 1n, releases: 0n }`.
+ */
+export declare function clogShareOfInflows(input: ClogModelInput): ShareOfInflows | null;
+/** The same model, stated in basis points of supply — the unit a launch type declares. */
+export declare function clogShareOfInflowsFromBps(clogBps: bigint, sliceBps: bigint, flowMultiple?: bigint): ShareOfInflows | null;
+/**
+ * Share of inflows, in basis points, for a clog of `clogBps` of supply sold in
+ * slices of `sliceBps` of supply.
+ *
+ * Pass the launch type's own `clogSliceBps` (from `getVariantAllocation`), not
+ * the policy table's 1%: the slice moves the answer (5% in 1% slices is 1649 bps;
+ * in the live 0.25% slices it is 1417 bps).
+ *
+ * @param clogBps      Clog allocation, bps of total supply.
+ * @param sliceBps     Per-release cap, bps of total supply.
+ * @param flowMultiple Buyer spend between releases, in slices at the launch
+ *                     price. The model's one assumption; defaults to
+ *                     `CLOG_MODEL_FLOW_MULTIPLE` (100).
+ * @returns Nearest basis point, rounded half up — the only rounding in the model
+ *          (use `clogShareOfInflows` for the exact fraction) — or null when the
+ *          model does not apply.
+ */
+export declare function clogInflowShareBps(clogBps: bigint, sliceBps: bigint, flowMultiple?: bigint): bigint | null;
+/**
+ * What share of INFLOWS a clog routes to the creator, given its share of supply —
+ * AT THE POLICY TABLE'S 1% SLICE AND 0.1% RESOLUTION.
+ *
+ * @deprecated Kept for existing callers. It answers for the CLAUDE.md table's
+ * assumed slice, not for any real launch type's, so it overstates the live Sepolia
+ * Clog type (5%: 1650 here vs 1417 at its real 0.25% slice). Use
+ * `clogInflowShareBps(clogBps, allocation.clogSliceBps)`.
+ *
+ * Output is unchanged for the four table rows (500 → 1650, 1000 → 3710,
+ * 1500 → 5460, 2500 → 7500). It is now derived from the model rather than looked
+ * up, so any integer clog in [0, 10000) returns a value (a multiple of 10) where
+ * it used to return null; non-integer or out-of-range input still returns null.
+ */
+export declare function inflowShareBps(clogBps: number): number | null;
+//# sourceMappingURL=clogInflow.d.ts.map

package/dist/clogInflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clogInflow.d.ts","sourceRoot":"","sources":["../src/clogInflow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AAEH;;;GAGG;AACH,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAE7C,yFAAyF;AACzF,eAAO,MAAM,oBAAoB,OAAO,CAAC;AAOzC,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,yDAAyD;IACzD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc;IAC7B,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,6CAA6C;IAC7C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oDAAoD;IACpD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,8CAA8C;IAC9C,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,cAAc,GAAG,cAAc,GAAG,IAAI,CA6C/E;AAED,0FAA0F;AAC1F,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,YAAY,GAAE,MAAiC,GAC9C,cAAc,GAAG,IAAI,CAEvB;AAOD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,YAAY,GAAE,MAAiC,GAC9C,MAAM,GAAG,IAAI,CAGf;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAM7D"}