@mania-labs/mania-sdk 1.0.0 → 1.0.2

package/src/__tests__/helpers/mocks.ts

@@ -0,0 +1,184 @@
+import { vi } from 'vitest';
+import type { Address, PublicClient, WalletClient, Hash } from 'viem';
+import type { BondingCurveState, GlobalState } from '../../types.js';
+import {
+  CURVE_SCENARIOS,
+  DEFAULT_GLOBAL_STATE,
+  TEST_ADDRESSES,
+} from './fixtures.js';
+
+/**
+ * Create a mock bonding curve state with optional overrides
+ */
+export function createMockBondingCurveState(
+  overrides: Partial<BondingCurveState> = {}
+): BondingCurveState {
+  return {
+    ...CURVE_SCENARIOS.FRESH,
+    ...overrides,
+  };
+}
+
+/**
+ * Create a mock global state with optional overrides
+ */
+export function createMockGlobalState(
+  overrides: Partial<GlobalState> = {}
+): GlobalState {
+  return {
+    ...DEFAULT_GLOBAL_STATE,
+    ...overrides,
+  };
+}
+
+/**
+ * Mock transaction hash
+ */
+export const MOCK_TX_HASH =
+  '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef' as Hash;
+
+/**
+ * Create a mock public client with configurable responses
+ */
+export function createMockPublicClient(config: {
+  bondingCurve?: BondingCurveState;
+  globalState?: GlobalState;
+  buyQuote?: bigint;
+  sellQuote?: bigint;
+  fee?: bigint;
+  userVolume?: bigint;
+} = {}): PublicClient {
+  const mockClient = {
+    readContract: vi.fn().mockImplementation(({ functionName, args }) => {
+      switch (functionName) {
+        case 'global':
+          return Promise.resolve([
+            config.globalState?.initialized ?? DEFAULT_GLOBAL_STATE.initialized,
+            config.globalState?.authority ?? DEFAULT_GLOBAL_STATE.authority,
+            config.globalState?.feeRecipient ?? DEFAULT_GLOBAL_STATE.feeRecipient,
+            config.globalState?.initialVirtualTokenReserves ??
+              DEFAULT_GLOBAL_STATE.initialVirtualTokenReserves,
+            config.globalState?.initialVirtualEthReserves ??
+              DEFAULT_GLOBAL_STATE.initialVirtualEthReserves,
+            config.globalState?.initialRealTokenReserves ??
+              DEFAULT_GLOBAL_STATE.initialRealTokenReserves,
+            config.globalState?.tokenTotalSupply ??
+              DEFAULT_GLOBAL_STATE.tokenTotalSupply,
+            config.globalState?.feeBasisPoints ??
+              DEFAULT_GLOBAL_STATE.feeBasisPoints,
+            config.globalState?.withdrawAuthority ??
+              DEFAULT_GLOBAL_STATE.withdrawAuthority,
+            config.globalState?.enableMigrate ??
+              DEFAULT_GLOBAL_STATE.enableMigrate,
+            config.globalState?.poolMigrationFee ??
+              DEFAULT_GLOBAL_STATE.poolMigrationFee,
+          ]);
+
+        case 'getBondingCurve': {
+          const curve = config.bondingCurve ?? CURVE_SCENARIOS.FRESH;
+          return Promise.resolve({
+            virtualTokenReserves: curve.virtualTokenReserves,
+            virtualEthReserves: curve.virtualEthReserves,
+            realTokenReserves: curve.realTokenReserves,
+            realEthReserves: curve.realEthReserves,
+            tokenTotalSupply: curve.tokenTotalSupply,
+            complete: curve.complete,
+            trackVolume: curve.trackVolume,
+          });
+        }
+
+        case 'getBuyQuote':
+          return Promise.resolve(config.buyQuote ?? 1000000000000000000000n);
+
+        case 'getSellQuote':
+          return Promise.resolve(config.sellQuote ?? 10000000000000000n);
+
+        case 'getFee':
+          return Promise.resolve(config.fee ?? (args[0] as bigint) / 100n);
+
+        case 'userVolume':
+          return Promise.resolve(config.userVolume ?? 0n);
+
+        default:
+          return Promise.resolve(undefined);
+      }
+    }),
+
+    watchContractEvent: vi.fn().mockReturnValue(() => {}),
+
+    waitForTransactionReceipt: vi.fn().mockResolvedValue({
+      status: 'success',
+      logs: [],
+    }),
+
+    getBalance: vi.fn().mockResolvedValue(10000000000000000000n), // 10 ETH
+  } as unknown as PublicClient;
+
+  return mockClient;
+}
+
+/**
+ * Create a mock wallet client
+ */
+export function createMockWalletClient(config: {
+  address?: Address;
+  txHash?: Hash;
+} = {}): WalletClient {
+  const address = config.address ?? TEST_ADDRESSES.USER1;
+  const txHash = config.txHash ?? MOCK_TX_HASH;
+
+  const mockClient = {
+    account: {
+      address,
+    },
+    writeContract: vi.fn().mockResolvedValue(txHash),
+  } as unknown as WalletClient;
+
+  return mockClient;
+}
+
+/**
+ * Create mock event logs for CreateEvent
+ */
+export function createMockCreateEventLogs(tokenAddress: Address) {
+  return [
+    {
+      args: {
+        name: 'Test Token',
+        symbol: 'TEST',
+        uri: 'https://example.com/metadata.json',
+        mint: tokenAddress,
+        user: TEST_ADDRESSES.USER1,
+        creator: TEST_ADDRESSES.USER1,
+        timestamp: BigInt(Date.now()),
+      },
+    },
+  ];
+}
+
+/**
+ * Create mock event logs for TradeEvent
+ */
+export function createMockTradeEventLogs(config: {
+  token: Address;
+  ethAmount: bigint;
+  tokenAmount: bigint;
+  isBuy: boolean;
+}) {
+  return [
+    {
+      args: {
+        mint: config.token,
+        ethAmount: config.ethAmount,
+        tokenAmount: config.tokenAmount,
+        isBuy: config.isBuy,
+        user: TEST_ADDRESSES.USER1,
+        timestamp: BigInt(Date.now()),
+        virtualEthReserves: 1000000000000000000n,
+        virtualTokenReserves: 1000000000000000000000000000n,
+        realEthReserves: 100000000000000000n,
+        realTokenReserves: 700000000000000000000000000n,
+      },
+    },
+  ];
+}

package/src/__tests__/integration/sdk-read.test.ts

@@ -0,0 +1,196 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { parseEther, type Address } from 'viem';
+import { ManiaSDK } from '../../mania.js';
+import { createTestSDK, withTestRetry } from '../helpers/integrationHelpers.js';
+import { RUN_INTEGRATION_TESTS } from '../setup.js';
+
+describe.skipIf(!RUN_INTEGRATION_TESTS)('SDK Read Methods - Integration', () => {
+  let sdk: ManiaSDK;
+  let walletAddress: Address;
+  let testTokenAddress: Address | undefined;
+
+  beforeAll(async () => {
+    const testSetup = createTestSDK();
+    sdk = testSetup.sdk;
+    walletAddress = testSetup.walletAddress;
+
+    // Use existing test token if provided in environment
+    testTokenAddress = process.env.TEST_TOKEN_ADDRESS as Address | undefined;
+
+    console.log(`Running integration tests with wallet: ${walletAddress}`);
+    if (testTokenAddress) {
+      console.log(`Using test token: ${testTokenAddress}`);
+    }
+  });
+
+  describe('getGlobalState', () => {
+    it('should return valid global state', async () => {
+      const state = await withTestRetry(() => sdk.getGlobalState());
+
+      expect(state.initialized).toBe(true);
+      expect(state.authority).toMatch(/^0x[a-fA-F0-9]{40}$/);
+      expect(state.feeRecipient).toMatch(/^0x[a-fA-F0-9]{40}$/);
+      expect(state.feeBasisPoints).toBeGreaterThan(0n);
+      expect(state.feeBasisPoints).toBeLessThanOrEqual(1000n); // Max 10%
+    });
+
+    it('should have valid reserve configurations', async () => {
+      const state = await withTestRetry(() => sdk.getGlobalState());
+
+      expect(state.initialVirtualTokenReserves).toBeGreaterThan(0n);
+      expect(state.initialVirtualEthReserves).toBeGreaterThan(0n);
+      expect(state.initialRealTokenReserves).toBeGreaterThan(0n);
+      expect(state.tokenTotalSupply).toBeGreaterThan(0n);
+    });
+
+    it('should have migration enabled', async () => {
+      const state = await withTestRetry(() => sdk.getGlobalState());
+
+      expect(state.enableMigrate).toBe(true);
+      expect(state.poolMigrationFee).toBeGreaterThanOrEqual(0n);
+    });
+  });
+
+  describe('getFee', () => {
+    it('should calculate fee correctly', async () => {
+      const amount = parseEther('1');
+      const fee = await withTestRetry(() => sdk.getFee(amount));
+
+      expect(fee).toBeGreaterThan(0n);
+      expect(fee).toBeLessThan(amount);
+    });
+
+    it('should scale proportionally with amount', async () => {
+      const smallAmount = parseEther('0.1');
+      const largeAmount = parseEther('1');
+
+      const [smallFee, largeFee] = await Promise.all([
+        withTestRetry(() => sdk.getFee(smallAmount)),
+        withTestRetry(() => sdk.getFee(largeAmount)),
+      ]);
+
+      // Large fee should be approximately 10x small fee
+      const ratio = Number(largeFee) / Number(smallFee);
+      expect(ratio).toBeCloseTo(10, 1);
+    });
+  });
+
+  describe('getUserVolume', () => {
+    it('should return bigint >= 0', async () => {
+      const volume = await withTestRetry(() => sdk.getUserVolume(walletAddress));
+      expect(volume).toBeGreaterThanOrEqual(0n);
+    });
+  });
+
+  describe.skipIf(!testTokenAddress)('Token-specific read methods', () => {
+    it('should get bonding curve state', async () => {
+      const curve = await withTestRetry(() => sdk.getBondingCurve(testTokenAddress!));
+
+      expect(curve.virtualTokenReserves).toBeGreaterThanOrEqual(0n);
+      expect(curve.virtualEthReserves).toBeGreaterThanOrEqual(0n);
+      expect(curve.realTokenReserves).toBeGreaterThanOrEqual(0n);
+      expect(curve.realEthReserves).toBeGreaterThanOrEqual(0n);
+      expect(curve.tokenTotalSupply).toBeGreaterThan(0n);
+      expect(typeof curve.complete).toBe('boolean');
+      expect(typeof curve.trackVolume).toBe('boolean');
+    });
+
+    it('should get bonding curve instance', async () => {
+      const curve = await withTestRetry(() => sdk.getBondingCurveInstance(testTokenAddress!));
+
+      expect(curve).toBeDefined();
+      expect(curve.getCurrentPrice()).toBeGreaterThanOrEqual(0n);
+      expect(curve.getMigrationProgress()).toBeGreaterThanOrEqual(0);
+      expect(curve.getMigrationProgress()).toBeLessThanOrEqual(100);
+    });
+
+    it('should get comprehensive token info', async () => {
+      const info = await withTestRetry(() => sdk.getTokenInfo(testTokenAddress!));
+
+      expect(info.address).toBe(testTokenAddress);
+      expect(info.bondingCurve).toBeDefined();
+      expect(info.currentPrice).toBeGreaterThanOrEqual(0n);
+      expect(info.marketCapEth).toBeGreaterThanOrEqual(0n);
+      expect(info.migrationProgress).toBeGreaterThanOrEqual(0);
+      expect(info.migrationProgress).toBeLessThanOrEqual(100);
+    });
+
+    it('should get buy quote', async () => {
+      const ethAmount = parseEther('0.01');
+      const quote = await withTestRetry(() => sdk.getBuyQuote(testTokenAddress!, ethAmount));
+
+      // Quote should be > 0 unless curve is migrated
+      const isMigrated = await sdk.isMigrated(testTokenAddress!);
+      if (!isMigrated) {
+        expect(quote).toBeGreaterThan(0n);
+      }
+    });
+
+    it('should get sell quote', async () => {
+      const tokenAmount = parseEther('1000');
+      const quote = await withTestRetry(() => sdk.getSellQuote(testTokenAddress!, tokenAmount));
+
+      // Quote should be >= 0
+      expect(quote).toBeGreaterThanOrEqual(0n);
+    });
+
+    it('should return valid complete status', async () => {
+      const complete = await withTestRetry(() => sdk.isComplete(testTokenAddress!));
+      expect(typeof complete).toBe('boolean');
+    });
+
+    it('should return valid migrated status', async () => {
+      const migrated = await withTestRetry(() => sdk.isMigrated(testTokenAddress!));
+      expect(typeof migrated).toBe('boolean');
+    });
+
+    it('migrated should imply complete', async () => {
+      const [complete, migrated] = await Promise.all([
+        withTestRetry(() => sdk.isComplete(testTokenAddress!)),
+        withTestRetry(() => sdk.isMigrated(testTokenAddress!)),
+      ]);
+
+      if (migrated) {
+        expect(complete).toBe(true);
+      }
+    });
+  });
+
+  describe('Quote consistency', () => {
+    it.skipIf(!testTokenAddress)('should return more tokens for larger ETH amounts', async () => {
+      const isMigrated = await sdk.isMigrated(testTokenAddress!);
+      if (isMigrated) return;
+
+      const [smallQuote, largeQuote] = await Promise.all([
+        withTestRetry(() => sdk.getBuyQuote(testTokenAddress!, parseEther('0.01'))),
+        withTestRetry(() => sdk.getBuyQuote(testTokenAddress!, parseEther('0.1'))),
+      ]);
+
+      expect(largeQuote).toBeGreaterThan(smallQuote);
+    });
+  });
+
+  describe('Factory address', () => {
+    it('should return correct factory address', () => {
+      const factoryAddress = sdk.getFactoryAddress();
+      expect(factoryAddress).toMatch(/^0x[a-fA-F0-9]{40}$/);
+    });
+  });
+
+  describe('Client accessors', () => {
+    it('should return public client', () => {
+      const publicClient = sdk.getPublicClient();
+      expect(publicClient).toBeDefined();
+    });
+
+    it('should return wallet client when connected', () => {
+      const walletClient = sdk.getWalletClient();
+      expect(walletClient).toBeDefined();
+    });
+
+    it('should return wallet address', () => {
+      const address = sdk.getWalletAddress();
+      expect(address).toBe(walletAddress);
+    });
+  });
+});