@mania-labs/mania-sdk 1.0.0 → 1.0.1

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

@@ -0,0 +1,495 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { parseEther, type Address } from 'viem';
+import { ManiaSDK } from '../../mania.js';
+import {
+  createMockPublicClient,
+  createMockWalletClient,
+  createMockBondingCurveState,
+  createMockGlobalState,
+  MOCK_TX_HASH,
+} from '../helpers/mocks.js';
+import { TEST_ADDRESSES, CURVE_SCENARIOS, DEFAULT_GLOBAL_STATE } from '../helpers/fixtures.js';
+import { CHAIN_CONFIGS } from '../../constants.js';
+
+describe('ManiaSDK', () => {
+  let sdk: ManiaSDK;
+
+  beforeEach(() => {
+    sdk = new ManiaSDK({
+      factoryAddress: TEST_ADDRESSES.FACTORY,
+      rpcUrl: 'https://example.com/rpc',
+      chainId: 6343,
+    });
+  });
+
+  describe('constructor', () => {
+    it('should initialize with provided config', () => {
+      expect(sdk.factoryAddress).toBe(TEST_ADDRESSES.FACTORY);
+      expect(sdk.chainId).toBe(6343);
+    });
+
+    it('should default chainId to 1 if not provided', () => {
+      const defaultSdk = new ManiaSDK({
+        factoryAddress: TEST_ADDRESSES.FACTORY,
+        rpcUrl: 'https://example.com/rpc',
+      });
+      expect(defaultSdk.chainId).toBe(1);
+    });
+  });
+
+  describe('fromChainId', () => {
+    it('should create SDK for supported chain', () => {
+      const sdkFromChain = ManiaSDK.fromChainId(6343, 'https://example.com/rpc');
+      expect(sdkFromChain.factoryAddress).toBe(CHAIN_CONFIGS[6343].factoryAddress);
+      expect(sdkFromChain.chainId).toBe(6343);
+    });
+
+    it('should throw for unsupported chain', () => {
+      expect(() => ManiaSDK.fromChainId(99999)).toThrow('Unsupported chain ID: 99999');
+    });
+  });
+
+  describe('getWalletAddress', () => {
+    it('should return undefined when wallet not connected', () => {
+      expect(sdk.getWalletAddress()).toBeUndefined();
+    });
+
+    it('should return address when wallet is connected', () => {
+      const mockWallet = createMockWalletClient({ address: TEST_ADDRESSES.USER1 });
+      sdk.setWalletClient(mockWallet);
+      expect(sdk.getWalletAddress()).toBe(TEST_ADDRESSES.USER1);
+    });
+  });
+
+  describe('getFactoryAddress', () => {
+    it('should return factory address', () => {
+      expect(sdk.getFactoryAddress()).toBe(TEST_ADDRESSES.FACTORY);
+    });
+  });
+
+  describe('getPublicClient', () => {
+    it('should return public client', () => {
+      expect(sdk.getPublicClient()).toBeDefined();
+    });
+  });
+
+  describe('getWalletClient', () => {
+    it('should return null when not connected', () => {
+      expect(sdk.getWalletClient()).toBeNull();
+    });
+
+    it('should return wallet client when connected', () => {
+      const mockWallet = createMockWalletClient();
+      sdk.setWalletClient(mockWallet);
+      expect(sdk.getWalletClient()).toBe(mockWallet);
+    });
+  });
+
+  describe('Read Methods', () => {
+    let mockPublicClient: ReturnType<typeof createMockPublicClient>;
+
+    beforeEach(() => {
+      mockPublicClient = createMockPublicClient({
+        bondingCurve: CURVE_SCENARIOS.FRESH,
+        globalState: DEFAULT_GLOBAL_STATE,
+      });
+      sdk.setPublicClient(mockPublicClient);
+    });
+
+    describe('getGlobalState', () => {
+      it('should fetch and parse global state', async () => {
+        const state = await sdk.getGlobalState();
+
+        expect(state.initialized).toBe(true);
+        expect(state.feeBasisPoints).toBe(DEFAULT_GLOBAL_STATE.feeBasisPoints);
+        expect(state.enableMigrate).toBe(true);
+        expect(mockPublicClient.readContract).toHaveBeenCalledWith(
+          expect.objectContaining({
+            functionName: 'global',
+          })
+        );
+      });
+    });
+
+    describe('getBondingCurve', () => {
+      it('should fetch bonding curve for token', async () => {
+        const curve = await sdk.getBondingCurve(TEST_ADDRESSES.TOKEN1);
+
+        expect(curve.virtualTokenReserves).toBe(CURVE_SCENARIOS.FRESH.virtualTokenReserves);
+        expect(curve.complete).toBe(false);
+        expect(mockPublicClient.readContract).toHaveBeenCalledWith(
+          expect.objectContaining({
+            functionName: 'getBondingCurve',
+            args: [TEST_ADDRESSES.TOKEN1],
+          })
+        );
+      });
+    });
+
+    describe('getBondingCurveInstance', () => {
+      it('should return BondingCurve class instance', async () => {
+        const curve = await sdk.getBondingCurveInstance(TEST_ADDRESSES.TOKEN1);
+
+        expect(curve).toBeDefined();
+        expect(curve.getState()).toEqual(CURVE_SCENARIOS.FRESH);
+        expect(curve.getCurrentPrice()).toBeGreaterThan(0n);
+      });
+    });
+
+    describe('getTokenInfo', () => {
+      it('should return comprehensive token info', async () => {
+        const info = await sdk.getTokenInfo(TEST_ADDRESSES.TOKEN1);
+
+        expect(info.address).toBe(TEST_ADDRESSES.TOKEN1);
+        expect(info.bondingCurve).toEqual(CURVE_SCENARIOS.FRESH);
+        expect(info.currentPrice).toBeGreaterThan(0n);
+        expect(info.marketCapEth).toBeGreaterThan(0n);
+        expect(info.migrationProgress).toBe(0);
+      });
+    });
+
+    describe('getBuyQuote', () => {
+      it('should fetch buy quote from contract', async () => {
+        const quote = await sdk.getBuyQuote(TEST_ADDRESSES.TOKEN1, parseEther('0.1'));
+
+        expect(quote).toBeGreaterThan(0n);
+        expect(mockPublicClient.readContract).toHaveBeenCalledWith(
+          expect.objectContaining({
+            functionName: 'getBuyQuote',
+            args: [TEST_ADDRESSES.TOKEN1, parseEther('0.1')],
+          })
+        );
+      });
+    });
+
+    describe('getSellQuote', () => {
+      it('should fetch sell quote from contract', async () => {
+        const quote = await sdk.getSellQuote(TEST_ADDRESSES.TOKEN1, parseEther('1000000'));
+
+        expect(quote).toBeGreaterThan(0n);
+        expect(mockPublicClient.readContract).toHaveBeenCalledWith(
+          expect.objectContaining({
+            functionName: 'getSellQuote',
+            args: [TEST_ADDRESSES.TOKEN1, parseEther('1000000')],
+          })
+        );
+      });
+    });
+
+    describe('getFee', () => {
+      it('should calculate fee for amount', async () => {
+        const fee = await sdk.getFee(parseEther('1'));
+
+        expect(fee).toBe(parseEther('0.01')); // 1% of 1 ETH
+        expect(mockPublicClient.readContract).toHaveBeenCalledWith(
+          expect.objectContaining({
+            functionName: 'getFee',
+            args: [parseEther('1')],
+          })
+        );
+      });
+    });
+
+    describe('getUserVolume', () => {
+      it('should fetch user volume', async () => {
+        const volume = await sdk.getUserVolume(TEST_ADDRESSES.USER1);
+
+        expect(volume).toBe(0n);
+        expect(mockPublicClient.readContract).toHaveBeenCalledWith(
+          expect.objectContaining({
+            functionName: 'userVolume',
+            args: [TEST_ADDRESSES.USER1],
+          })
+        );
+      });
+    });
+
+    describe('isComplete', () => {
+      it('should return false for fresh curve', async () => {
+        const complete = await sdk.isComplete(TEST_ADDRESSES.TOKEN1);
+        expect(complete).toBe(false);
+      });
+
+      it('should return true for complete curve', async () => {
+        const completeMock = createMockPublicClient({
+          bondingCurve: CURVE_SCENARIOS.COMPLETE,
+        });
+        sdk.setPublicClient(completeMock);
+
+        const complete = await sdk.isComplete(TEST_ADDRESSES.TOKEN1);
+        expect(complete).toBe(true);
+      });
+    });
+
+    describe('isMigrated', () => {
+      it('should return false for active curve', async () => {
+        const migrated = await sdk.isMigrated(TEST_ADDRESSES.TOKEN1);
+        expect(migrated).toBe(false);
+      });
+
+      it('should return true for migrated curve', async () => {
+        const migratedMock = createMockPublicClient({
+          bondingCurve: CURVE_SCENARIOS.MIGRATED,
+        });
+        sdk.setPublicClient(migratedMock);
+
+        const migrated = await sdk.isMigrated(TEST_ADDRESSES.TOKEN1);
+        expect(migrated).toBe(true);
+      });
+    });
+  });
+
+  describe('Write Methods', () => {
+    let mockPublicClient: ReturnType<typeof createMockPublicClient>;
+    let mockWalletClient: ReturnType<typeof createMockWalletClient>;
+
+    beforeEach(() => {
+      mockPublicClient = createMockPublicClient({
+        bondingCurve: CURVE_SCENARIOS.FRESH,
+        globalState: DEFAULT_GLOBAL_STATE,
+      });
+      mockWalletClient = createMockWalletClient({ address: TEST_ADDRESSES.USER1 });
+      sdk.setPublicClient(mockPublicClient);
+      sdk.setWalletClient(mockWalletClient);
+    });
+
+    describe('create', () => {
+      it('should throw without wallet connected', async () => {
+        const noWalletSdk = new ManiaSDK({
+          factoryAddress: TEST_ADDRESSES.FACTORY,
+          rpcUrl: 'https://example.com/rpc',
+        });
+        noWalletSdk.setPublicClient(mockPublicClient);
+
+        await expect(
+          noWalletSdk.create({
+            name: 'Test',
+            symbol: 'TEST',
+            uri: 'https://example.com',
+            creator: TEST_ADDRESSES.USER1,
+          })
+        ).rejects.toThrow('Wallet not connected');
+      });
+
+      it('should call writeContract with correct params', async () => {
+        const result = await sdk.create({
+          name: 'Test Token',
+          symbol: 'TEST',
+          uri: 'https://example.com/token.json',
+          creator: TEST_ADDRESSES.USER1,
+        });
+
+        expect(result.hash).toBe(MOCK_TX_HASH);
+        expect(result.success).toBe(true);
+        expect(mockWalletClient.writeContract).toHaveBeenCalledWith(
+          expect.objectContaining({
+            functionName: 'create',
+            args: ['Test Token', 'TEST', 'https://example.com/token.json', TEST_ADDRESSES.USER1],
+          })
+        );
+      });
+    });
+
+    describe('createAndBuy', () => {
+      it('should include ETH value in transaction', async () => {
+        const result = await sdk.createAndBuy({
+          name: 'Test Token',
+          symbol: 'TEST',
+          uri: 'https://example.com/token.json',
+          creator: TEST_ADDRESSES.USER1,
+          buyAmountEth: parseEther('0.1'),
+          minTokensOut: 0n,
+        });
+
+        expect(result.hash).toBe(MOCK_TX_HASH);
+        expect(mockWalletClient.writeContract).toHaveBeenCalledWith(
+          expect.objectContaining({
+            functionName: 'createAndBuy',
+            value: parseEther('0.1'),
+          })
+        );
+      });
+    });
+
+    describe('buy', () => {
+      it('should call writeContract with correct params', async () => {
+        const result = await sdk.buy({
+          token: TEST_ADDRESSES.TOKEN1,
+          amountEth: parseEther('0.1'),
+          minTokensOut: parseEther('1000'),
+        });
+
+        expect(result.hash).toBe(MOCK_TX_HASH);
+        expect(result.success).toBe(true);
+        expect(mockWalletClient.writeContract).toHaveBeenCalledWith(
+          expect.objectContaining({
+            functionName: 'buy',
+            args: [TEST_ADDRESSES.TOKEN1, parseEther('1000'), TEST_ADDRESSES.USER1],
+            value: parseEther('0.1'),
+          })
+        );
+      });
+
+      it('should use provided recipient', async () => {
+        await sdk.buy({
+          token: TEST_ADDRESSES.TOKEN1,
+          amountEth: parseEther('0.1'),
+          minTokensOut: parseEther('1000'),
+          recipient: TEST_ADDRESSES.USER2,
+        });
+
+        expect(mockWalletClient.writeContract).toHaveBeenCalledWith(
+          expect.objectContaining({
+            args: [TEST_ADDRESSES.TOKEN1, parseEther('1000'), TEST_ADDRESSES.USER2],
+          })
+        );
+      });
+    });
+
+    describe('buyWithSlippage', () => {
+      it('should calculate minTokensOut automatically', async () => {
+        const result = await sdk.buyWithSlippage(
+          TEST_ADDRESSES.TOKEN1,
+          parseEther('0.1'),
+          100 // 1% slippage
+        );
+
+        expect(result.hash).toBe(MOCK_TX_HASH);
+        // The mock will have calculated slippage
+        expect(mockWalletClient.writeContract).toHaveBeenCalledWith(
+          expect.objectContaining({
+            functionName: 'buy',
+          })
+        );
+      });
+    });
+
+    describe('sell', () => {
+      it('should call writeContract with correct params', async () => {
+        const result = await sdk.sell({
+          token: TEST_ADDRESSES.TOKEN1,
+          amountTokens: parseEther('1000000'),
+          minEthOut: parseEther('0.01'),
+        });
+
+        expect(result.hash).toBe(MOCK_TX_HASH);
+        expect(result.success).toBe(true);
+        expect(mockWalletClient.writeContract).toHaveBeenCalledWith(
+          expect.objectContaining({
+            functionName: 'sell',
+            args: [TEST_ADDRESSES.TOKEN1, parseEther('1000000'), parseEther('0.01')],
+          })
+        );
+      });
+    });
+
+    describe('sellWithSlippage', () => {
+      it('should calculate minEthOut automatically', async () => {
+        const result = await sdk.sellWithSlippage(
+          TEST_ADDRESSES.TOKEN1,
+          parseEther('1000000'),
+          100 // 1% slippage
+        );
+
+        expect(result.hash).toBe(MOCK_TX_HASH);
+        expect(mockWalletClient.writeContract).toHaveBeenCalledWith(
+          expect.objectContaining({
+            functionName: 'sell',
+          })
+        );
+      });
+    });
+
+    describe('migrate', () => {
+      it('should include pool migration fee', async () => {
+        const result = await sdk.migrate({
+          token: TEST_ADDRESSES.TOKEN1,
+        });
+
+        expect(result.hash).toBe(MOCK_TX_HASH);
+        expect(mockWalletClient.writeContract).toHaveBeenCalledWith(
+          expect.objectContaining({
+            functionName: 'migrate',
+            args: [TEST_ADDRESSES.TOKEN1],
+            value: DEFAULT_GLOBAL_STATE.poolMigrationFee,
+          })
+        );
+      });
+    });
+  });
+
+  describe('Event Watching', () => {
+    let mockPublicClient: ReturnType<typeof createMockPublicClient>;
+
+    beforeEach(() => {
+      mockPublicClient = createMockPublicClient();
+      sdk.setPublicClient(mockPublicClient);
+    });
+
+    describe('watchCreateEvents', () => {
+      it('should set up event watcher', () => {
+        const callback = vi.fn();
+        const unwatch = sdk.watchCreateEvents(callback);
+
+        expect(mockPublicClient.watchContractEvent).toHaveBeenCalledWith(
+          expect.objectContaining({
+            eventName: 'CreateEvent',
+          })
+        );
+        expect(typeof unwatch).toBe('function');
+      });
+    });
+
+    describe('watchTradeEvents', () => {
+      it('should watch all tokens when no filter provided', () => {
+        const callback = vi.fn();
+        sdk.watchTradeEvents(undefined, callback);
+
+        expect(mockPublicClient.watchContractEvent).toHaveBeenCalledWith(
+          expect.objectContaining({
+            eventName: 'TradeEvent',
+            args: undefined,
+          })
+        );
+      });
+
+      it('should filter by token when provided', () => {
+        const callback = vi.fn();
+        sdk.watchTradeEvents(TEST_ADDRESSES.TOKEN1, callback);
+
+        expect(mockPublicClient.watchContractEvent).toHaveBeenCalledWith(
+          expect.objectContaining({
+            eventName: 'TradeEvent',
+            args: { mint: TEST_ADDRESSES.TOKEN1 },
+          })
+        );
+      });
+    });
+
+    describe('watchCompleteEvents', () => {
+      it('should set up event watcher', () => {
+        const callback = vi.fn();
+        sdk.watchCompleteEvents(callback);
+
+        expect(mockPublicClient.watchContractEvent).toHaveBeenCalledWith(
+          expect.objectContaining({
+            eventName: 'CompleteEvent',
+          })
+        );
+      });
+    });
+
+    describe('watchMigrationEvents', () => {
+      it('should set up event watcher', () => {
+        const callback = vi.fn();
+        sdk.watchMigrationEvents(callback);
+
+        expect(mockPublicClient.watchContractEvent).toHaveBeenCalledWith(
+          expect.objectContaining({
+            eventName: 'CompleteManiaAmmMigrationEvent',
+          })
+        );
+      });
+    });
+  });
+});