@peddles/sdk 0.2.0

package/dist/clogInflow.js

@@ -0,0 +1,177 @@
+/**
+ * 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 const CLOG_MODEL_FLOW_MULTIPLE = 100n;
+/** The slice (1% of supply) at which the model reproduces the CLAUDE.md policy table. */
+export const CLOG_TABLE_SLICE_BPS = 100n;
+/** More rounds than any registrable launch type can need (25% in 1-unit slices of 10,000). */
+const MAX_ROUNDS = 100000n;
+const BPS = 10000n;
+/**
+ * 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 function clogShareOfInflows(input) {
+    const { supply, clog, slice } = input;
+    const flowMultiple = input.flowMultiple ?? CLOG_MODEL_FLOW_MULTIPLE;
+    if (supply <= 0n || clog < 0n || clog >= supply)
+        return null;
+    if (clog === 0n)
+        return { num: 0n, den: 1n, releases: 0n };
+    if (slice <= 0n || flowMultiple <= 0n)
+        return null;
+    const x0 = supply - clog;
+    const k = x0 * x0; // q0 = x0 in units of p0
+    const buy = flowMultiple * slice;
+    // q = qn / qd, kept as an unreduced exact fraction.
+    let qn = x0;
+    let qd = 1n;
+    let remaining = clog;
+    let rounds = 0n;
+    while (remaining > 0n) {
+        if (rounds >= MAX_ROUNDS)
+            return null;
+        rounds += 1n;
+        // Buyers spend: q ← q + B.
+        qn += buy * qd;
+        // The clog sells s tokens: q ← k·q / (k + s·q).
+        const sold = remaining < slice ? remaining : slice;
+        const nextN = k * qn;
+        const nextD = k * qd + sold * qn;
+        // Floor: q must not fall below q0 (= x0), i.e. nextN / nextD ≥ x0.
+        if (nextN < x0 * nextD)
+            return null;
+        // Left unreduced. The fraction almost never reduces, and a gcd on numbers
+        // that grow a few dozen bits per round is what makes a 2,500-round type slow.
+        qn = nextN;
+        qd = nextD;
+        remaining -= sold;
+    }
+    // share = 1 − (q − q0) / (n·B) = (n·B·qd − (qn − x0·qd)) / (n·B·qd)
+    const inflow = rounds * buy;
+    const den = inflow * qd;
+    const num = den - (qn - x0 * qd);
+    return { num, den, releases: rounds };
+}
+/** The same model, stated in basis points of supply — the unit a launch type declares. */
+export function clogShareOfInflowsFromBps(clogBps, sliceBps, flowMultiple = CLOG_MODEL_FLOW_MULTIPLE) {
+    return clogShareOfInflows({ supply: BPS, clog: clogBps, slice: sliceBps, flowMultiple });
+}
+/** `num / den` scaled by `unit`, rounded half up. `num ≥ 0`, `den > 0`. */
+function roundHalfUp(num, den, unit) {
+    return (num * unit * 2n + den) / (den * 2n);
+}
+/**
+ * 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 function clogInflowShareBps(clogBps, sliceBps, flowMultiple = CLOG_MODEL_FLOW_MULTIPLE) {
+    const share = clogShareOfInflowsFromBps(clogBps, sliceBps, flowMultiple);
+    return share === null ? null : roundHalfUp(share.num, share.den, BPS);
+}
+/**
+ * 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 function inflowShareBps(clogBps) {
+    if (!Number.isSafeInteger(clogBps))
+        return null;
+    const share = clogShareOfInflowsFromBps(BigInt(clogBps), CLOG_TABLE_SLICE_BPS);
+    if (share === null)
+        return null;
+    // Table resolution is 0.1% = 10 bps: round once at that resolution, then restate in bps.
+    return Number(roundHalfUp(share.num, share.den, BPS / 10n) * 10n);
+}
+//# sourceMappingURL=clogInflow.js.map

package/dist/clogInflow.js.map

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

package/dist/deployments.d.ts

@@ -0,0 +1,30 @@
+import { DEPLOYMENTS, type KnownChainId, type ContractName } from './deployments.generated.js';
+export { DEPLOYMENTS };
+export type { KnownChainId, ContractName };
+/** Thrown when the SDK is asked about a chain it ships no address book for. */
+export declare class UnknownChainError extends Error {
+    readonly chainId: number;
+    constructor(chainId: number);
+}
+/** Thrown when a chain is known but does not carry the contract being asked for. */
+export declare class UnknownContractError extends Error {
+    constructor(chainId: number, name: string);
+}
+export declare function isKnownChain(chainId: number): chainId is KnownChainId;
+/**
+ * The address book for one chain.
+ *
+ * FAILS CLOSED, ALWAYS. An unknown chain throws rather than returning a default
+ * or an empty map, and a missing contract throws rather than returning
+ * `undefined` or the zero address. Both of those alternatives look like a
+ * working call right up until a transaction is signed against nothing.
+ *
+ * This is not hypothetical in this codebase: every address changed in a single
+ * redeploy, and one stale copy of this list had the API quoting a launchpad that
+ * no longer existed — an error that surfaced as "neither leg is a launched coin"
+ * rather than as a missing address.
+ */
+export declare function deploymentFor(chainId: number): Readonly<Record<string, `0x${string}`>>;
+/** One address, or a throw. Never a default, never the zero address. */
+export declare function addressOf(chainId: number, name: string): `0x${string}`;
+//# sourceMappingURL=deployments.d.ts.map

package/dist/deployments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployments.d.ts","sourceRoot":"","sources":["../src/deployments.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/F,OAAO,EAAE,WAAW,EAAE,CAAC;AACvB,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,CAAC;AAE3C,+EAA+E;AAC/E,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBACb,OAAO,EAAE,MAAM;CAS5B;AAED,oFAAoF;AACpF,qBAAa,oBAAqB,SAAQ,KAAK;gBACjC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAO1C;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,IAAI,YAAY,CAErE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC,CAAC,CAGtF;AAED,wEAAwE;AACxE,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,KAAK,MAAM,EAAE,CAMtE"}

package/dist/deployments.generated.d.ts

@@ -0,0 +1,92 @@
+/** Every Peddles contract address the SDK knows, by chain id. */
+export declare const DEPLOYMENTS: {
+    readonly 4663: {
+        readonly PeddlesClogVaultFactory: "0x1d2142699F1D818203738226240C605243a39b9e";
+        readonly PeddlesFactoryV20: "0x51336A94B55Ad82D1099Dc82b27b151eDFfc1978";
+        readonly PeddlesFeeForwarder: "0xc572A003d0Ab529da670a42177Fc583b03D5b026";
+        readonly PeddlesFeeHook: "0xfe055282E3cD471A8b2cd922d31E75ECd3bBc0CC";
+        readonly PeddlesHandleLauncher: "0x3720ca29D87E692000Ca71C56a56a3BA05B00CD1";
+        readonly PeddlesHandlePotFactory: "0x2b5881c79a83C9EB17C67354F6737f3c9A120DE2";
+        readonly PeddlesHolderRewardsFactory: "0xB22d6D7B1eC296AA79cbFf4ABE4992A726BE1978";
+        readonly PeddlesLaunchOrchestratorV20: "0x81213e2cE27f03714143152aE5cf5c94094f1978";
+        readonly PeddlesLiquidityActivationManager: "0xBE8d8999b53c5E5249feBafe5f505221F3e41978";
+        readonly PeddlesNFTBondingGraduationOrchestratorV20: "0x6C5032DeDCc78b92b370C86a2aA0EA3AD0D71978";
+        readonly PeddlesNFTFactory: "0x2e0029BeDCBb2f211Fd17EeBA8f40657cF6A1978";
+        readonly PeddlesNftFeeDistributorFactory: "0x3081d5E69b7D12A330C9594C175F88EB77f31978";
+        readonly PeddlesNftLiquidityReserve: "0x367F626775E22818C369BB3a276E3e9Fbc201978";
+        readonly PeddlesNFTMarketplace: "0xC0374a0776449fE60dD1653C6421bEB41e911978";
+        readonly PeddlesNftStockGraduationOrchestrator: "0x3DAd8D2B78C8a71f01600FDecA0b17af5F961978";
+        readonly PeddlesPerpFactory: "0xCFA648281759C406E921F736c86ece2a9c4D1Fca";
+        readonly PeddlesPerpHookDeployer: "0x3ab1848069cE7d19CD62ffB645292146cDd0139F";
+        readonly PeddlesPerpTreasury: "0x2C322f48B2dD97f6c5050eDF5F349C7f70126dB5";
+        readonly PeddlesRouteSwapRouter: "0xA4858047F9c7359CC0d9071598BFA74187739d8D";
+        readonly PeddlesStockLaunchpad: "0x4b7Aa977eA4B95D9859D73e6bc922ecF2F881978";
+        readonly PeddlesStockSwapRouter: "0x5A934c5eE47daa3b4562f9Dc9224bB00e9191978";
+        readonly PeddlesStockVaultFactory: "0xa565E57046B51C4C1144b837A1871FF89c141978";
+        readonly PeddlesTransferValidator: "0x2ADA0EA86925b5EbA1CF7B75e0d606C89b1B1978";
+        readonly PeddlesV4LiquidityExecutor: "0xAB23BD1234AB1BCa48a97aB8e2baaFAaE7A21978";
+        readonly PeddlesV4SwapRouter: "0xDd1F65380C9f7283A61FC489DCAceA352ee31978";
+        readonly PeddlesVaultFactoryV20: "0xe6EE48916F87DD8E8Cab9D100a5E9717aE731978";
+        readonly PeddlesVaultRegistry: "0xd322A44c4600dfDcF399Ceb7a32869e83d561978";
+    };
+    readonly 8453: {
+        readonly PeddlesClogVaultFactory: "0x8563Aeec8C63d53BC8dfbE56FF9134a7b1e80503";
+        readonly PeddlesFactoryV20: "0x90bD4d38F621529b4aD6480c221075B7317b1978";
+        readonly PeddlesFeeForwarder: "0x77886951f19458B2FC27D4373553001A620264D3";
+        readonly PeddlesFeeHook: "0xAB8E39207718f519865D6f0d52eFB31b231D40cc";
+        readonly PeddlesFlywheel: "0x2E9366BF81d0D0ebA905927B55d3Fa3008891978";
+        readonly PeddlesHandleLauncher: "0x265f0653aA62B30Fab11d0718D12CedE7965d7C4";
+        readonly PeddlesHandlePotFactory: "0xC2575Cc3Eb3934C826Fa33FC9BA2e6DA8186D725";
+        readonly PeddlesHolderRewardsFactory: "0xE4A89dCb02211409b50CEFd9B570E67dA2aD1978";
+        readonly PeddlesLaunchOrchestratorV20: "0x7e7E62B41E447B6526E89D0AAAd7Cac9FB9f1978";
+        readonly PeddlesLiquidityActivationManager: "0xa8bfd83d21eec43F9a984C6B13a31Ce1df191978";
+        readonly PeddlesNFTBondingGraduationOrchestratorV20: "0xB7bB0f25B1AE59adcAa2787C68cd50296d2B1978";
+        readonly PeddlesNFTFactory: "0xd111413B91b0E31865464658071099779e2C1978";
+        readonly PeddlesNftFeeDistributorFactory: "0x9B0c155e7248706860c9707c2a8f41A0a2281978";
+        readonly PeddlesNftLiquidityReserve: "0x444C34FF8503eA088a36792659D7c34D7F931978";
+        readonly PeddlesNFTMarketplace: "0x5362a7DE96E8b3474Aef1a0fE6F6e2427Bd81978";
+        readonly PeddlesNftStockGraduationOrchestrator: "0xD6d41a5029EC7F78886C135A71A9c85e96781978";
+        readonly PeddlesPerpFactory: "0x71a8EF2288fFdB3b1d546C33a16F0d4104E11488";
+        readonly PeddlesPerpHookDeployer: "0x9122dAd755B6F8c1DB5F2B7c494580169fB327F2";
+        readonly PeddlesPerpTreasury: "0xDB77eA86006E530D25789F2cf2aeB7bd2C7c3745";
+        readonly PeddlesRouteSwapRouter: "0x8f04A804Ba989d38A68D93eb8679d3a967f2b079";
+        readonly PeddlesStockLaunchpad: "0x680805FBd0D6225d0bE4E12A2B73b2Ed83a31978";
+        readonly PeddlesStockSwapRouter: "0xd150B1E102493e4F35A1e95DdA80948C0e581978";
+        readonly PeddlesStockVaultFactory: "0x5EF74DFc6Dfd9e5dAb314Df5747AC4E117e41978";
+        readonly PeddlesToken: "0xCF2Be52981b5BD563C268a0e2b17D50B53e21978";
+        readonly PeddlesTransferValidator: "0xD1390f3E4741963A7eEd1E53163a1B09c97e1978";
+        readonly PeddlesV4LiquidityExecutor: "0x4Ca94531420F0e4f5a612475c8c4E35E9c8d1978";
+        readonly PeddlesV4SwapRouter: "0xbf7A709cBf71b303B856126D3aEb5051a07c1978";
+        readonly PeddlesVaultFactoryV20: "0xD4fe62B8cd5a7e07fF09D6D1151fA5BC8A771978";
+        readonly PeddlesVaultRegistry: "0xb390c4A83D8B308b378250a59F273A7c9aDF1978";
+    };
+};
+/**
+ * The perp launchpad on each chain that has one (from contracts/deployments/<chainId>-perp.json).
+ * `baseCandidates` are the bases the deploy whitelisted — CANDIDATES only: whether a base is
+ * allowed, and on what curve, is read live from `PeddlesPerpFactory.bases(base)`.
+ */
+export declare const PERP_DEPLOYMENTS: {
+    readonly 4663: {
+        readonly PeddlesPerpFactory: "0xCFA648281759C406E921F736c86ece2a9c4D1Fca";
+        readonly PeddlesPerpHookDeployer: "0x3ab1848069cE7d19CD62ffB645292146cDd0139F";
+        readonly PeddlesPerpTreasury: "0x2C322f48B2dD97f6c5050eDF5F349C7f70126dB5";
+        readonly hookCodePointer: "0xf97907D6AA1Ae3D3Ec3247eEfA998C8D6BE78605";
+        readonly baseCandidates: {
+            readonly WETH: "0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73";
+        };
+    };
+    readonly 8453: {
+        readonly PeddlesPerpFactory: "0x71a8EF2288fFdB3b1d546C33a16F0d4104E11488";
+        readonly PeddlesPerpHookDeployer: "0x9122dAd755B6F8c1DB5F2B7c494580169fB327F2";
+        readonly PeddlesPerpTreasury: "0xDB77eA86006E530D25789F2cf2aeB7bd2C7c3745";
+        readonly hookCodePointer: "0xDAE55090fF0ffb81E3da33C79950DF7Ef78379aA";
+        readonly baseCandidates: {
+            readonly WETH: "0x4200000000000000000000000000000000000006";
+        };
+    };
+};
+export type KnownChainId = keyof typeof DEPLOYMENTS;
+export type PerpChainId = keyof typeof PERP_DEPLOYMENTS;
+export type ContractName<C extends KnownChainId = KnownChainId> = keyof (typeof DEPLOYMENTS)[C];
+//# sourceMappingURL=deployments.generated.d.ts.map

package/dist/deployments.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployments.generated.d.ts","sourceRoot":"","sources":["../src/deployments.generated.ts"],"names":[],"mappings":"AAKA,iEAAiE;AACjE,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6Dd,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;CAmBnB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,WAAW,CAAC;AACpD,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,gBAAgB,CAAC;AACxD,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,YAAY,GAAG,YAAY,IAAI,MAAM,CAAC,OAAO,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC"}

package/dist/deployments.generated.js

@@ -0,0 +1,93 @@
+// GENERATED FILE — DO NOT EDIT.
+// Written by script/generate-deployments.mjs from contracts/deployments/<chainId>.json
+// and <chainId>-perp.json.
+// Re-run it after any deploy and commit the result.
+/** Every Peddles contract address the SDK knows, by chain id. */
+export const DEPLOYMENTS = {
+    4663: {
+        PeddlesClogVaultFactory: '0x1d2142699F1D818203738226240C605243a39b9e',
+        PeddlesFactoryV20: '0x51336A94B55Ad82D1099Dc82b27b151eDFfc1978',
+        PeddlesFeeForwarder: '0xc572A003d0Ab529da670a42177Fc583b03D5b026',
+        PeddlesFeeHook: '0xfe055282E3cD471A8b2cd922d31E75ECd3bBc0CC',
+        PeddlesHandleLauncher: '0x3720ca29D87E692000Ca71C56a56a3BA05B00CD1',
+        PeddlesHandlePotFactory: '0x2b5881c79a83C9EB17C67354F6737f3c9A120DE2',
+        PeddlesHolderRewardsFactory: '0xB22d6D7B1eC296AA79cbFf4ABE4992A726BE1978',
+        PeddlesLaunchOrchestratorV20: '0x81213e2cE27f03714143152aE5cf5c94094f1978',
+        PeddlesLiquidityActivationManager: '0xBE8d8999b53c5E5249feBafe5f505221F3e41978',
+        PeddlesNFTBondingGraduationOrchestratorV20: '0x6C5032DeDCc78b92b370C86a2aA0EA3AD0D71978',
+        PeddlesNFTFactory: '0x2e0029BeDCBb2f211Fd17EeBA8f40657cF6A1978',
+        PeddlesNftFeeDistributorFactory: '0x3081d5E69b7D12A330C9594C175F88EB77f31978',
+        PeddlesNftLiquidityReserve: '0x367F626775E22818C369BB3a276E3e9Fbc201978',
+        PeddlesNFTMarketplace: '0xC0374a0776449fE60dD1653C6421bEB41e911978',
+        PeddlesNftStockGraduationOrchestrator: '0x3DAd8D2B78C8a71f01600FDecA0b17af5F961978',
+        PeddlesPerpFactory: '0xCFA648281759C406E921F736c86ece2a9c4D1Fca',
+        PeddlesPerpHookDeployer: '0x3ab1848069cE7d19CD62ffB645292146cDd0139F',
+        PeddlesPerpTreasury: '0x2C322f48B2dD97f6c5050eDF5F349C7f70126dB5',
+        PeddlesRouteSwapRouter: '0xA4858047F9c7359CC0d9071598BFA74187739d8D',
+        PeddlesStockLaunchpad: '0x4b7Aa977eA4B95D9859D73e6bc922ecF2F881978',
+        PeddlesStockSwapRouter: '0x5A934c5eE47daa3b4562f9Dc9224bB00e9191978',
+        PeddlesStockVaultFactory: '0xa565E57046B51C4C1144b837A1871FF89c141978',
+        PeddlesTransferValidator: '0x2ADA0EA86925b5EbA1CF7B75e0d606C89b1B1978',
+        PeddlesV4LiquidityExecutor: '0xAB23BD1234AB1BCa48a97aB8e2baaFAaE7A21978',
+        PeddlesV4SwapRouter: '0xDd1F65380C9f7283A61FC489DCAceA352ee31978',
+        PeddlesVaultFactoryV20: '0xe6EE48916F87DD8E8Cab9D100a5E9717aE731978',
+        PeddlesVaultRegistry: '0xd322A44c4600dfDcF399Ceb7a32869e83d561978',
+    },
+    8453: {
+        PeddlesClogVaultFactory: '0x8563Aeec8C63d53BC8dfbE56FF9134a7b1e80503',
+        PeddlesFactoryV20: '0x90bD4d38F621529b4aD6480c221075B7317b1978',
+        PeddlesFeeForwarder: '0x77886951f19458B2FC27D4373553001A620264D3',
+        PeddlesFeeHook: '0xAB8E39207718f519865D6f0d52eFB31b231D40cc',
+        PeddlesFlywheel: '0x2E9366BF81d0D0ebA905927B55d3Fa3008891978',
+        PeddlesHandleLauncher: '0x265f0653aA62B30Fab11d0718D12CedE7965d7C4',
+        PeddlesHandlePotFactory: '0xC2575Cc3Eb3934C826Fa33FC9BA2e6DA8186D725',
+        PeddlesHolderRewardsFactory: '0xE4A89dCb02211409b50CEFd9B570E67dA2aD1978',
+        PeddlesLaunchOrchestratorV20: '0x7e7E62B41E447B6526E89D0AAAd7Cac9FB9f1978',
+        PeddlesLiquidityActivationManager: '0xa8bfd83d21eec43F9a984C6B13a31Ce1df191978',
+        PeddlesNFTBondingGraduationOrchestratorV20: '0xB7bB0f25B1AE59adcAa2787C68cd50296d2B1978',
+        PeddlesNFTFactory: '0xd111413B91b0E31865464658071099779e2C1978',
+        PeddlesNftFeeDistributorFactory: '0x9B0c155e7248706860c9707c2a8f41A0a2281978',
+        PeddlesNftLiquidityReserve: '0x444C34FF8503eA088a36792659D7c34D7F931978',
+        PeddlesNFTMarketplace: '0x5362a7DE96E8b3474Aef1a0fE6F6e2427Bd81978',
+        PeddlesNftStockGraduationOrchestrator: '0xD6d41a5029EC7F78886C135A71A9c85e96781978',
+        PeddlesPerpFactory: '0x71a8EF2288fFdB3b1d546C33a16F0d4104E11488',
+        PeddlesPerpHookDeployer: '0x9122dAd755B6F8c1DB5F2B7c494580169fB327F2',
+        PeddlesPerpTreasury: '0xDB77eA86006E530D25789F2cf2aeB7bd2C7c3745',
+        PeddlesRouteSwapRouter: '0x8f04A804Ba989d38A68D93eb8679d3a967f2b079',
+        PeddlesStockLaunchpad: '0x680805FBd0D6225d0bE4E12A2B73b2Ed83a31978',
+        PeddlesStockSwapRouter: '0xd150B1E102493e4F35A1e95DdA80948C0e581978',
+        PeddlesStockVaultFactory: '0x5EF74DFc6Dfd9e5dAb314Df5747AC4E117e41978',
+        PeddlesToken: '0xCF2Be52981b5BD563C268a0e2b17D50B53e21978',
+        PeddlesTransferValidator: '0xD1390f3E4741963A7eEd1E53163a1B09c97e1978',
+        PeddlesV4LiquidityExecutor: '0x4Ca94531420F0e4f5a612475c8c4E35E9c8d1978',
+        PeddlesV4SwapRouter: '0xbf7A709cBf71b303B856126D3aEb5051a07c1978',
+        PeddlesVaultFactoryV20: '0xD4fe62B8cd5a7e07fF09D6D1151fA5BC8A771978',
+        PeddlesVaultRegistry: '0xb390c4A83D8B308b378250a59F273A7c9aDF1978',
+    },
+};
+/**
+ * The perp launchpad on each chain that has one (from contracts/deployments/<chainId>-perp.json).
+ * `baseCandidates` are the bases the deploy whitelisted — CANDIDATES only: whether a base is
+ * allowed, and on what curve, is read live from `PeddlesPerpFactory.bases(base)`.
+ */
+export const PERP_DEPLOYMENTS = {
+    4663: {
+        PeddlesPerpFactory: '0xCFA648281759C406E921F736c86ece2a9c4D1Fca',
+        PeddlesPerpHookDeployer: '0x3ab1848069cE7d19CD62ffB645292146cDd0139F',
+        PeddlesPerpTreasury: '0x2C322f48B2dD97f6c5050eDF5F349C7f70126dB5',
+        hookCodePointer: '0xf97907D6AA1Ae3D3Ec3247eEfA998C8D6BE78605',
+        baseCandidates: {
+            WETH: '0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73',
+        },
+    },
+    8453: {
+        PeddlesPerpFactory: '0x71a8EF2288fFdB3b1d546C33a16F0d4104E11488',
+        PeddlesPerpHookDeployer: '0x9122dAd755B6F8c1DB5F2B7c494580169fB327F2',
+        PeddlesPerpTreasury: '0xDB77eA86006E530D25789F2cf2aeB7bd2C7c3745',
+        hookCodePointer: '0xDAE55090fF0ffb81E3da33C79950DF7Ef78379aA',
+        baseCandidates: {
+            WETH: '0x4200000000000000000000000000000000000006',
+        },
+    },
+};
+//# sourceMappingURL=deployments.generated.js.map

package/dist/deployments.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployments.generated.js","sourceRoot":"","sources":["../src/deployments.generated.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAChC,uFAAuF;AACvF,2BAA2B;AAC3B,oDAAoD;AAEpD,iEAAiE;AACjE,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,IAAI,EAAE;QACJ,uBAAuB,EAAE,4CAA4C;QACrE,iBAAiB,EAAE,4CAA4C;QAC/D,mBAAmB,EAAE,4CAA4C;QACjE,cAAc,EAAE,4CAA4C;QAC5D,qBAAqB,EAAE,4CAA4C;QACnE,uBAAuB,EAAE,4CAA4C;QACrE,2BAA2B,EAAE,4CAA4C;QACzE,4BAA4B,EAAE,4CAA4C;QAC1E,iCAAiC,EAAE,4CAA4C;QAC/E,0CAA0C,EAAE,4CAA4C;QACxF,iBAAiB,EAAE,4CAA4C;QAC/D,+BAA+B,EAAE,4CAA4C;QAC7E,0BAA0B,EAAE,4CAA4C;QACxE,qBAAqB,EAAE,4CAA4C;QACnE,qCAAqC,EAAE,4CAA4C;QACnF,kBAAkB,EAAE,4CAA4C;QAChE,uBAAuB,EAAE,4CAA4C;QACrE,mBAAmB,EAAE,4CAA4C;QACjE,sBAAsB,EAAE,4CAA4C;QACpE,qBAAqB,EAAE,4CAA4C;QACnE,sBAAsB,EAAE,4CAA4C;QACpE,wBAAwB,EAAE,4CAA4C;QACtE,wBAAwB,EAAE,4CAA4C;QACtE,0BAA0B,EAAE,4CAA4C;QACxE,mBAAmB,EAAE,4CAA4C;QACjE,sBAAsB,EAAE,4CAA4C;QACpE,oBAAoB,EAAE,4CAA4C;KACnE;IACD,IAAI,EAAE;QACJ,uBAAuB,EAAE,4CAA4C;QACrE,iBAAiB,EAAE,4CAA4C;QAC/D,mBAAmB,EAAE,4CAA4C;QACjE,cAAc,EAAE,4CAA4C;QAC5D,eAAe,EAAE,4CAA4C;QAC7D,qBAAqB,EAAE,4CAA4C;QACnE,uBAAuB,EAAE,4CAA4C;QACrE,2BAA2B,EAAE,4CAA4C;QACzE,4BAA4B,EAAE,4CAA4C;QAC1E,iCAAiC,EAAE,4CAA4C;QAC/E,0CAA0C,EAAE,4CAA4C;QACxF,iBAAiB,EAAE,4CAA4C;QAC/D,+BAA+B,EAAE,4CAA4C;QAC7E,0BAA0B,EAAE,4CAA4C;QACxE,qBAAqB,EAAE,4CAA4C;QACnE,qCAAqC,EAAE,4CAA4C;QACnF,kBAAkB,EAAE,4CAA4C;QAChE,uBAAuB,EAAE,4CAA4C;QACrE,mBAAmB,EAAE,4CAA4C;QACjE,sBAAsB,EAAE,4CAA4C;QACpE,qBAAqB,EAAE,4CAA4C;QACnE,sBAAsB,EAAE,4CAA4C;QACpE,wBAAwB,EAAE,4CAA4C;QACtE,YAAY,EAAE,4CAA4C;QAC1D,wBAAwB,EAAE,4CAA4C;QACtE,0BAA0B,EAAE,4CAA4C;QACxE,mBAAmB,EAAE,4CAA4C;QACjE,sBAAsB,EAAE,4CAA4C;QACpE,oBAAoB,EAAE,4CAA4C;KACnE;CACO,CAAC;AAEX;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,IAAI,EAAE;QACJ,kBAAkB,EAAE,4CAA4C;QAChE,uBAAuB,EAAE,4CAA4C;QACrE,mBAAmB,EAAE,4CAA4C;QACjE,eAAe,EAAE,4CAA4C;QAC7D,cAAc,EAAE;YACd,IAAI,EAAE,4CAA4C;SACnD;KACF;IACD,IAAI,EAAE;QACJ,kBAAkB,EAAE,4CAA4C;QAChE,uBAAuB,EAAE,4CAA4C;QACrE,mBAAmB,EAAE,4CAA4C;QACjE,eAAe,EAAE,4CAA4C;QAC7D,cAAc,EAAE;YACd,IAAI,EAAE,4CAA4C;SACnD;KACF;CACO,CAAC"}

package/dist/deployments.js

@@ -0,0 +1,52 @@
+import { DEPLOYMENTS } from './deployments.generated.js';
+export { DEPLOYMENTS };
+/** Thrown when the SDK is asked about a chain it ships no address book for. */
+export class UnknownChainError extends Error {
+    chainId;
+    constructor(chainId) {
+        super(`Peddles SDK has no deployment for chain ${chainId}. ` +
+            `Known chains: ${Object.keys(DEPLOYMENTS).join(', ')}. ` +
+            `Pass an explicit address map if you are pointing at a private deployment.`);
+        this.name = 'UnknownChainError';
+        this.chainId = chainId;
+    }
+}
+/** Thrown when a chain is known but does not carry the contract being asked for. */
+export class UnknownContractError extends Error {
+    constructor(chainId, name) {
+        super(`Peddles SDK has no address for ${name} on chain ${chainId}. ` +
+            `That deployment may predate the contract.`);
+        this.name = 'UnknownContractError';
+    }
+}
+export function isKnownChain(chainId) {
+    return Object.prototype.hasOwnProperty.call(DEPLOYMENTS, chainId);
+}
+/**
+ * The address book for one chain.
+ *
+ * FAILS CLOSED, ALWAYS. An unknown chain throws rather than returning a default
+ * or an empty map, and a missing contract throws rather than returning
+ * `undefined` or the zero address. Both of those alternatives look like a
+ * working call right up until a transaction is signed against nothing.
+ *
+ * This is not hypothetical in this codebase: every address changed in a single
+ * redeploy, and one stale copy of this list had the API quoting a launchpad that
+ * no longer existed — an error that surfaced as "neither leg is a launched coin"
+ * rather than as a missing address.
+ */
+export function deploymentFor(chainId) {
+    if (!isKnownChain(chainId))
+        throw new UnknownChainError(chainId);
+    return DEPLOYMENTS[chainId];
+}
+/** One address, or a throw. Never a default, never the zero address. */
+export function addressOf(chainId, name) {
+    const book = deploymentFor(chainId);
+    // Own properties only: `book['constructor']` would otherwise return a function.
+    const found = Object.prototype.hasOwnProperty.call(book, name) ? book[name] : undefined;
+    if (!found || /^0x0{40}$/.test(found))
+        throw new UnknownContractError(chainId, name);
+    return found;
+}
+//# sourceMappingURL=deployments.js.map

package/dist/deployments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployments.js","sourceRoot":"","sources":["../src/deployments.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAwC,MAAM,4BAA4B,CAAC;AAE/F,OAAO,EAAE,WAAW,EAAE,CAAC;AAGvB,+EAA+E;AAC/E,MAAM,OAAO,iBAAkB,SAAQ,KAAK;IACjC,OAAO,CAAS;IACzB,YAAY,OAAe;QACzB,KAAK,CACH,2CAA2C,OAAO,IAAI;YACpD,iBAAiB,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI;YACxD,2EAA2E,CAC9E,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC;QAChC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;CACF;AAED,oFAAoF;AACpF,MAAM,OAAO,oBAAqB,SAAQ,KAAK;IAC7C,YAAY,OAAe,EAAE,IAAY;QACvC,KAAK,CACH,kCAAkC,IAAI,aAAa,OAAO,IAAI;YAC5D,2CAA2C,CAC9C,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC;IACrC,CAAC;CACF;AAED,MAAM,UAAU,YAAY,CAAC,OAAe;IAC1C,OAAO,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;AACpE,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,aAAa,CAAC,OAAe;IAC3C,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;QAAE,MAAM,IAAI,iBAAiB,CAAC,OAAO,CAAC,CAAC;IACjE,OAAO,WAAW,CAAC,OAAO,CAA4C,CAAC;AACzE,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,SAAS,CAAC,OAAe,EAAE,IAAY;IACrD,MAAM,IAAI,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;IACpC,gFAAgF;IAChF,MAAM,KAAK,GAAG,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACxF,IAAI,CAAC,KAAK,IAAI,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC;QAAE,MAAM,IAAI,oBAAoB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IACrF,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/feeSplit.d.ts

@@ -0,0 +1,54 @@
+/**
+ * How one charged fee divides — the exact arithmetic `PeddlesFeeHook._book` runs.
+ *
+ * IMPORT-FREE on purpose, like `clogInflow.ts`: it is pure bigint maths with no
+ * runtime, so a UI, an indexer or a test can use it without pulling in viem.
+ *
+ * THE MODEL (fixed at launch, never changed afterwards):
+ *
+ *   creatorTaxBps       the ALL-IN rate a trader pays, 100..1000 (1%..10%)
+ *   excessToCreatorBps  the creator's share of everything ABOVE the two fixed
+ *                       0.50% legs, 0..10000; the rest of that excess is holders'
+ *
+ *   platform    = fee × 50 / creatorTaxBps                       (floored)
+ *   creatorBase = fee × 50 / creatorTaxBps                       (floored)
+ *   excess      = fee − platform − creatorBase
+ *   creator     = creatorBase + excess × excessToCreatorBps / 10000   (floored)
+ *   holders     = fee − platform − creator                      (the remainder)
+ *
+ * Every floor lands its dust with holders, so `platform + creator + holders`
+ * equals `fee` exactly; at `excessToCreatorBps == 10000` the holder leg is 0.
+ *
+ * `fee` is what the hook CHARGED, in the pool's quote asset. It is not the trade
+ * size: the hook charges `gross × creatorTaxBps / 10000` (floored) on an exact-in
+ * trade and grosses up an exact-out one. During a pool's opening window the hook
+ * uses a different, fixed split (½ liquidity / ¼ creator / ¼ platform) that this
+ * function does not model.
+ */
+/** `PeddlesFeeHook.PLATFORM_FEE_BPS`. */
+export declare const PLATFORM_FEE_BPS = 50;
+/** `PeddlesFeeHook.CREATOR_FEE_BPS`. */
+export declare const CREATOR_FEE_BPS = 50;
+/** `PeddlesFeeHook.MIN_CREATOR_TAX_BPS` — the two fixed legs added together. */
+export declare const MIN_CREATOR_TAX_BPS: number;
+/** `PeddlesFeeHook.MAX_CREATOR_TAX_BPS`. */
+export declare const MAX_CREATOR_TAX_BPS = 1000;
+/** Basis-point denominator. */
+export declare const BPS = 10000;
+/** `PeddlesFeeHook.MAX_FEE_AMOUNT` — the largest fee one accrual can represent (int128 max). */
+export declare const MAX_FEE_AMOUNT: bigint;
+/** One fee, divided. Base units of the pool's quote asset. */
+export interface FeeSplit {
+    readonly platform: bigint;
+    readonly creator: bigint;
+    readonly holders: bigint;
+}
+/**
+ * Divide a charged fee between platform, creator and holders.
+ *
+ * Throws `RangeError` for terms `registerPool` would refuse, and for a fee the
+ * hook would not charge at all (negative, or above `MAX_FEE_AMOUNT`). Returning a
+ * split for either would describe a charge that cannot happen.
+ */
+export declare function feeSplit(creatorTaxBps: number, excessToCreatorBps: number, fee: bigint): FeeSplit;
+//# sourceMappingURL=feeSplit.d.ts.map

package/dist/feeSplit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feeSplit.d.ts","sourceRoot":"","sources":["../src/feeSplit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,yCAAyC;AACzC,eAAO,MAAM,gBAAgB,KAAK,CAAC;AACnC,wCAAwC;AACxC,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,gFAAgF;AAChF,eAAO,MAAM,mBAAmB,QAAqC,CAAC;AACtE,4CAA4C;AAC5C,eAAO,MAAM,mBAAmB,OAAO,CAAC;AACxC,+BAA+B;AAC/B,eAAO,MAAM,GAAG,QAAS,CAAC;AAC1B,gGAAgG;AAChG,eAAO,MAAM,cAAc,QAAoB,CAAC;AAEhD,8DAA8D;AAC9D,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAQD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,aAAa,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,CAcjG"}

package/dist/feeSplit.js

@@ -0,0 +1,69 @@
+/**
+ * How one charged fee divides — the exact arithmetic `PeddlesFeeHook._book` runs.
+ *
+ * IMPORT-FREE on purpose, like `clogInflow.ts`: it is pure bigint maths with no
+ * runtime, so a UI, an indexer or a test can use it without pulling in viem.
+ *
+ * THE MODEL (fixed at launch, never changed afterwards):
+ *
+ *   creatorTaxBps       the ALL-IN rate a trader pays, 100..1000 (1%..10%)
+ *   excessToCreatorBps  the creator's share of everything ABOVE the two fixed
+ *                       0.50% legs, 0..10000; the rest of that excess is holders'
+ *
+ *   platform    = fee × 50 / creatorTaxBps                       (floored)
+ *   creatorBase = fee × 50 / creatorTaxBps                       (floored)
+ *   excess      = fee − platform − creatorBase
+ *   creator     = creatorBase + excess × excessToCreatorBps / 10000   (floored)
+ *   holders     = fee − platform − creator                      (the remainder)
+ *
+ * Every floor lands its dust with holders, so `platform + creator + holders`
+ * equals `fee` exactly; at `excessToCreatorBps == 10000` the holder leg is 0.
+ *
+ * `fee` is what the hook CHARGED, in the pool's quote asset. It is not the trade
+ * size: the hook charges `gross × creatorTaxBps / 10000` (floored) on an exact-in
+ * trade and grosses up an exact-out one. During a pool's opening window the hook
+ * uses a different, fixed split (½ liquidity / ¼ creator / ¼ platform) that this
+ * function does not model.
+ */
+/** `PeddlesFeeHook.PLATFORM_FEE_BPS`. */
+export const PLATFORM_FEE_BPS = 50;
+/** `PeddlesFeeHook.CREATOR_FEE_BPS`. */
+export const CREATOR_FEE_BPS = 50;
+/** `PeddlesFeeHook.MIN_CREATOR_TAX_BPS` — the two fixed legs added together. */
+export const MIN_CREATOR_TAX_BPS = PLATFORM_FEE_BPS + CREATOR_FEE_BPS;
+/** `PeddlesFeeHook.MAX_CREATOR_TAX_BPS`. */
+export const MAX_CREATOR_TAX_BPS = 1000;
+/** Basis-point denominator. */
+export const BPS = 10_000;
+/** `PeddlesFeeHook.MAX_FEE_AMOUNT` — the largest fee one accrual can represent (int128 max). */
+export const MAX_FEE_AMOUNT = (1n << 127n) - 1n;
+function assertBps(label, value, min, max) {
+    if (!Number.isInteger(value) || value < min || value > max) {
+        throw new RangeError(`${label} must be an integer in [${min}, ${max}], got ${String(value)}`);
+    }
+}
+/**
+ * Divide a charged fee between platform, creator and holders.
+ *
+ * Throws `RangeError` for terms `registerPool` would refuse, and for a fee the
+ * hook would not charge at all (negative, or above `MAX_FEE_AMOUNT`). Returning a
+ * split for either would describe a charge that cannot happen.
+ */
+export function feeSplit(creatorTaxBps, excessToCreatorBps, fee) {
+    assertBps('creatorTaxBps', creatorTaxBps, MIN_CREATOR_TAX_BPS, MAX_CREATOR_TAX_BPS);
+    assertBps('excessToCreatorBps', excessToCreatorBps, 0, BPS);
+    if (typeof fee !== 'bigint')
+        throw new TypeError('fee must be a bigint in base units');
+    if (fee < 0n)
+        throw new RangeError(`fee must not be negative, got ${fee}`);
+    if (fee > MAX_FEE_AMOUNT)
+        throw new RangeError(`fee ${fee} exceeds MAX_FEE_AMOUNT; the hook charges nothing`);
+    const total = BigInt(creatorTaxBps);
+    const platform = (fee * BigInt(PLATFORM_FEE_BPS)) / total;
+    const creatorBase = (fee * BigInt(CREATOR_FEE_BPS)) / total;
+    const excess = fee - platform - creatorBase;
+    const creator = creatorBase + (excess * BigInt(excessToCreatorBps)) / BigInt(BPS);
+    const holders = fee - platform - creator;
+    return { platform, creator, holders };
+}
+//# sourceMappingURL=feeSplit.js.map

package/dist/feeSplit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feeSplit.js","sourceRoot":"","sources":["../src/feeSplit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,yCAAyC;AACzC,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,CAAC;AACnC,wCAAwC;AACxC,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,CAAC;AAClC,gFAAgF;AAChF,MAAM,CAAC,MAAM,mBAAmB,GAAG,gBAAgB,GAAG,eAAe,CAAC;AACtE,4CAA4C;AAC5C,MAAM,CAAC,MAAM,mBAAmB,GAAG,IAAI,CAAC;AACxC,+BAA+B;AAC/B,MAAM,CAAC,MAAM,GAAG,GAAG,MAAM,CAAC;AAC1B,gGAAgG;AAChG,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,EAAE,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;AAShD,SAAS,SAAS,CAAC,KAAa,EAAE,KAAa,EAAE,GAAW,EAAE,GAAW;IACvE,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,GAAG,IAAI,KAAK,GAAG,GAAG,EAAE,CAAC;QAC3D,MAAM,IAAI,UAAU,CAAC,GAAG,KAAK,2BAA2B,GAAG,KAAK,GAAG,UAAU,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAChG,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,QAAQ,CAAC,aAAqB,EAAE,kBAA0B,EAAE,GAAW;IACrF,SAAS,CAAC,eAAe,EAAE,aAAa,EAAE,mBAAmB,EAAE,mBAAmB,CAAC,CAAC;IACpF,SAAS,CAAC,oBAAoB,EAAE,kBAAkB,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;IAC5D,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,MAAM,IAAI,SAAS,CAAC,oCAAoC,CAAC,CAAC;IACvF,IAAI,GAAG,GAAG,EAAE;QAAE,MAAM,IAAI,UAAU,CAAC,iCAAiC,GAAG,EAAE,CAAC,CAAC;IAC3E,IAAI,GAAG,GAAG,cAAc;QAAE,MAAM,IAAI,UAAU,CAAC,OAAO,GAAG,mDAAmD,CAAC,CAAC;IAE9G,MAAM,KAAK,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;IACpC,MAAM,QAAQ,GAAG,CAAC,GAAG,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC,GAAG,KAAK,CAAC;IAC1D,MAAM,WAAW,GAAG,CAAC,GAAG,GAAG,MAAM,CAAC,eAAe,CAAC,CAAC,GAAG,KAAK,CAAC;IAC5D,MAAM,MAAM,GAAG,GAAG,GAAG,QAAQ,GAAG,WAAW,CAAC;IAC5C,MAAM,OAAO,GAAG,WAAW,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,kBAAkB,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IAClF,MAAM,OAAO,GAAG,GAAG,GAAG,QAAQ,GAAG,OAAO,CAAC;IACzC,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;AACxC,CAAC"}