@vultisig/rujira 12.0.0 → 13.0.0

package/CHANGELOG.md

@@ -1,5 +1,78 @@
 # @vultisig/rujira
 
+## 13.0.0
+
+### Major Changes
+
+- [#299](https://github.com/vultisig/vultisig-sdk/pull/299) [`4af5bb8`](https://github.com/vultisig/vultisig-sdk/commit/4af5bb8043da7dab15b5e1a135e5195d2dd1d7cc) Thanks [@gomesalexandre](https://github.com/gomesalexandre)! - feat(rujira)!: drop RujiraPerps
+
+  **BREAKING CHANGE.** The `RujiraPerps` module is removed. Its only
+  consumer was vultisig-mcp-ts' `src/tools/rujira/perps.ts`, which
+  [mcp-ts#36](https://github.com/vultisig/mcp-ts/pull/36) deleted
+  (commit `e5ecb58`). No known external consumers.
+
+  Removed:
+  - `RujiraPerps` class export
+  - `PerpsMarket` type export
+  - `PerpsTransactionParams` type export
+  - `client.perps` field on `RujiraClient`
+  - `@vultisig/rujira/perps` subpath export
+
+  No replacement API. Consumers that still need perps-style interactions
+  should open an issue — the module was a thin wrapper around on-chain
+  calls that can be reconstructed if there's demand.
+
+  All other Rujira surfaces (swap, orderbook, staking, ghost, deposit,
+  withdraw, discovery) are unchanged.
+
+### Patch Changes
+
+- Updated dependencies [[`2018787`](https://github.com/vultisig/vultisig-sdk/commit/2018787f8101ea9a98e975c0e7477245c3f86fad), [`f52057b`](https://github.com/vultisig/vultisig-sdk/commit/f52057b4af859018d1c180fa6db9ce15e153409f)]:
+  - @vultisig/sdk@0.18.0
+
+## 12.1.0
+
+### Minor Changes
+
+- [#300](https://github.com/vultisig/vultisig-sdk/pull/300) [`2da432d`](https://github.com/vultisig/vultisig-sdk/commit/2da432d3e972802ee246584971c5abca05b49797) Thanks [@gomesalexandre](https://github.com/gomesalexandre)! - feat(rujira): CCL (Custom Concentrated Liquidity) support
+
+  Rujira shipped [Custom Concentrated Liquidity](https://rujira.network/trade) on RUJI Trade
+  on 2026-04-20. This release adds SDK support for range-position management on
+  `rujira-fin` pair contracts via a new `range` ExecuteMsg variant.
+
+  New surface:
+  - **`client.range: RujiraRange`** — pure builders (no signer needed):
+    - `buildCreatePosition({ pairAddress, config, base, quote })`
+    - `buildDeposit({ pairAddress, idx, base, quote })`
+    - `buildWithdraw({ pairAddress, idx, share })`
+    - `buildClaim({ pairAddress, idx })`
+    - `buildTransfer({ pairAddress, idx, to })`
+    - `buildWithdrawAll({ pairAddress, idx })` — returns `RangeMultiTransactionParams`
+      with `[claim, withdraw('1')]`. Callers MUST sign + broadcast both msgs in a
+      single cosmos tx for atomicity (`wasm_execute_multi`).
+  - **GraphQL helpers** (against `api.vultisig.com/ruji/api/graphql`):
+    - `client.range.getPositions(owner)` — list all range positions
+    - `client.range.getPosition(pairAddress, idx)` — single position analytics
+    - `client.range.getPairAddress(base, quote)` — resolve FIN pair contract
+      from tickers / denoms (exact-match preferred, single-candidate fuzzy
+      match fallback; ambiguous hits throw `INVALID_PARAMS`)
+  - **`@vultisig/rujira/ccl` subpath export** — CCL math module ported from
+    rujira-ui (MIT): linear + quadratic weight models, √price Newton-Raphson
+    price recovery, bucket distribution generator. 90 tests pass.
+  - **`@vultisig/rujira/range` subpath export** — just the RujiraRange class
+    - types for consumers that want to avoid pulling the full entry point.
+  - **`RujiraErrorCode.INVALID_PARAMS`** — new error code for the input
+    validation surface (Decimal12 for config fields, Decimal4 + `(0, 1]` for
+    withdraw share, `idx` strictly `/^\d+$/`, `thor1` prefix on pair addresses).
+
+  No change to existing `swap` / `orderbook` / `staking` / `ghost` / `deposit` /
+  `withdraw` / `discovery` surfaces.
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @vultisig/sdk@0.17.1
+
 ## 12.0.0
 
 ### Patch Changes

package/dist/ccl/base.d.ts

@@ -0,0 +1,17 @@
+export declare abstract class Ccl {
+    readonly high: number;
+    readonly low: number;
+    protected sA: number;
+    protected sB: number;
+    constructor(high: number, low: number);
+    protected abstract yAt(s: number): number;
+    protected abstract xAt(s: number): number;
+    protected abstract yPrime(s: number): number;
+    protected abstract xPrime(s: number): number;
+    abstract weight(p: number): number;
+    price(base: number, quote: number): number;
+    ask(price: number, spread: number): number;
+    bid(price: number, spread: number): number;
+    balanceRatio(price: number): number | null;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/ccl/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/ccl/base.ts"],"names":[],"mappings":"AAIA,8BAAsB,GAAG;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,SAAS,CAAC,EAAE,EAAE,MAAM,CAAA;IACpB,SAAS,CAAC,EAAE,EAAE,MAAM,CAAA;gBAER,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;IAarC,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IACzC,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IACzC,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAC5C,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAC5C,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAGlC,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM;IAsC1C,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAI1C,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAI1C,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;CAM3C"}

package/dist/ccl/base.js

@@ -0,0 +1,60 @@
+import { RujiraError, RujiraErrorCode } from '../errors.js';
+const NEWTON_ITERATIONS = 6;
+export class Ccl {
+    constructor(high, low) {
+        if (!Number.isFinite(high) || !Number.isFinite(low) || low < 0 || high < low) {
+            throw new RujiraError(RujiraErrorCode.INVALID_PARAMS, `CCL range bounds must be finite and satisfy 0 <= low <= high (got high=${high}, low=${low})`);
+        }
+        this.high = high;
+        this.low = low;
+        this.sA = Math.sqrt(low);
+        this.sB = Math.sqrt(high);
+    }
+    // Newton-Raphson: solve F(s) = x·Y(s) - y·X(s) = 0
+    price(base, quote) {
+        // Reject non-finite / negative inputs up front so a bad parsed
+        // number from upstream (NaN from a failed parseFloat, or an
+        // Infinity from a bogus scaling) can't propagate through the
+        // solver and produce a NaN price. Exported helpers MUST fail
+        // loudly on invalid inputs — silent NaN is worse than a throw.
+        if (!Number.isFinite(base) || !Number.isFinite(quote) || base < 0 || quote < 0) {
+            throw new RujiraError(RujiraErrorCode.INVALID_PARAMS, `price() requires finite non-negative base/quote (got base=${base}, quote=${quote})`);
+        }
+        if (quote === 0)
+            return this.sA * this.sA;
+        if (base === 0)
+            return this.sB * this.sB;
+        let s = Math.sqrt(this.sA * this.sB);
+        for (let i = 0; i < NEWTON_ITERATIONS; i++) {
+            const f = base * this.yAt(s) - quote * this.xAt(s);
+            const fPrime = base * this.yPrime(s) - quote * this.xPrime(s);
+            if (fPrime === 0)
+                break;
+            const delta = f / fPrime;
+            if (delta < 0) {
+                s = s + Math.abs(delta);
+            }
+            else if (Math.abs(delta) > s) {
+                s = this.sA;
+            }
+            else {
+                s = s - Math.abs(delta);
+            }
+            s = Math.max(this.sA, Math.min(this.sB, s));
+        }
+        return s * s;
+    }
+    ask(price, spread) {
+        return price + (price * spread) / 2;
+    }
+    bid(price, spread) {
+        return Math.max(0, price - (price * spread) / 2);
+    }
+    balanceRatio(price) {
+        const s = Math.sqrt(price);
+        const xS = this.xAt(s);
+        if (xS === 0)
+            return null;
+        return this.yAt(s) / xS;
+    }
+}

package/dist/ccl/ccl.d.ts

@@ -0,0 +1,5 @@
+import type { Ccl } from './base.js';
+import type { CclDistribution, CclModel, CclRangeConfig } from './types.js';
+export declare function createCcl(high: number, low: number, sigma: number, model?: CclModel): Ccl;
+export declare function generateCclDistribution(config: CclRangeConfig): CclDistribution;
+//# sourceMappingURL=ccl.d.ts.map

package/dist/ccl/ccl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ccl.d.ts","sourceRoot":"","sources":["../../src/ccl/ccl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAA;AAGpC,OAAO,KAAK,EAAE,eAAe,EAAyB,QAAQ,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAElG,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,GAAE,QAAmB,GAAG,GAAG,CAEnG;AAGD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,cAAc,GAAG,eAAe,CA6E/E"}

package/dist/ccl/ccl.js

@@ -0,0 +1,73 @@
+import { CclLinear } from './linear.js';
+import { CclQuadratic } from './quadratic.js';
+export function createCcl(high, low, sigma, model = 'linear') {
+    return model === 'quadratic' ? new CclQuadratic(high, low, sigma) : new CclLinear(high, low, sigma);
+}
+// Generates distribution using geometric (delta-based) stepping matching Rust RangeOfferIter
+export function generateCclDistribution(config) {
+    const { high, low, price, sigma, spread, delta, model } = config;
+    const empty = {
+        asks: [],
+        bids: [],
+        price: 0,
+        askPrice: 0,
+        bidPrice: 0,
+        avgAskFillPrice: 0,
+        avgBidFillPrice: 0,
+        balanceRatio: null,
+    };
+    if (![high, low, price, sigma, spread, delta].every(Number.isFinite) ||
+        high <= low ||
+        low <= 0 ||
+        price <= 0 ||
+        spread < 0 ||
+        spread >= 1 ||
+        delta <= 0) {
+        return empty;
+    }
+    const ccl = createCcl(high, low, sigma, model);
+    const askPrice = ccl.ask(price, spread);
+    const bidPrice = ccl.bid(price, spread);
+    const asks = [];
+    const bids = [];
+    let askWeight = 0;
+    let bidWeight = 0;
+    // Asks: geometric steps ascending from askPrice to high
+    let p = askPrice;
+    while (p < high) {
+        const next = Math.min(p + p * delta, high);
+        if (next <= p)
+            break;
+        const pMid = (p + next) / 2;
+        const w = Math.max(0, ccl.weight(pMid));
+        asks.push({ pStart: p, pEnd: next, pMid, weight: w, pct: 0, side: 'ask' });
+        askWeight += w;
+        p = next;
+    }
+    // Bids: geometric steps descending from bidPrice to low
+    p = bidPrice;
+    while (p > low) {
+        const next = Math.max(p - p * delta, low);
+        if (next <= 0 || next >= p)
+            break;
+        const pMid = (next + p) / 2;
+        const w = Math.max(0, ccl.weight(pMid));
+        bids.push({ pStart: next, pEnd: p, pMid, weight: w, pct: 0, side: 'bid' });
+        bidWeight += w;
+        p = next;
+    }
+    if (askWeight > 0) {
+        for (const bucket of asks) {
+            bucket.pct = (bucket.weight / askWeight) * 100;
+        }
+    }
+    if (bidWeight > 0) {
+        for (const bucket of bids) {
+            bucket.pct = (bucket.weight / bidWeight) * 100;
+        }
+    }
+    const avgAskFillPrice = askWeight > 0 ? asks.reduce((sum, b) => sum + b.pMid * b.weight, 0) / askWeight : 0;
+    const avgBidFillPrice = bidWeight > 0 ? bids.reduce((sum, b) => sum + b.pMid * b.weight, 0) / bidWeight : 0;
+    const balanceRatio = ccl.balanceRatio(price);
+    return { asks, bids, price, askPrice, bidPrice, avgAskFillPrice, avgBidFillPrice, balanceRatio };
+}

package/dist/ccl/ccl.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ccl.test.d.ts.map

package/dist/ccl/ccl.test.d.ts.map

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

package/dist/ccl/ccl.test.js

@@ -0,0 +1,281 @@
+import { describe, expect, it } from 'vitest';
+import { createCcl, generateCclDistribution } from './ccl.js';
+import { CclLinear } from './linear.js';
+import { CclQuadratic } from './quadratic.js';
+const models = [
+    { name: 'quadratic', create: (h, l, s) => new CclQuadratic(h, l, s) },
+    { name: 'linear', create: (h, l, s) => new CclLinear(h, l, s) },
+];
+// ============================================================
+// Shared base class behavior — runs against BOTH models
+// ============================================================
+describe.each(models)('Ccl base [$name]', ({ create }) => {
+    describe('price', () => {
+        it('returns low when quote=0', () => {
+            const ccl = create(4000, 3000, 0);
+            expect(ccl.price(100000, 0)).toBeCloseTo(3000, 0);
+        });
+        it('returns high when base=0', () => {
+            const ccl = create(4000, 3000, 0);
+            expect(ccl.price(0, 401992761)).toBeCloseTo(4000, 0);
+        });
+        it('stays within [low, high] for all skew values', () => {
+            const cases = [
+                [0.9, 100, 1000000],
+                [-0.9, 100, 1000000],
+                [0.5, 1000000, 1],
+                [0.99, 500000, 500000],
+                [-0.99, 500000, 500000],
+            ];
+            for (const [sigma, b, q] of cases) {
+                const ccl = create(4, 3, sigma);
+                const price = ccl.price(b, q);
+                expect(price).toBeGreaterThanOrEqual(3);
+                expect(price).toBeLessThanOrEqual(4);
+            }
+        });
+    });
+    describe('ask / bid', () => {
+        it('ask = price + price * spread', () => {
+            const ccl = create(4, 3, 0);
+            const price = 3.5;
+            const spread = 0.01;
+            expect(ccl.ask(price, spread)).toBeCloseTo(price + (price * spread) / 2);
+        });
+        it('bid = price - price * spread', () => {
+            const ccl = create(4, 3, 0);
+            const price = 3.5;
+            const spread = 0.01;
+            expect(ccl.bid(price, spread)).toBeCloseTo(price - (price * spread) / 2);
+        });
+        it('bid floors at 0', () => {
+            const ccl = create(4, 3, 0);
+            expect(ccl.bid(0.01, 2)).toBe(0);
+        });
+        it('ask returns price between center and high', () => {
+            const ccl = create(4, 3, 0);
+            const base = 100000000;
+            const quote = 401992761;
+            const price = ccl.price(base, quote);
+            const askPrice = ccl.ask(price, 0.01);
+            expect(askPrice).toBeGreaterThan(price);
+        });
+        it('bid returns price between low and center', () => {
+            const ccl = create(4, 3, 0);
+            const base = 100000000;
+            const quote = 401992761;
+            const price = ccl.price(base, quote);
+            const bidPrice = ccl.bid(price, 0.01);
+            expect(bidPrice).toBeLessThan(price);
+            expect(bidPrice).toBeGreaterThanOrEqual(0);
+        });
+    });
+    describe('balanceRatio', () => {
+        it('returns positive ratio at mid-range price', () => {
+            const ccl = create(4, 3, 0);
+            const ratio = ccl.balanceRatio(3.5);
+            expect(ratio).not.toBeNull();
+            expect(ratio).toBeGreaterThan(0);
+        });
+        it('returns null at upper bound (x=0)', () => {
+            const ccl = create(4, 3, 0);
+            expect(ccl.balanceRatio(4)).toBeNull();
+        });
+        it('ratio increases as price moves toward high', () => {
+            const ccl = create(4, 3, 0);
+            const ratioLow = ccl.balanceRatio(3.2);
+            const ratioHigh = ccl.balanceRatio(3.8);
+            expect(ratioHigh).toBeGreaterThan(ratioLow);
+        });
+    });
+});
+// ============================================================
+// Roundtrip: balanceRatio(p) → price(base, quote) ≈ p
+// ============================================================
+describe.each(models)('balanceRatio roundtrip [$name]', ({ create }) => {
+    const prices = [3.2, 3.5, 3.8];
+    const sigmas = [0, 0.5, -0.5, 0.8, -0.8];
+    const base = 100_000_000;
+    it.each(sigmas.flatMap(s => prices.map(p => ({ s, p }))))('σ=$s p=$p → quoted price matches', ({ s, p }) => {
+        const ccl = create(4, 3, s);
+        const ratio = ccl.balanceRatio(p);
+        expect(ratio).not.toBeNull();
+        const quote = Math.round(base * ratio);
+        const quoted = ccl.price(base, quote);
+        expect(quoted).toBeCloseTo(p, 4);
+    });
+});
+// ============================================================
+// Rust reference values
+// ============================================================
+describe('CclQuadratic price reference', () => {
+    it('computes price matching Rust cl_pricing test', () => {
+        const ccl = new CclQuadratic(4000, 3000, 0);
+        const price = ccl.price(100000, 401992761);
+        expect(price).toBeGreaterThanOrEqual(3499);
+        expect(price).toBeLessThanOrEqual(3501);
+    });
+});
+// ============================================================
+// createCcl factory
+// ============================================================
+describe('createCcl factory', () => {
+    it('defaults to linear', () => {
+        expect(createCcl(4, 3, 0)).toBeInstanceOf(CclLinear);
+    });
+    it('creates quadratic when specified', () => {
+        expect(createCcl(4, 3, 0, 'quadratic')).toBeInstanceOf(CclQuadratic);
+    });
+    it('creates linear when specified', () => {
+        expect(createCcl(4, 3, 0, 'linear')).toBeInstanceOf(CclLinear);
+    });
+});
+// ============================================================
+// generateCclDistribution — delta-based stepping
+// ============================================================
+describe.each(models.map(m => m.name))('generateCclDistribution [%s]', model => {
+    const baseConfig = {
+        high: 4,
+        low: 3,
+        price: 3.5,
+        sigma: 0,
+        spread: 0.01,
+        delta: 0.05,
+        model,
+    };
+    it('mid price equals provided price', () => {
+        const dist = generateCclDistribution(baseConfig);
+        expect(dist.price).toBe(3.5);
+    });
+    it('returns buckets that sum to 100%', () => {
+        const dist = generateCclDistribution(baseConfig);
+        const askSum = dist.asks.reduce((s, b) => s + b.pct, 0);
+        const bidSum = dist.bids.reduce((s, b) => s + b.pct, 0);
+        expect(askSum).toBeCloseTo(100, 1);
+        expect(bidSum).toBeCloseTo(100, 1);
+    });
+    it('ask buckets cover [askPrice, high]', () => {
+        const dist = generateCclDistribution(baseConfig);
+        expect(dist.asks.length).toBeGreaterThan(0);
+        expect(dist.asks[0].pStart).toBeCloseTo(dist.askPrice, 6);
+        expect(dist.asks[dist.asks.length - 1].pEnd).toBeCloseTo(4, 6);
+    });
+    it('bid buckets cover [low, bidPrice]', () => {
+        const dist = generateCclDistribution(baseConfig);
+        expect(dist.bids.length).toBeGreaterThan(0);
+        // bids are ordered descending (first bucket is closest to spread)
+        expect(dist.bids[dist.bids.length - 1].pStart).toBeCloseTo(3, 1);
+        expect(dist.bids[0].pEnd).toBeCloseTo(dist.bidPrice, 6);
+    });
+    it('geometric steps: each ask bucket is wider than the previous', () => {
+        const dist = generateCclDistribution({ ...baseConfig, delta: 0.05 });
+        for (let i = 1; i < dist.asks.length - 1; i++) {
+            const prevWidth = dist.asks[i - 1].pEnd - dist.asks[i - 1].pStart;
+            const currWidth = dist.asks[i].pEnd - dist.asks[i].pStart;
+            expect(currWidth).toBeGreaterThanOrEqual(prevWidth - 1e-10);
+        }
+    });
+    it('σ=0 produces uniform distribution', () => {
+        const dist = generateCclDistribution(baseConfig);
+        const allBuckets = [...dist.asks, ...dist.bids];
+        const weights = allBuckets.map(b => b.weight);
+        const avg = weights.reduce((s, w) => s + w, 0) / weights.length;
+        for (const w of weights) {
+            expect(w).toBeCloseTo(avg, 1);
+        }
+    });
+    it('returns empty for invalid inputs', () => {
+        const dist = generateCclDistribution({ ...baseConfig, high: 2, low: 3 });
+        expect(dist.asks).toHaveLength(0);
+        expect(dist.bids).toHaveLength(0);
+    });
+    it('returns empty for delta=0', () => {
+        const dist = generateCclDistribution({ ...baseConfig, delta: 0 });
+        expect(dist.asks).toHaveLength(0);
+    });
+    it('avgAskFillPrice is between askPrice and high', () => {
+        const dist = generateCclDistribution(baseConfig);
+        expect(dist.avgAskFillPrice).toBeGreaterThanOrEqual(dist.askPrice);
+        expect(dist.avgAskFillPrice).toBeLessThanOrEqual(baseConfig.high);
+    });
+    it('avgBidFillPrice is between low and bidPrice', () => {
+        const dist = generateCclDistribution(baseConfig);
+        expect(dist.avgBidFillPrice).toBeGreaterThanOrEqual(baseConfig.low);
+        expect(dist.avgBidFillPrice).toBeLessThanOrEqual(dist.bidPrice);
+    });
+    it('avgAskFillPrice and avgBidFillPrice are 0 for invalid inputs', () => {
+        const dist = generateCclDistribution({ ...baseConfig, high: 2, low: 3 });
+        expect(dist.avgAskFillPrice).toBe(0);
+        expect(dist.avgBidFillPrice).toBe(0);
+    });
+    it('σ=0 avgAskFillPrice is near midpoint of ask range', () => {
+        const dist = generateCclDistribution(baseConfig);
+        const expectedMid = (dist.askPrice + baseConfig.high) / 2;
+        expect(dist.avgAskFillPrice).toBeCloseTo(expectedMid, 1);
+    });
+    it('σ=0 avgBidFillPrice is near midpoint of bid range', () => {
+        const dist = generateCclDistribution(baseConfig);
+        const expectedMid = (baseConfig.low + dist.bidPrice) / 2;
+        expect(dist.avgBidFillPrice).toBeCloseTo(expectedMid, 1);
+    });
+    it('balanceRatio roundtrips to price', () => {
+        const dist = generateCclDistribution(baseConfig);
+        expect(dist.balanceRatio).not.toBeNull();
+        const ccl = createCcl(4, 3, 0, model);
+        const base = 1e8;
+        const quote = Math.round(base * dist.balanceRatio);
+        expect(ccl.price(base, quote)).toBeCloseTo(3.5, 4);
+    });
+    it('smaller delta produces more buckets', () => {
+        const distSmall = generateCclDistribution({ ...baseConfig, delta: 0.01 });
+        const distLarge = generateCclDistribution({ ...baseConfig, delta: 0.1 });
+        const smallTotal = distSmall.asks.length + distSmall.bids.length;
+        const largeTotal = distLarge.asks.length + distLarge.bids.length;
+        expect(smallTotal).toBeGreaterThan(largeTotal);
+    });
+});
+// ============================================================
+// Distribution skew behavior
+// ============================================================
+describe('distribution skew (quadratic — symmetric)', () => {
+    const cfg = {
+        high: 4,
+        low: 3,
+        price: 3.5,
+        sigma: 0,
+        spread: 0.01,
+        delta: 0.05,
+        model: 'quadratic',
+    };
+    it('σ>0 concentrates asks near spread', () => {
+        const dist = generateCclDistribution({ ...cfg, sigma: 0.8 });
+        const asks = dist.asks;
+        expect(asks[0].pct).toBeGreaterThan(asks[asks.length - 1].pct);
+    });
+    it('σ<0 concentrates asks near edge', () => {
+        const dist = generateCclDistribution({ ...cfg, sigma: -0.8 });
+        const asks = dist.asks;
+        expect(asks[asks.length - 1].pct).toBeGreaterThan(asks[0].pct);
+    });
+});
+describe('distribution skew (linear — directional)', () => {
+    const cfg = {
+        high: 4,
+        low: 3,
+        price: 3.5,
+        sigma: 0,
+        spread: 0.01,
+        delta: 0.05,
+        model: 'linear',
+    };
+    it('σ>0 concentrates asks toward high', () => {
+        const dist = generateCclDistribution({ ...cfg, sigma: 0.8 });
+        const asks = dist.asks;
+        expect(asks[asks.length - 1].pct).toBeGreaterThan(asks[0].pct);
+    });
+    it('σ<0 concentrates asks toward low (near spread)', () => {
+        const dist = generateCclDistribution({ ...cfg, sigma: -0.8 });
+        const asks = dist.asks;
+        expect(asks[0].pct).toBeGreaterThan(asks[asks.length - 1].pct);
+    });
+});

package/dist/ccl/index.d.ts

@@ -0,0 +1,6 @@
+export * from './base.js';
+export * from './ccl.js';
+export { CclLinear } from './linear.js';
+export { CclQuadratic } from './quadratic.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/ccl/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ccl/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA;AACzB,cAAc,UAAU,CAAA;AACxB,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,cAAc,YAAY,CAAA"}

package/dist/ccl/index.js

@@ -0,0 +1,5 @@
+export * from './base.js';
+export * from './ccl.js';
+export { CclLinear } from './linear.js';
+export { CclQuadratic } from './quadratic.js';
+export * from './types.js';

package/dist/ccl/linear.d.ts

@@ -0,0 +1,12 @@
+import { Ccl } from './base.js';
+export declare class CclLinear extends Ccl {
+    private alpha;
+    private beta;
+    constructor(high: number, low: number, sigma: number);
+    protected yAt(s: number): number;
+    protected xAt(s: number): number;
+    protected yPrime(s: number): number;
+    protected xPrime(s: number): number;
+    weight(p: number): number;
+}
+//# sourceMappingURL=linear.d.ts.map

package/dist/ccl/linear.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linear.d.ts","sourceRoot":"","sources":["../../src/ccl/linear.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,GAAG,EAAE,MAAM,WAAW,CAAA;AAE/B,qBAAa,SAAU,SAAQ,GAAG;IAChC,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,IAAI,CAAQ;gBAER,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAgBpD,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAQhC,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAQhC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAKnC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAMnC,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;CAG1B"}

package/dist/ccl/linear.js

@@ -0,0 +1,47 @@
+// Linear weight: w(p) = 1 + σ·(p - p_m)/Δp
+// Coefficients: β = σ/Δp, α = 1 - β·p_m
+import { Ccl } from './base.js';
+export class CclLinear extends Ccl {
+    constructor(high, low, sigma) {
+        super(high, low);
+        const pM = (high + low) / 2;
+        const deltaP = high - low;
+        if (deltaP === 0) {
+            this.beta = 0;
+            this.alpha = 1;
+        }
+        else {
+            this.beta = sigma / deltaP;
+            this.alpha = 1 - this.beta * pM;
+        }
+    }
+    // Y(s) = α·(s - s_a) + (β/3)·(s³ - s_a³)
+    yAt(s) {
+        const diff = s - this.sA;
+        const sCubed = s * s * s;
+        const sACubed = this.sA * this.sA * this.sA;
+        return this.alpha * diff + (this.beta / 3) * (sCubed - sACubed);
+    }
+    // X(s) = (s_b - s)·(α/(s·s_b) + β)
+    xAt(s) {
+        const diff = this.sB - s;
+        const denom = s * this.sB;
+        if (denom === 0)
+            return 0;
+        return diff * (this.alpha / denom + this.beta);
+    }
+    // Y'(s) = α + β·s²
+    yPrime(s) {
+        return this.alpha + this.beta * s * s;
+    }
+    // X'(s) = -α/s² - β
+    xPrime(s) {
+        const s2 = s * s;
+        if (s2 === 0)
+            return 0;
+        return -this.alpha / s2 - this.beta;
+    }
+    weight(p) {
+        return this.alpha + this.beta * p;
+    }
+}

package/dist/ccl/quadratic.d.ts

@@ -0,0 +1,13 @@
+import { Ccl } from './base.js';
+export declare class CclQuadratic extends Ccl {
+    private c0;
+    private c2;
+    private c4;
+    constructor(high: number, low: number, sigma: number);
+    protected yAt(s: number): number;
+    protected xAt(s: number): number;
+    protected yPrime(s: number): number;
+    protected xPrime(s: number): number;
+    weight(p: number): number;
+}
+//# sourceMappingURL=quadratic.d.ts.map

package/dist/ccl/quadratic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quadratic.d.ts","sourceRoot":"","sources":["../../src/ccl/quadratic.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,GAAG,EAAE,MAAM,WAAW,CAAA;AAE/B,qBAAa,YAAa,SAAQ,GAAG;IACnC,OAAO,CAAC,EAAE,CAAQ;IAClB,OAAO,CAAC,EAAE,CAAQ;IAClB,OAAO,CAAC,EAAE,CAAQ;gBAEN,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAmBpD,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAShC,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAQhC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAMnC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAMnC,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;CAG1B"}