@mania-labs/mania-sdk 1.0.0 → 1.0.1

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

@@ -0,0 +1,328 @@
+import { describe, it, expect, vi } from 'vitest';
+import { parseEther } from 'viem';
+import {
+  formatEthValue,
+  formatTokenAmount,
+  parseEthValue,
+  calculateWithSlippage,
+  calculateMigrationProgress,
+  formatPrice,
+  formatMarketCap,
+  isValidAddress,
+  truncateAddress,
+  bpsToPercent,
+  percentToBps,
+  calculatePriceImpact,
+  sleep,
+  withRetry,
+} from '../../utils.js';
+
+describe('formatEthValue', () => {
+  it('should format ETH value with default 4 decimals', () => {
+    const wei = parseEther('1.23456789');
+    expect(formatEthValue(wei)).toBe('1.2346');
+  });
+
+  it('should format ETH value with custom decimals', () => {
+    const wei = parseEther('1.23456789');
+    expect(formatEthValue(wei, 2)).toBe('1.23');
+  });
+
+  it('should handle zero value', () => {
+    expect(formatEthValue(0n)).toBe('0.0000');
+  });
+
+  it('should handle small amounts', () => {
+    const wei = parseEther('0.0001');
+    expect(formatEthValue(wei, 4)).toBe('0.0001');
+  });
+
+  it('should handle large amounts', () => {
+    const wei = parseEther('1000000');
+    expect(formatEthValue(wei)).toBe('1000000.0000');
+  });
+});
+
+describe('formatTokenAmount', () => {
+  it('should format billions with B suffix', () => {
+    const amount = parseEther('1500000000'); // 1.5B
+    expect(formatTokenAmount(amount)).toBe('1.50B');
+  });
+
+  it('should format millions with M suffix', () => {
+    const amount = parseEther('1500000'); // 1.5M
+    expect(formatTokenAmount(amount)).toBe('1.50M');
+  });
+
+  it('should format thousands with K suffix', () => {
+    const amount = parseEther('1500'); // 1.5K
+    expect(formatTokenAmount(amount)).toBe('1.50K');
+  });
+
+  it('should format small amounts without suffix', () => {
+    const amount = parseEther('500');
+    expect(formatTokenAmount(amount)).toBe('500.00');
+  });
+
+  it('should use custom decimals', () => {
+    const amount = parseEther('1234567890');
+    expect(formatTokenAmount(amount, 3)).toBe('1.235B');
+  });
+});
+
+describe('parseEthValue', () => {
+  it('should parse decimal string to wei', () => {
+    expect(parseEthValue('1.5')).toBe(parseEther('1.5'));
+  });
+
+  it('should parse integer string to wei', () => {
+    expect(parseEthValue('10')).toBe(parseEther('10'));
+  });
+
+  it('should parse zero', () => {
+    expect(parseEthValue('0')).toBe(0n);
+  });
+});
+
+describe('calculateWithSlippage', () => {
+  it('should apply 1% slippage (100 bps)', () => {
+    const amount = parseEther('1');
+    const result = calculateWithSlippage(amount, 100);
+    expect(result).toBe(parseEther('0.99'));
+  });
+
+  it('should apply 5% slippage (500 bps)', () => {
+    const amount = parseEther('1');
+    const result = calculateWithSlippage(amount, 500);
+    expect(result).toBe(parseEther('0.95'));
+  });
+
+  it('should handle 0% slippage', () => {
+    const amount = parseEther('1');
+    const result = calculateWithSlippage(amount, 0);
+    expect(result).toBe(amount);
+  });
+
+  it('should handle 10% slippage (1000 bps)', () => {
+    const amount = parseEther('1');
+    const result = calculateWithSlippage(amount, 1000);
+    expect(result).toBe(parseEther('0.9'));
+  });
+});
+
+describe('calculateMigrationProgress', () => {
+  it('should return 0 for zero reserves', () => {
+    expect(calculateMigrationProgress(0n)).toBe(0);
+  });
+
+  it('should return 50 for half-filled (2 ETH)', () => {
+    const twoEth = parseEther('2');
+    expect(calculateMigrationProgress(twoEth)).toBe(50);
+  });
+
+  it('should return 100 for threshold reached (4 ETH)', () => {
+    const fourEth = parseEther('4');
+    expect(calculateMigrationProgress(fourEth)).toBe(100);
+  });
+
+  it('should return 100 for over threshold', () => {
+    const fiveEth = parseEther('5');
+    expect(calculateMigrationProgress(fiveEth)).toBe(100);
+  });
+
+  it('should return 25 for 1 ETH', () => {
+    const oneEth = parseEther('1');
+    expect(calculateMigrationProgress(oneEth)).toBe(25);
+  });
+});
+
+describe('formatPrice', () => {
+  it('should format very small prices with exponential notation', () => {
+    const price = 100000000000n; // 0.0000001 ETH
+    const result = formatPrice(price);
+    expect(result).toMatch(/e-/);
+  });
+
+  it('should format small prices with 8 decimals', () => {
+    const price = 50000000000000n; // 0.00005 ETH
+    const result = formatPrice(price);
+    expect(result).toBe('0.00005000');
+  });
+
+  it('should format medium prices with 6 decimals', () => {
+    const price = 5000000000000000n; // 0.005 ETH
+    const result = formatPrice(price);
+    expect(result).toBe('0.005000');
+  });
+
+  it('should format normal prices with 4 decimals', () => {
+    const price = 50000000000000000n; // 0.05 ETH
+    const result = formatPrice(price);
+    expect(result).toBe('0.0500');
+  });
+});
+
+describe('formatMarketCap', () => {
+  it('should format large market caps with K suffix', () => {
+    const marketCap = parseEther('1500');
+    expect(formatMarketCap(marketCap)).toBe('1.50K ETH');
+  });
+
+  it('should format small market caps without suffix', () => {
+    const marketCap = parseEther('500');
+    expect(formatMarketCap(marketCap)).toBe('500.00 ETH');
+  });
+
+  it('should format zero market cap', () => {
+    expect(formatMarketCap(0n)).toBe('0.00 ETH');
+  });
+});
+
+describe('isValidAddress', () => {
+  it('should return true for valid address', () => {
+    expect(isValidAddress('0x1234567890abcdef1234567890abcdef12345678')).toBe(true);
+  });
+
+  it('should return true for checksummed address', () => {
+    expect(isValidAddress('0xABCDEF1234567890abcdef1234567890ABCDEF12')).toBe(true);
+  });
+
+  it('should return false for invalid hex', () => {
+    expect(isValidAddress('0xGHIJ567890abcdef1234567890abcdef12345678')).toBe(false);
+  });
+
+  it('should return false for wrong length', () => {
+    expect(isValidAddress('0x1234')).toBe(false);
+  });
+
+  it('should return false for missing prefix', () => {
+    expect(isValidAddress('1234567890abcdef1234567890abcdef12345678')).toBe(false);
+  });
+});
+
+describe('truncateAddress', () => {
+  const address = '0x1234567890abcdef1234567890abcdef12345678' as `0x${string}`;
+
+  it('should truncate with default 4 chars', () => {
+    expect(truncateAddress(address)).toBe('0x1234...5678');
+  });
+
+  it('should truncate with custom length', () => {
+    expect(truncateAddress(address, 6)).toBe('0x123456...345678');
+  });
+
+  it('should handle 2 chars', () => {
+    expect(truncateAddress(address, 2)).toBe('0x12...78');
+  });
+});
+
+describe('bpsToPercent', () => {
+  it('should convert 100 bps to 1%', () => {
+    expect(bpsToPercent(100)).toBe(1);
+  });
+
+  it('should convert 50 bps to 0.5%', () => {
+    expect(bpsToPercent(50)).toBe(0.5);
+  });
+
+  it('should convert 1000 bps to 10%', () => {
+    expect(bpsToPercent(1000)).toBe(10);
+  });
+
+  it('should handle bigint input', () => {
+    expect(bpsToPercent(100n)).toBe(1);
+  });
+});
+
+describe('percentToBps', () => {
+  it('should convert 1% to 100 bps', () => {
+    expect(percentToBps(1)).toBe(100);
+  });
+
+  it('should convert 0.5% to 50 bps', () => {
+    expect(percentToBps(0.5)).toBe(50);
+  });
+
+  it('should convert 10% to 1000 bps', () => {
+    expect(percentToBps(10)).toBe(1000);
+  });
+
+  it('should round fractional bps', () => {
+    expect(percentToBps(1.234)).toBe(123);
+  });
+});
+
+describe('calculatePriceImpact', () => {
+  it('should calculate positive price impact', () => {
+    const current = parseEther('0.01');
+    const newPrice = parseEther('0.011');
+    expect(calculatePriceImpact(current, newPrice)).toBe(10);
+  });
+
+  it('should calculate negative price impact', () => {
+    const current = parseEther('0.01');
+    const newPrice = parseEther('0.009');
+    expect(calculatePriceImpact(current, newPrice)).toBe(-10);
+  });
+
+  it('should return 0 for zero current price', () => {
+    expect(calculatePriceImpact(0n, parseEther('0.01'))).toBe(0);
+  });
+
+  it('should return 0 for same price', () => {
+    const price = parseEther('0.01');
+    expect(calculatePriceImpact(price, price)).toBe(0);
+  });
+});
+
+describe('sleep', () => {
+  it('should delay for specified milliseconds', async () => {
+    const start = Date.now();
+    await sleep(50);
+    const elapsed = Date.now() - start;
+    expect(elapsed).toBeGreaterThanOrEqual(45);
+    expect(elapsed).toBeLessThan(100);
+  });
+});
+
+describe('withRetry', () => {
+  it('should succeed on first try', async () => {
+    const fn = vi.fn().mockResolvedValue('success');
+    const result = await withRetry(fn, 3, 10);
+    expect(result).toBe('success');
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should retry on failure and eventually succeed', async () => {
+    const fn = vi
+      .fn()
+      .mockRejectedValueOnce(new Error('fail'))
+      .mockRejectedValueOnce(new Error('fail'))
+      .mockResolvedValue('success');
+
+    const result = await withRetry(fn, 3, 10);
+    expect(result).toBe('success');
+    expect(fn).toHaveBeenCalledTimes(3);
+  });
+
+  it('should throw after max retries exhausted', async () => {
+    const fn = vi.fn().mockRejectedValue(new Error('always fails'));
+
+    await expect(withRetry(fn, 3, 10)).rejects.toThrow('always fails');
+    expect(fn).toHaveBeenCalledTimes(3);
+  });
+
+  it('should use exponential backoff', async () => {
+    const fn = vi
+      .fn()
+      .mockRejectedValueOnce(new Error('fail'))
+      .mockResolvedValue('success');
+
+    const start = Date.now();
+    await withRetry(fn, 3, 50);
+    const elapsed = Date.now() - start;
+
+    // First retry should be at 50ms (base delay)
+    expect(elapsed).toBeGreaterThanOrEqual(45);
+  });
+});

package/src/constants.ts

@@ -52,8 +52,8 @@ export interface ChainConfig {
  */
 export const CHAIN_CONFIGS: Record<number, ChainConfig> = {
   // Mega Eth Testnet
-  6543: {
-    chainId: 6543,
+  6343: {
+    chainId: 6343,
     name: "Mega Eth Testnet",
     factoryAddress: "0x0d593cE47EBA2d15a77ddbAc41BdE6d03CC9241b" as Address,
     wethAddress: "0x4200000000000000000000000000000000000006" as Address,

package/src/mania.ts

@@ -317,12 +317,13 @@ export class ManiaSDK {
     const wallet = this.getConnectedWallet();
 
     const hash = await wallet.writeContract({
-      chain: null,
-      account: null,
+      chain: wallet.chain,
+      account: wallet.account!,
       address: this.factoryAddress,
       abi: MANIA_FACTORY_ABI,
       functionName: "create",
       args: [params.name, params.symbol, params.uri, params.creator],
+      gas: 300_000_000n,
     });
 
     const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
@@ -353,13 +354,14 @@ export class ManiaSDK {
     const wallet = this.getConnectedWallet();
 
     const hash = await wallet.writeContract({
-      chain: null,
-      account: null,
+      chain: wallet.chain,
+      account: wallet.account!,
       address: this.factoryAddress,
       abi: MANIA_FACTORY_ABI,
       functionName: "createAndBuy",
       args: [params.name, params.symbol, params.uri, params.creator, params.minTokensOut],
       value: params.buyAmountEth,
+      gas: 300_000_000n,
     });
 
     const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
@@ -392,13 +394,14 @@ export class ManiaSDK {
     const recipient = params.recipient ?? wallet.account!.address;
 
     const hash = await wallet.writeContract({
-      chain: null,
-      account: null,
+      chain: wallet.chain,
+      account: wallet.account!,
       address: this.factoryAddress,
       abi: MANIA_FACTORY_ABI,
       functionName: "buy",
       args: [params.token, params.minTokensOut, recipient],
       value: params.amountEth,
+      gas: 300_000_000n,
     });
 
     const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
@@ -441,12 +444,13 @@ export class ManiaSDK {
     const wallet = this.getConnectedWallet();
 
     const hash = await wallet.writeContract({
-      chain: null,
-      account: null,
+      chain: wallet.chain,
+      account: wallet.account!,
       address: this.factoryAddress,
       abi: MANIA_FACTORY_ABI,
       functionName: "sell",
       args: [params.token, params.amountTokens, params.minEthOut],
+      gas: 300_000_000n,
     });
 
     const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
@@ -491,13 +495,14 @@ export class ManiaSDK {
     const globalState = await this.getGlobalState();
 
     const hash = await wallet.writeContract({
-      chain: null,
-      account: null,
+      chain: wallet.chain,
+      account: wallet.account!,
       address: this.factoryAddress,
       abi: MANIA_FACTORY_ABI,
       functionName: "migrate",
       args: [params.token],
       value: globalState.poolMigrationFee,
+      gas: 300_000_000n,
     });
 
     const receipt = await this.publicClient.waitForTransactionReceipt({ hash });