@mania-labs/mania-sdk 1.0.0 → 1.0.2

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

@@ -0,0 +1,383 @@
+import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
+import { parseEther, formatEther, type Address } from 'viem';
+import { ManiaSDK } from '../../mania.js';
+import {
+  createTestSDK,
+  getBalanceSnapshot,
+  compareBalances,
+  getTokenBalance,
+  hasEnoughETH,
+  generateUniqueTokenParams,
+  withTestRetry,
+  type BalanceSnapshot,
+} from '../helpers/integrationHelpers.js';
+import { RUN_INTEGRATION_TESTS } from '../setup.js';
+
+describe.skipIf(!RUN_INTEGRATION_TESTS)('SDK Write Methods - Integration', () => {
+  let sdk: ManiaSDK;
+  let walletAddress: Address;
+  let publicClient: ReturnType<typeof createTestSDK>['publicClient'];
+
+  // Token created during tests
+  let createdTokenAddress: Address | undefined;
+
+  // Minimum ETH required for tests
+  const MIN_ETH_REQUIRED = parseEther('0.5');
+
+  beforeAll(async () => {
+    const testSetup = createTestSDK();
+    sdk = testSetup.sdk;
+    walletAddress = testSetup.walletAddress;
+    publicClient = testSetup.publicClient;
+
+    console.log(`Running write integration tests with wallet: ${walletAddress}`);
+
+    // Check wallet has enough ETH
+    const hasEnough = await hasEnoughETH(publicClient, walletAddress, MIN_ETH_REQUIRED);
+    if (!hasEnough) {
+      const balance = await publicClient.getBalance({ address: walletAddress });
+      console.warn(
+        `Warning: Wallet balance (${formatEther(balance)} ETH) may be insufficient for all tests. ` +
+          `Recommended: ${formatEther(MIN_ETH_REQUIRED)} ETH`
+      );
+    }
+  });
+
+  describe('create', () => {
+    it('should create a new token', async () => {
+      const params = generateUniqueTokenParams();
+      const balanceBefore = await getBalanceSnapshot(publicClient, walletAddress);
+
+      const result = await withTestRetry(() =>
+        sdk.create({
+          ...params,
+          creator: walletAddress,
+        })
+      );
+
+      expect(result.hash).toMatch(/^0x[a-fA-F0-9]{64}$/);
+      expect(result.success).toBe(true);
+      expect(result.tokenAddress).toMatch(/^0x[a-fA-F0-9]{40}$/);
+
+      createdTokenAddress = result.tokenAddress;
+
+      // Verify bonding curve exists
+      const curve = await sdk.getBondingCurve(createdTokenAddress!);
+      expect(curve.tokenTotalSupply).toBeGreaterThan(0n);
+      expect(curve.complete).toBe(false);
+
+      // Verify ETH was spent (gas only)
+      const balanceAfter = await getBalanceSnapshot(publicClient, walletAddress);
+      const diff = compareBalances(balanceBefore, balanceAfter);
+      expect(diff.ethDiff).toBeLessThan(0n); // Spent gas
+    });
+  });
+
+  describe('createAndBuy', () => {
+    it('should create token and buy in one transaction', async () => {
+      const params = generateUniqueTokenParams();
+      const buyAmount = parseEther('0.01');
+      const balanceBefore = await getBalanceSnapshot(publicClient, walletAddress);
+
+      const result = await withTestRetry(() =>
+        sdk.createAndBuy({
+          ...params,
+          creator: walletAddress,
+          buyAmountEth: buyAmount,
+          minTokensOut: 0n, // Accept any amount for test
+        })
+      );
+
+      expect(result.hash).toMatch(/^0x[a-fA-F0-9]{64}$/);
+      expect(result.success).toBe(true);
+      expect(result.tokenAddress).toMatch(/^0x[a-fA-F0-9]{40}$/);
+
+      const tokenAddress = result.tokenAddress!;
+
+      // Verify token balance > 0
+      const tokenBalance = await getTokenBalance(publicClient, tokenAddress, walletAddress);
+      expect(tokenBalance).toBeGreaterThan(0n);
+      console.log(`Bought ${formatEther(tokenBalance)} tokens`);
+
+      // Verify bonding curve has real ETH reserves
+      const curve = await sdk.getBondingCurve(tokenAddress);
+      expect(curve.realEthReserves).toBeGreaterThan(0n);
+
+      // Verify ETH was spent (buyAmount + gas)
+      const balanceAfter = await getBalanceSnapshot(publicClient, walletAddress);
+      const diff = compareBalances(balanceBefore, balanceAfter);
+      expect(diff.ethDiff).toBeLessThan(-buyAmount / 2n); // At least half of buy amount spent
+    });
+  });
+
+  describe('buy', () => {
+    it('should buy tokens and increase balance', async () => {
+      // Create a fresh token for this test
+      const params = generateUniqueTokenParams();
+      const createResult = await withTestRetry(() =>
+        sdk.create({
+          ...params,
+          creator: walletAddress,
+        })
+      );
+
+      if (!createResult.tokenAddress) {
+        throw new Error('Token creation failed');
+      }
+
+      const tokenAddress = createResult.tokenAddress;
+      const tokenBalanceBefore = await getTokenBalance(publicClient, tokenAddress, walletAddress);
+      const ethBalanceBefore = await publicClient.getBalance({ address: walletAddress });
+
+      const buyAmount = parseEther('0.01');
+
+      const result = await withTestRetry(() =>
+        sdk.buy({
+          token: tokenAddress,
+          amountEth: buyAmount,
+          minTokensOut: 0n,
+        })
+      );
+
+      expect(result.hash).toMatch(/^0x[a-fA-F0-9]{64}$/);
+      expect(result.success).toBe(true);
+
+      // Verify token balance increased
+      const tokenBalanceAfter = await getTokenBalance(publicClient, tokenAddress, walletAddress);
+      expect(tokenBalanceAfter).toBeGreaterThan(tokenBalanceBefore);
+      console.log(
+        `Token balance: ${formatEther(tokenBalanceBefore)} -> ${formatEther(tokenBalanceAfter)}`
+      );
+
+      // Verify ETH balance decreased
+      const ethBalanceAfter = await publicClient.getBalance({ address: walletAddress });
+      expect(ethBalanceAfter).toBeLessThan(ethBalanceBefore);
+    });
+
+    it('should fail with unrealistic minTokensOut', async () => {
+      // Create a fresh token for this test
+      const params = generateUniqueTokenParams();
+      const createResult = await withTestRetry(() =>
+        sdk.create({
+          ...params,
+          creator: walletAddress,
+        })
+      );
+
+      if (!createResult.tokenAddress) {
+        throw new Error('Token creation failed');
+      }
+
+      const tokenAddress = createResult.tokenAddress;
+      const buyAmount = parseEther('0.001');
+      const unrealisticMinTokens = parseEther('999999999999'); // Way too high
+
+      await expect(
+        sdk.buy({
+          token: tokenAddress,
+          amountEth: buyAmount,
+          minTokensOut: unrealisticMinTokens,
+        })
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('buyWithSlippage', () => {
+    it('should buy with automatic slippage calculation', async () => {
+      // Create a fresh token for this test
+      const params = generateUniqueTokenParams();
+      const createResult = await withTestRetry(() =>
+        sdk.create({
+          ...params,
+          creator: walletAddress,
+        })
+      );
+
+      if (!createResult.tokenAddress) {
+        throw new Error('Token creation failed');
+      }
+
+      const tokenAddress = createResult.tokenAddress;
+      const buyAmount = parseEther('0.01');
+
+      const result = await withTestRetry(() =>
+        sdk.buyWithSlippage(tokenAddress, buyAmount, 500) // 5% slippage
+      );
+
+      expect(result.hash).toMatch(/^0x[a-fA-F0-9]{64}$/);
+      expect(result.success).toBe(true);
+
+      // Verify tokens received
+      const tokenBalance = await getTokenBalance(publicClient, tokenAddress, walletAddress);
+      expect(tokenBalance).toBeGreaterThan(0n);
+    });
+  });
+
+  describe('sell', () => {
+    it('should sell tokens and receive ETH', async () => {
+      // Create and buy tokens first
+      const params = generateUniqueTokenParams();
+      const createResult = await withTestRetry(() =>
+        sdk.createAndBuy({
+          ...params,
+          creator: walletAddress,
+          buyAmountEth: parseEther('0.02'),
+          minTokensOut: 0n,
+        })
+      );
+
+      if (!createResult.tokenAddress) {
+        throw new Error('Token creation failed');
+      }
+
+      const tokenAddress = createResult.tokenAddress;
+
+      // Get balances before sell
+      const tokenBalanceBefore = await getTokenBalance(publicClient, tokenAddress, walletAddress);
+      const ethBalanceBefore = await publicClient.getBalance({ address: walletAddress });
+
+      // Sell half of tokens
+      const sellAmount = tokenBalanceBefore / 2n;
+
+      const result = await withTestRetry(() =>
+        sdk.sell({
+          token: tokenAddress,
+          amountTokens: sellAmount,
+          minEthOut: 0n, // Accept any amount for test
+        })
+      );
+
+      expect(result.hash).toMatch(/^0x[a-fA-F0-9]{64}$/);
+      expect(result.success).toBe(true);
+
+      // Verify token balance decreased
+      const tokenBalanceAfter = await getTokenBalance(publicClient, tokenAddress, walletAddress);
+      expect(tokenBalanceAfter).toBeLessThan(tokenBalanceBefore);
+      expect(tokenBalanceAfter).toBe(tokenBalanceBefore - sellAmount);
+      console.log(
+        `Token balance: ${formatEther(tokenBalanceBefore)} -> ${formatEther(tokenBalanceAfter)}`
+      );
+
+      // Verify ETH balance increased (accounting for gas)
+      const ethBalanceAfter = await publicClient.getBalance({ address: walletAddress });
+      // Note: ETH might slightly decrease due to gas, but should be close
+      const ethChange = ethBalanceAfter - ethBalanceBefore;
+      console.log(`ETH change: ${formatEther(ethChange)}`);
+    });
+  });
+
+  describe('sellWithSlippage', () => {
+    it('should sell with automatic slippage calculation', async () => {
+      // Create and buy tokens first
+      const params = generateUniqueTokenParams();
+      const createResult = await withTestRetry(() =>
+        sdk.createAndBuy({
+          ...params,
+          creator: walletAddress,
+          buyAmountEth: parseEther('0.02'),
+          minTokensOut: 0n,
+        })
+      );
+
+      if (!createResult.tokenAddress) {
+        throw new Error('Token creation failed');
+      }
+
+      const tokenAddress = createResult.tokenAddress;
+      const tokenBalance = await getTokenBalance(publicClient, tokenAddress, walletAddress);
+
+      // Sell 25% of tokens
+      const sellAmount = tokenBalance / 4n;
+
+      const result = await withTestRetry(() =>
+        sdk.sellWithSlippage(tokenAddress, sellAmount, 500) // 5% slippage
+      );
+
+      expect(result.hash).toMatch(/^0x[a-fA-F0-9]{64}$/);
+      expect(result.success).toBe(true);
+
+      // Verify tokens were sold
+      const tokenBalanceAfter = await getTokenBalance(publicClient, tokenAddress, walletAddress);
+      expect(tokenBalanceAfter).toBeLessThan(tokenBalance);
+    });
+  });
+
+  describe('Balance verification summary', () => {
+    it('should track full buy/sell cycle balances', async () => {
+      // Create fresh token
+      const params = generateUniqueTokenParams();
+
+      // Initial balances
+      const initialEth = await publicClient.getBalance({ address: walletAddress });
+      console.log(`\n=== Balance Tracking Test ===`);
+      console.log(`Initial ETH: ${formatEther(initialEth)}`);
+
+      // Create and buy
+      const buyAmount = parseEther('0.02');
+      const createResult = await withTestRetry(() =>
+        sdk.createAndBuy({
+          ...params,
+          creator: walletAddress,
+          buyAmountEth: buyAmount,
+          minTokensOut: 0n,
+        })
+      );
+
+      const tokenAddress = createResult.tokenAddress!;
+      const tokensReceived = await getTokenBalance(publicClient, tokenAddress, walletAddress);
+      const ethAfterBuy = await publicClient.getBalance({ address: walletAddress });
+
+      console.log(`After createAndBuy:`);
+      console.log(`  Tokens received: ${formatEther(tokensReceived)}`);
+      console.log(`  ETH spent: ${formatEther(initialEth - ethAfterBuy)}`);
+
+      // Sell all tokens
+      const sellResult = await withTestRetry(() =>
+        sdk.sell({
+          token: tokenAddress,
+          amountTokens: tokensReceived,
+          minEthOut: 0n,
+        })
+      );
+
+      const tokensAfterSell = await getTokenBalance(publicClient, tokenAddress, walletAddress);
+      const ethAfterSell = await publicClient.getBalance({ address: walletAddress });
+
+      console.log(`After sell:`);
+      console.log(`  Tokens remaining: ${formatEther(tokensAfterSell)}`);
+      console.log(`  ETH recovered: ${formatEther(ethAfterSell - ethAfterBuy)}`);
+      console.log(`  Total ETH lost (fees + gas): ${formatEther(initialEth - ethAfterSell)}`);
+
+      // Verify all tokens were sold
+      expect(tokensAfterSell).toBe(0n);
+
+      // Verify we lost some ETH to fees (but not all)
+      expect(ethAfterSell).toBeLessThan(initialEth);
+      expect(ethAfterSell).toBeGreaterThan(initialEth - buyAmount);
+    });
+  });
+
+  // Migration test - skip by default as it requires a complete curve
+  describe.skip('migrate', () => {
+    it('should migrate complete curve to Uniswap', async () => {
+      const completedToken = process.env.TEST_COMPLETED_TOKEN_ADDRESS as Address | undefined;
+      if (!completedToken) {
+        console.log('Skipping migration test - no completed token provided');
+        return;
+      }
+
+      // Verify curve is complete
+      const isComplete = await sdk.isComplete(completedToken);
+      expect(isComplete).toBe(true);
+
+      const result = await sdk.migrate({ token: completedToken });
+
+      expect(result.hash).toMatch(/^0x[a-fA-F0-9]{64}$/);
+      expect(result.success).toBe(true);
+
+      // Verify token is now migrated
+      const isMigrated = await sdk.isMigrated(completedToken);
+      expect(isMigrated).toBe(true);
+    });
+  });
+});

package/src/__tests__/setup.ts

@@ -0,0 +1,34 @@
+import { config } from 'dotenv';
+import { resolve } from 'path';
+
+// Load test environment variables
+config({ path: resolve(process.cwd(), '.env.test') });
+
+// Validate required environment variables for integration tests
+export function validateIntegrationEnv(): boolean {
+  const required = ['TEST_PRIVATE_KEY', 'MEGA_ETH_RPC_URL'];
+  const missing = required.filter((key) => !process.env[key]);
+
+  if (missing.length > 0) {
+    console.warn(
+      `Missing environment variables for integration tests: ${missing.join(', ')}`
+    );
+    console.warn('Integration tests will be skipped.');
+    return false;
+  }
+
+  return true;
+}
+
+// Check if integration tests should run
+export const RUN_INTEGRATION_TESTS =
+  process.env.RUN_INTEGRATION_TESTS === 'true' && validateIntegrationEnv();
+
+// Global test setup
+beforeAll(() => {
+  // Any global setup can go here
+});
+
+afterAll(() => {
+  // Any global cleanup can go here
+});