@mania-labs/mania-sdk 1.0.0 → 1.0.2

package/src/__tests__/unit/bondingCurve.test.ts

@@ -0,0 +1,357 @@
+import { describe, it, expect } from 'vitest';
+import { parseEther } from 'viem';
+import { BondingCurve, calculateBuyAmount, calculateSellAmount } from '../../bondingCurve.js';
+import { CURVE_SCENARIOS, INITIAL_RESERVES } from '../helpers/fixtures.js';
+import { TOTAL_FEE_BASIS_POINTS, MIGRATION_THRESHOLD } from '../../constants.js';
+
+describe('BondingCurve', () => {
+  describe('constructor and getState', () => {
+    it('should create instance with provided state', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.FRESH, TOTAL_FEE_BASIS_POINTS);
+      const state = curve.getState();
+      expect(state.virtualTokenReserves).toBe(CURVE_SCENARIOS.FRESH.virtualTokenReserves);
+    });
+
+    it('should return a copy of state, not reference', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.FRESH, TOTAL_FEE_BASIS_POINTS);
+      const state1 = curve.getState();
+      const state2 = curve.getState();
+      expect(state1).toEqual(state2);
+      expect(state1).not.toBe(state2);
+    });
+  });
+
+  describe('isComplete', () => {
+    it('should return false for fresh curve', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.FRESH, TOTAL_FEE_BASIS_POINTS);
+      expect(curve.isComplete()).toBe(false);
+    });
+
+    it('should return true for complete curve', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.COMPLETE, TOTAL_FEE_BASIS_POINTS);
+      expect(curve.isComplete()).toBe(true);
+    });
+  });
+
+  describe('isMigrated', () => {
+    it('should return false for active curve', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.FRESH, TOTAL_FEE_BASIS_POINTS);
+      expect(curve.isMigrated()).toBe(false);
+    });
+
+    it('should return false for complete but not migrated curve', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.COMPLETE, TOTAL_FEE_BASIS_POINTS);
+      expect(curve.isMigrated()).toBe(false);
+    });
+
+    it('should return true for migrated curve (all reserves zero)', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.MIGRATED, TOTAL_FEE_BASIS_POINTS);
+      expect(curve.isMigrated()).toBe(true);
+    });
+  });
+
+  describe('getCurrentPrice', () => {
+    it('should return price for fresh curve', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.FRESH, TOTAL_FEE_BASIS_POINTS);
+      const price = curve.getCurrentPrice();
+      expect(price).toBeGreaterThan(0n);
+    });
+
+    it('should return 0 for migrated curve', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.MIGRATED, TOTAL_FEE_BASIS_POINTS);
+      expect(curve.getCurrentPrice()).toBe(0n);
+    });
+
+    it('should increase with more ETH reserves', () => {
+      const freshCurve = new BondingCurve(CURVE_SCENARIOS.FRESH, TOTAL_FEE_BASIS_POINTS);
+      const halfCurve = new BondingCurve(CURVE_SCENARIOS.HALF_FILLED, TOTAL_FEE_BASIS_POINTS);
+
+      expect(halfCurve.getCurrentPrice()).toBeGreaterThan(freshCurve.getCurrentPrice());
+    });
+  });
+
+  describe('getMarketCapEth', () => {
+    it('should calculate market cap correctly', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.FRESH, TOTAL_FEE_BASIS_POINTS);
+      const marketCap = curve.getMarketCapEth();
+      expect(marketCap).toBeGreaterThan(0n);
+    });
+
+    it('should return 0 for migrated curve', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.MIGRATED, TOTAL_FEE_BASIS_POINTS);
+      expect(curve.getMarketCapEth()).toBe(0n);
+    });
+  });
+
+  describe('getMigrationProgress', () => {
+    it('should return 0 for fresh curve', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.FRESH, TOTAL_FEE_BASIS_POINTS);
+      expect(curve.getMigrationProgress()).toBe(0);
+    });
+
+    it('should return 50 for half-filled curve', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.HALF_FILLED, TOTAL_FEE_BASIS_POINTS);
+      expect(curve.getMigrationProgress()).toBe(50);
+    });
+
+    it('should return 100 for complete curve', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.COMPLETE, TOTAL_FEE_BASIS_POINTS);
+      expect(curve.getMigrationProgress()).toBe(100);
+    });
+  });
+
+  describe('getEthUntilMigration', () => {
+    it('should return 4 ETH for fresh curve', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.FRESH, TOTAL_FEE_BASIS_POINTS);
+      expect(curve.getEthUntilMigration()).toBe(MIGRATION_THRESHOLD);
+    });
+
+    it('should return 2 ETH for half-filled curve', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.HALF_FILLED, TOTAL_FEE_BASIS_POINTS);
+      expect(curve.getEthUntilMigration()).toBe(parseEther('2'));
+    });
+
+    it('should return 0 for complete curve', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.COMPLETE, TOTAL_FEE_BASIS_POINTS);
+      expect(curve.getEthUntilMigration()).toBe(0n);
+    });
+  });
+
+  describe('getBuyQuote', () => {
+    it('should return valid quote structure', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.FRESH, TOTAL_FEE_BASIS_POINTS);
+      const quote = curve.getBuyQuote(parseEther('0.1'));
+
+      expect(quote.tokensOut).toBeGreaterThan(0n);
+      expect(quote.fee).toBeGreaterThan(0n);
+      expect(quote.netEth).toBeGreaterThan(0n);
+      expect(quote.pricePerToken).toBeGreaterThan(0n);
+    });
+
+    it('should deduct fee from ETH amount', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.FRESH, TOTAL_FEE_BASIS_POINTS);
+      const ethAmount = parseEther('1');
+      const quote = curve.getBuyQuote(ethAmount);
+
+      expect(quote.fee).toBe(ethAmount / 100n); // 1% fee
+      expect(quote.netEth).toBe(ethAmount - quote.fee);
+    });
+
+    it('should return more tokens for larger ETH amounts', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.FRESH, TOTAL_FEE_BASIS_POINTS);
+      // Use smaller amounts that don't exceed realTokenReserves cap
+      const smallQuote = curve.getBuyQuote(parseEther('0.01'));
+      const largeQuote = curve.getBuyQuote(parseEther('0.02'));
+
+      expect(largeQuote.tokensOut).toBeGreaterThan(smallQuote.tokensOut);
+    });
+
+    it('should cap tokens at available supply', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.FRESH, TOTAL_FEE_BASIS_POINTS);
+      const hugeQuote = curve.getBuyQuote(parseEther('100'));
+
+      expect(hugeQuote.tokensOut).toBeLessThanOrEqual(CURVE_SCENARIOS.FRESH.realTokenReserves);
+    });
+  });
+
+  describe('getSellQuote', () => {
+    it('should return valid quote structure', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.HALF_FILLED, TOTAL_FEE_BASIS_POINTS);
+      const quote = curve.getSellQuote(parseEther('1000000'));
+
+      expect(quote.ethOutGross).toBeGreaterThan(0n);
+      expect(quote.fee).toBeGreaterThan(0n);
+      expect(quote.ethOutNet).toBeGreaterThan(0n);
+      expect(quote.pricePerToken).toBeGreaterThan(0n);
+    });
+
+    it('should deduct fee from ETH output', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.HALF_FILLED, TOTAL_FEE_BASIS_POINTS);
+      const quote = curve.getSellQuote(parseEther('1000000'));
+
+      expect(quote.ethOutNet).toBeLessThan(quote.ethOutGross);
+      expect(quote.ethOutNet).toBe(quote.ethOutGross - quote.fee);
+    });
+  });
+
+  describe('calculateMinTokensOut', () => {
+    it('should apply slippage correctly', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.FRESH, TOTAL_FEE_BASIS_POINTS);
+      const ethAmount = parseEther('0.1');
+      const quote = curve.getBuyQuote(ethAmount);
+      const minTokens = curve.calculateMinTokensOut(ethAmount, 100); // 1% slippage
+
+      expect(minTokens).toBeLessThan(quote.tokensOut);
+      // 1% slippage means 99% of quote
+      expect(minTokens).toBe((quote.tokensOut * 9900n) / 10000n);
+    });
+  });
+
+  describe('calculateMinEthOut', () => {
+    it('should apply slippage correctly', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.HALF_FILLED, TOTAL_FEE_BASIS_POINTS);
+      const tokenAmount = parseEther('1000000');
+      const quote = curve.getSellQuote(tokenAmount);
+      const minEth = curve.calculateMinEthOut(tokenAmount, 100); // 1% slippage
+
+      expect(minEth).toBeLessThan(quote.ethOutNet);
+      // 1% slippage means 99% of quote
+      expect(minEth).toBe((quote.ethOutNet * 9900n) / 10000n);
+    });
+  });
+
+  describe('calculateBuyPriceImpact', () => {
+    it('should return positive impact for buys', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.FRESH, TOTAL_FEE_BASIS_POINTS);
+      const impact = curve.calculateBuyPriceImpact(parseEther('0.1'));
+      expect(impact).toBeGreaterThan(0);
+    });
+
+    it('should increase with larger buy amounts', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.FRESH, TOTAL_FEE_BASIS_POINTS);
+      const smallImpact = curve.calculateBuyPriceImpact(parseEther('0.01'));
+      const largeImpact = curve.calculateBuyPriceImpact(parseEther('1'));
+
+      expect(largeImpact).toBeGreaterThan(smallImpact);
+    });
+
+    it('should return 0 for zero price', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.MIGRATED, TOTAL_FEE_BASIS_POINTS);
+      expect(curve.calculateBuyPriceImpact(parseEther('0.1'))).toBe(0);
+    });
+  });
+
+  describe('calculateSellPriceImpact', () => {
+    it('should return negative impact for sells', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.HALF_FILLED, TOTAL_FEE_BASIS_POINTS);
+      const impact = curve.calculateSellPriceImpact(parseEther('1000000'));
+      expect(impact).toBeLessThan(0);
+    });
+
+    it('should return 0 for zero price', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.MIGRATED, TOTAL_FEE_BASIS_POINTS);
+      expect(curve.calculateSellPriceImpact(parseEther('1000000'))).toBe(0);
+    });
+  });
+
+  describe('wouldExceedMigrationThreshold', () => {
+    it('should return false for small buys on fresh curve', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.FRESH, TOTAL_FEE_BASIS_POINTS);
+      expect(curve.wouldExceedMigrationThreshold(parseEther('0.1'))).toBe(false);
+    });
+
+    it('should return true for large buys on near-complete curve', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.NEAR_COMPLETE, TOTAL_FEE_BASIS_POINTS);
+      expect(curve.wouldExceedMigrationThreshold(parseEther('0.5'))).toBe(true);
+    });
+  });
+
+  describe('getMaxBuyAmount', () => {
+    it('should return positive amount for fresh curve', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.FRESH, TOTAL_FEE_BASIS_POINTS);
+      const maxBuy = curve.getMaxBuyAmount();
+      expect(maxBuy).toBeGreaterThan(0n);
+    });
+
+    it('should return 0 for complete curve', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.COMPLETE, TOTAL_FEE_BASIS_POINTS);
+      expect(curve.getMaxBuyAmount()).toBe(0n);
+    });
+
+    it('should account for fees', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.FRESH, TOTAL_FEE_BASIS_POINTS);
+      const maxBuy = curve.getMaxBuyAmount();
+      // Max buy should be slightly more than 4 ETH to account for fees
+      expect(maxBuy).toBeGreaterThan(MIGRATION_THRESHOLD);
+    });
+  });
+
+  describe('updateState', () => {
+    it('should update internal state', () => {
+      const curve = new BondingCurve(CURVE_SCENARIOS.FRESH, TOTAL_FEE_BASIS_POINTS);
+      curve.updateState(CURVE_SCENARIOS.HALF_FILLED);
+
+      const state = curve.getState();
+      expect(state.realEthReserves).toBe(CURVE_SCENARIOS.HALF_FILLED.realEthReserves);
+    });
+  });
+
+  describe('fromContractData', () => {
+    it('should create instance from contract tuple', () => {
+      const data = [
+        INITIAL_RESERVES.virtualTokenReserves,
+        INITIAL_RESERVES.virtualEthReserves,
+        INITIAL_RESERVES.realTokenReserves,
+        0n, // realEthReserves
+        INITIAL_RESERVES.tokenTotalSupply,
+        false, // complete
+        true, // trackVolume
+      ] as const;
+
+      const curve = BondingCurve.fromContractData(data, TOTAL_FEE_BASIS_POINTS);
+      const state = curve.getState();
+
+      expect(state.virtualTokenReserves).toBe(INITIAL_RESERVES.virtualTokenReserves);
+      expect(state.complete).toBe(false);
+      expect(state.trackVolume).toBe(true);
+    });
+  });
+});
+
+describe('calculateBuyAmount', () => {
+  it('should calculate tokens out correctly', () => {
+    const tokensOut = calculateBuyAmount(
+      INITIAL_RESERVES.virtualTokenReserves,
+      INITIAL_RESERVES.virtualEthReserves,
+      parseEther('0.1'),
+      TOTAL_FEE_BASIS_POINTS
+    );
+
+    expect(tokensOut).toBeGreaterThan(0n);
+  });
+
+  it('should match BondingCurve class calculation', () => {
+    const curve = new BondingCurve(CURVE_SCENARIOS.FRESH, TOTAL_FEE_BASIS_POINTS);
+    // Use smaller amount that doesn't trigger realTokenReserves cap
+    // (0.1 ETH would exceed cap, causing mismatch since utility can't cap)
+    const ethAmount = parseEther('0.01');
+
+    const classResult = curve.getBuyQuote(ethAmount).tokensOut;
+    const utilResult = calculateBuyAmount(
+      CURVE_SCENARIOS.FRESH.virtualTokenReserves,
+      CURVE_SCENARIOS.FRESH.virtualEthReserves,
+      ethAmount,
+      TOTAL_FEE_BASIS_POINTS
+    );
+
+    expect(utilResult).toBe(classResult);
+  });
+});
+
+describe('calculateSellAmount', () => {
+  it('should calculate ETH out correctly', () => {
+    const ethOut = calculateSellAmount(
+      CURVE_SCENARIOS.HALF_FILLED.virtualTokenReserves,
+      CURVE_SCENARIOS.HALF_FILLED.virtualEthReserves,
+      parseEther('1000000'),
+      TOTAL_FEE_BASIS_POINTS
+    );
+
+    expect(ethOut).toBeGreaterThan(0n);
+  });
+
+  it('should match BondingCurve class calculation', () => {
+    const curve = new BondingCurve(CURVE_SCENARIOS.HALF_FILLED, TOTAL_FEE_BASIS_POINTS);
+    const tokenAmount = parseEther('1000000');
+
+    const classResult = curve.getSellQuote(tokenAmount).ethOutNet;
+    const utilResult = calculateSellAmount(
+      CURVE_SCENARIOS.HALF_FILLED.virtualTokenReserves,
+      CURVE_SCENARIOS.HALF_FILLED.virtualEthReserves,
+      tokenAmount,
+      TOTAL_FEE_BASIS_POINTS
+    );
+
+    expect(utilResult).toBe(classResult);
+  });
+});

package/src/__tests__/unit/constants.test.ts

@@ -0,0 +1,136 @@
+import { describe, it, expect } from 'vitest';
+import { parseEther } from 'viem';
+import {
+  PROTOCOL_FEE_BASIS_POINTS,
+  CREATOR_FEE_BASIS_POINTS,
+  TOTAL_FEE_BASIS_POINTS,
+  MAX_FEE_BASIS_POINTS,
+  MIGRATION_THRESHOLD,
+  TOKENS_FOR_LP,
+  MAX_MIGRATE_FEES,
+  UNISWAP_FEE_TIER,
+  TICK_LOWER,
+  TICK_UPPER,
+  DEFAULT_SLIPPAGE_BPS,
+  BPS_DENOMINATOR,
+  CHAIN_CONFIGS,
+  getChainConfig,
+} from '../../constants.js';
+
+describe('Fee Constants', () => {
+  it('should have correct protocol fee (0.70%)', () => {
+    expect(PROTOCOL_FEE_BASIS_POINTS).toBe(70n);
+  });
+
+  it('should have correct creator fee (0.30%)', () => {
+    expect(CREATOR_FEE_BASIS_POINTS).toBe(30n);
+  });
+
+  it('should have correct total fee (1.00%)', () => {
+    expect(TOTAL_FEE_BASIS_POINTS).toBe(100n);
+  });
+
+  it('should have fees sum correctly', () => {
+    expect(PROTOCOL_FEE_BASIS_POINTS + CREATOR_FEE_BASIS_POINTS).toBe(TOTAL_FEE_BASIS_POINTS);
+  });
+
+  it('should have max fee of 10%', () => {
+    expect(MAX_FEE_BASIS_POINTS).toBe(1000n);
+  });
+});
+
+describe('Migration Constants', () => {
+  it('should have migration threshold of 4 ETH', () => {
+    expect(MIGRATION_THRESHOLD).toBe(parseEther('4'));
+  });
+
+  it('should have tokens for LP of 206.9M', () => {
+    expect(TOKENS_FOR_LP).toBe(206_900_000_000_000_000_000_000_000n);
+  });
+
+  it('should have max migrate fees of 0.0003 ETH', () => {
+    expect(MAX_MIGRATE_FEES).toBe(300_000_000_000_000n);
+  });
+});
+
+describe('Uniswap V3 Constants', () => {
+  it('should have fee tier of 0.3%', () => {
+    expect(UNISWAP_FEE_TIER).toBe(3000);
+  });
+
+  it('should have full range tick lower', () => {
+    expect(TICK_LOWER).toBe(-887220);
+  });
+
+  it('should have full range tick upper', () => {
+    expect(TICK_UPPER).toBe(887220);
+  });
+
+  it('should have symmetric tick range', () => {
+    expect(Math.abs(TICK_LOWER)).toBe(TICK_UPPER);
+  });
+});
+
+describe('Default Slippage', () => {
+  it('should have default slippage of 1%', () => {
+    expect(DEFAULT_SLIPPAGE_BPS).toBe(100);
+  });
+});
+
+describe('BPS Denominator', () => {
+  it('should be 10000', () => {
+    expect(BPS_DENOMINATOR).toBe(10000n);
+  });
+});
+
+describe('Chain Configurations', () => {
+  it('should have Mega ETH Testnet config', () => {
+    const config = CHAIN_CONFIGS[6343];
+    expect(config).toBeDefined();
+    expect(config.chainId).toBe(6343);
+    expect(config.name).toBe('Mega Eth Testnet');
+  });
+
+  it('should have valid factory address', () => {
+    const config = CHAIN_CONFIGS[6343];
+    expect(config.factoryAddress).toMatch(/^0x[a-fA-F0-9]{40}$/);
+  });
+
+  it('should have valid WETH address', () => {
+    const config = CHAIN_CONFIGS[6343];
+    expect(config.wethAddress).toMatch(/^0x[a-fA-F0-9]{40}$/);
+  });
+
+  it('should have valid position manager address', () => {
+    const config = CHAIN_CONFIGS[6343];
+    expect(config.nonfungiblePositionManager).toMatch(/^0x[a-fA-F0-9]{40}$/);
+  });
+
+  it('should have valid Uniswap factory address', () => {
+    const config = CHAIN_CONFIGS[6343];
+    expect(config.uniswapV3Factory).toMatch(/^0x[a-fA-F0-9]{40}$/);
+  });
+
+  it('should have block explorer URL', () => {
+    const config = CHAIN_CONFIGS[6343];
+    expect(config.blockExplorer).toMatch(/^https?:\/\//);
+  });
+});
+
+describe('getChainConfig', () => {
+  it('should return config for supported chain', () => {
+    const config = getChainConfig(6343);
+    expect(config).toBeDefined();
+    expect(config?.chainId).toBe(6343);
+  });
+
+  it('should return undefined for unsupported chain', () => {
+    const config = getChainConfig(99999);
+    expect(config).toBeUndefined();
+  });
+
+  it('should return undefined for invalid chain ID', () => {
+    const config = getChainConfig(0);
+    expect(config).toBeUndefined();
+  });
+});