@mania-labs/mania-sdk 1.0.0 → 1.0.1

package/dist/index.js

@@ -76,8 +76,8 @@ var DEFAULT_SLIPPAGE_BPS = 100;
 var BPS_DENOMINATOR = 10000n;
 var CHAIN_CONFIGS = {
   // Mega Eth Testnet
-  6543: {
-    chainId: 6543,
+  6343: {
+    chainId: 6343,
     name: "Mega Eth Testnet",
     factoryAddress: "0x0d593cE47EBA2d15a77ddbAc41BdE6d03CC9241b",
     wethAddress: "0x4200000000000000000000000000000000000006",
@@ -815,12 +815,13 @@ var ManiaSDK = class _ManiaSDK {
   async create(params) {
     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]
+      args: [params.name, params.symbol, params.uri, params.creator],
+      gas: 300000000n
     });
     const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
     const logs = (0, import_viem.parseEventLogs)({
@@ -844,13 +845,14 @@ var ManiaSDK = class _ManiaSDK {
   async createAndBuy(params) {
     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
+      value: params.buyAmountEth,
+      gas: 300000000n
     });
     const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
     const logs = (0, import_viem.parseEventLogs)({
@@ -875,13 +877,14 @@ var ManiaSDK = class _ManiaSDK {
     const wallet = this.getConnectedWallet();
     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
+      value: params.amountEth,
+      gas: 300000000n
     });
     const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
     return {
@@ -914,12 +917,13 @@ var ManiaSDK = class _ManiaSDK {
   async sell(params) {
     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]
+      args: [params.token, params.amountTokens, params.minEthOut],
+      gas: 300000000n
     });
     const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
     return {
@@ -953,13 +957,14 @@ var ManiaSDK = class _ManiaSDK {
     const wallet = this.getConnectedWallet();
     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
+      value: globalState.poolMigrationFee,
+      gas: 300000000n
     });
     const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
     const logs = (0, import_viem.parseEventLogs)({

package/dist/index.mjs

@@ -22,8 +22,8 @@ var DEFAULT_SLIPPAGE_BPS = 100;
 var BPS_DENOMINATOR = 10000n;
 var CHAIN_CONFIGS = {
   // Mega Eth Testnet
-  6543: {
-    chainId: 6543,
+  6343: {
+    chainId: 6343,
     name: "Mega Eth Testnet",
     factoryAddress: "0x0d593cE47EBA2d15a77ddbAc41BdE6d03CC9241b",
     wethAddress: "0x4200000000000000000000000000000000000006",
@@ -761,12 +761,13 @@ var ManiaSDK = class _ManiaSDK {
   async create(params) {
     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]
+      args: [params.name, params.symbol, params.uri, params.creator],
+      gas: 300000000n
     });
     const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
     const logs = parseEventLogs({
@@ -790,13 +791,14 @@ var ManiaSDK = class _ManiaSDK {
   async createAndBuy(params) {
     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
+      value: params.buyAmountEth,
+      gas: 300000000n
     });
     const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
     const logs = parseEventLogs({
@@ -821,13 +823,14 @@ var ManiaSDK = class _ManiaSDK {
     const wallet = this.getConnectedWallet();
     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
+      value: params.amountEth,
+      gas: 300000000n
     });
     const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
     return {
@@ -860,12 +863,13 @@ var ManiaSDK = class _ManiaSDK {
   async sell(params) {
     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]
+      args: [params.token, params.amountTokens, params.minEthOut],
+      gas: 300000000n
     });
     const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
     return {
@@ -899,13 +903,14 @@ var ManiaSDK = class _ManiaSDK {
     const wallet = this.getConnectedWallet();
     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
+      value: globalState.poolMigrationFee,
+      gas: 300000000n
     });
     const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
     const logs = parseEventLogs({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mania-labs/mania-sdk",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Official SDK for interacting with the Mania Protocol - EVM Bonding Curve Token Launchpad",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -24,6 +24,10 @@
     "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
     "lint": "eslint src --ext .ts",
     "test": "vitest",
+    "test:unit": "vitest run --dir src/__tests__/unit",
+    "test:integration": "vitest run --dir src/__tests__/integration",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest watch",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -43,6 +47,8 @@
   },
   "devDependencies": {
     "@types/node": "^24.10.1",
+    "@vitest/coverage-v8": "^2.1.0",
+    "dotenv": "^16.3.1",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
     "vitest": "^2.1.0"

package/src/.claude/settings.local.json

@@ -1,7 +1,8 @@
 {
   "permissions": {
     "allow": [
-      "WebFetch(domain:www.npmjs.com)"
+      "WebFetch(domain:www.npmjs.com)",
+      "Bash(cat:*)"
     ],
     "deny": [],
     "ask": []

package/src/__tests__/helpers/fixtures.ts

@@ -0,0 +1,136 @@
+import type { Address } from 'viem';
+import { parseEther } from 'viem';
+import type { BondingCurveState, GlobalState } from '../../types.js';
+
+/**
+ * Test addresses
+ */
+export const TEST_ADDRESSES = {
+  FACTORY: '0x0d593cE47EBA2d15a77ddbAc41BdE6d03CC9241b' as Address,
+  WETH: '0x4200000000000000000000000000000000000006' as Address,
+  ZERO: '0x0000000000000000000000000000000000000000' as Address,
+  USER1: '0x1111111111111111111111111111111111111111' as Address,
+  USER2: '0x2222222222222222222222222222222222222222' as Address,
+  TOKEN1: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' as Address,
+  TOKEN2: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' as Address,
+};
+
+/**
+ * Common test amounts
+ */
+export const TEST_AMOUNTS = {
+  SMALL_ETH: parseEther('0.01'),
+  MEDIUM_ETH: parseEther('0.1'),
+  LARGE_ETH: parseEther('1'),
+  MIGRATION_THRESHOLD: parseEther('4'),
+  SMALL_TOKENS: parseEther('1000'),
+  MEDIUM_TOKENS: parseEther('1000000'),
+  LARGE_TOKENS: parseEther('100000000'),
+};
+
+/**
+ * Default token creation parameters
+ */
+export const TEST_TOKEN_PARAMS = {
+  name: 'Test Token',
+  symbol: 'TEST',
+  uri: 'https://example.com/metadata.json',
+  creator: TEST_ADDRESSES.USER1,
+};
+
+/**
+ * Initial virtual reserves (matching contract defaults)
+ */
+export const INITIAL_RESERVES = {
+  virtualTokenReserves: 1_073_000_000_000_000_000_000_000_000n, // 1.073B tokens
+  virtualEthReserves: 30_000_000_000_000_000n, // 0.03 ETH
+  realTokenReserves: 793_100_000_000_000_000_000_000_000n, // 793.1M tokens
+  tokenTotalSupply: 1_000_000_000_000_000_000_000_000_000n, // 1B tokens
+};
+
+/**
+ * Pre-configured bonding curve scenarios
+ */
+export const CURVE_SCENARIOS = {
+  /**
+   * Fresh curve - no trades yet
+   */
+  FRESH: {
+    virtualTokenReserves: INITIAL_RESERVES.virtualTokenReserves,
+    virtualEthReserves: INITIAL_RESERVES.virtualEthReserves,
+    realTokenReserves: INITIAL_RESERVES.realTokenReserves,
+    realEthReserves: 0n,
+    tokenTotalSupply: INITIAL_RESERVES.tokenTotalSupply,
+    complete: false,
+    trackVolume: true,
+  } as BondingCurveState,
+
+  /**
+   * Half-filled curve - 2 ETH real reserves (50% to migration)
+   */
+  HALF_FILLED: {
+    virtualTokenReserves: 800_000_000_000_000_000_000_000_000n,
+    virtualEthReserves: 2_030_000_000_000_000_000n, // 2.03 ETH
+    realTokenReserves: 520_000_000_000_000_000_000_000_000n,
+    realEthReserves: 2_000_000_000_000_000_000n, // 2 ETH
+    tokenTotalSupply: INITIAL_RESERVES.tokenTotalSupply,
+    complete: false,
+    trackVolume: true,
+  } as BondingCurveState,
+
+  /**
+   * Near-complete curve - 3.9 ETH real reserves
+   */
+  NEAR_COMPLETE: {
+    virtualTokenReserves: 300_000_000_000_000_000_000_000_000n,
+    virtualEthReserves: 3_930_000_000_000_000_000n,
+    realTokenReserves: 27_000_000_000_000_000_000_000_000n,
+    realEthReserves: 3_900_000_000_000_000_000n, // 3.9 ETH
+    tokenTotalSupply: INITIAL_RESERVES.tokenTotalSupply,
+    complete: false,
+    trackVolume: true,
+  } as BondingCurveState,
+
+  /**
+   * Complete curve - reached 4 ETH threshold
+   */
+  COMPLETE: {
+    virtualTokenReserves: 280_000_000_000_000_000_000_000_000n,
+    virtualEthReserves: 4_030_000_000_000_000_000n,
+    realTokenReserves: 7_000_000_000_000_000_000_000_000n,
+    realEthReserves: 4_000_000_000_000_000_000n, // 4 ETH
+    tokenTotalSupply: INITIAL_RESERVES.tokenTotalSupply,
+    complete: true,
+    trackVolume: true,
+  } as BondingCurveState,
+
+  /**
+   * Migrated curve - all reserves zeroed out
+   */
+  MIGRATED: {
+    virtualTokenReserves: 0n,
+    virtualEthReserves: 0n,
+    realTokenReserves: 0n,
+    realEthReserves: 0n,
+    tokenTotalSupply: INITIAL_RESERVES.tokenTotalSupply,
+    complete: true,
+    trackVolume: true,
+  } as BondingCurveState,
+};
+
+/**
+ * Default global state
+ */
+export const DEFAULT_GLOBAL_STATE: GlobalState = {
+  initialized: true,
+  authority: TEST_ADDRESSES.USER1,
+  feeRecipient: TEST_ADDRESSES.USER1,
+  initialVirtualTokenReserves: INITIAL_RESERVES.virtualTokenReserves,
+  initialVirtualEthReserves: INITIAL_RESERVES.virtualEthReserves,
+  initialRealTokenReserves: INITIAL_RESERVES.realTokenReserves,
+  tokenTotalSupply: INITIAL_RESERVES.tokenTotalSupply,
+  feeBasisPoints: 100n, // 1%
+  withdrawAuthority: TEST_ADDRESSES.USER1,
+  enableMigrate: true,
+  poolMigrationFee: 300_000_000_000_000n, // 0.0003 ETH
+};

package/src/__tests__/helpers/integrationHelpers.ts

@@ -0,0 +1,258 @@
+import {
+  createPublicClient,
+  createWalletClient,
+  http,
+  type Address,
+  type PublicClient,
+  type WalletClient,
+  type Hash,
+  formatEther,
+  parseEther,
+} from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { ManiaSDK } from '../../mania.js';
+import { CHAIN_CONFIGS } from '../../constants.js';
+import { ERC20_ABI } from '../../abi.js';
+
+// Mega ETH Testnet chain definition
+const megaEthTestnet = {
+  id: 6343,
+  name: 'Mega ETH Testnet',
+  nativeCurrency: {
+    decimals: 18,
+    name: 'Ether',
+    symbol: 'ETH',
+  },
+  rpcUrls: {
+    default: {
+      http: [process.env.MEGA_ETH_RPC_URL || 'https://timothy.megaeth.com/rpc'],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: 'Blockscout',
+      url: 'https://megaeth-testnet-v2.blockscout.com',
+    },
+  },
+} as const;
+
+/**
+ * Balance snapshot for tracking changes
+ */
+export interface BalanceSnapshot {
+  eth: bigint;
+  token?: bigint;
+  tokenAddress?: Address;
+}
+
+/**
+ * Balance comparison result
+ */
+export interface BalanceComparison {
+  ethDiff: bigint;
+  tokenDiff?: bigint;
+  ethDiffFormatted: string;
+  tokenDiffFormatted?: string;
+}
+
+/**
+ * Create SDK instance for integration tests
+ */
+export function createTestSDK(): {
+  sdk: ManiaSDK;
+  walletAddress: Address;
+  publicClient: PublicClient;
+  walletClient: WalletClient;
+} {
+  const privateKey = process.env.TEST_PRIVATE_KEY;
+  if (!privateKey) {
+    throw new Error('TEST_PRIVATE_KEY environment variable is required');
+  }
+
+  const rpcUrl = process.env.MEGA_ETH_RPC_URL || 'https://timothy.megaeth.com/rpc';
+  const chainConfig = CHAIN_CONFIGS[6343];
+
+  if (!chainConfig) {
+    throw new Error('Mega ETH Testnet chain config not found');
+  }
+
+  const account = privateKeyToAccount(
+    privateKey.startsWith('0x')
+      ? (privateKey as `0x${string}`)
+      : (`0x${privateKey}` as `0x${string}`)
+  );
+
+  const publicClient = createPublicClient({
+    chain: megaEthTestnet,
+    transport: http(rpcUrl),
+  });
+
+  const walletClient = createWalletClient({
+    account,
+    chain: megaEthTestnet,
+    transport: http(rpcUrl),
+  });
+
+  const sdk = new ManiaSDK({
+    factoryAddress: chainConfig.factoryAddress,
+    rpcUrl,
+    chainId: 6343,
+  });
+
+  sdk.setPublicClient(publicClient as unknown as PublicClient);
+  sdk.setWalletClient(walletClient as unknown as WalletClient);
+
+  return {
+    sdk,
+    walletAddress: account.address,
+    publicClient: publicClient as unknown as PublicClient,
+    walletClient: walletClient as unknown as WalletClient,
+  };
+}
+
+/**
+ * Get ETH and optional token balance snapshot
+ */
+export async function getBalanceSnapshot(
+  publicClient: PublicClient,
+  walletAddress: Address,
+  tokenAddress?: Address
+): Promise<BalanceSnapshot> {
+  const eth = await publicClient.getBalance({ address: walletAddress });
+
+  let token: bigint | undefined;
+  if (tokenAddress) {
+    token = await getTokenBalance(publicClient, tokenAddress, walletAddress);
+  }
+
+  return {
+    eth,
+    token,
+    tokenAddress,
+  };
+}
+
+/**
+ * Compare two balance snapshots
+ */
+export function compareBalances(
+  before: BalanceSnapshot,
+  after: BalanceSnapshot
+): BalanceComparison {
+  const ethDiff = after.eth - before.eth;
+
+  let tokenDiff: bigint | undefined;
+  let tokenDiffFormatted: string | undefined;
+
+  if (before.token !== undefined && after.token !== undefined) {
+    tokenDiff = after.token - before.token;
+    tokenDiffFormatted = formatEther(tokenDiff);
+  }
+
+  return {
+    ethDiff,
+    tokenDiff,
+    ethDiffFormatted: formatEther(ethDiff),
+    tokenDiffFormatted,
+  };
+}
+
+/**
+ * Get ERC20 token balance
+ */
+export async function getTokenBalance(
+  publicClient: PublicClient,
+  tokenAddress: Address,
+  walletAddress: Address
+): Promise<bigint> {
+  const balance = await publicClient.readContract({
+    address: tokenAddress,
+    abi: ERC20_ABI,
+    functionName: 'balanceOf',
+    args: [walletAddress],
+  });
+
+  return balance as bigint;
+}
+
+/**
+ * Verify a transaction was successful
+ */
+export async function verifyTransactionSuccess(
+  publicClient: PublicClient,
+  hash: Hash
+): Promise<boolean> {
+  const receipt = await publicClient.waitForTransactionReceipt({ hash });
+  return receipt.status === 'success';
+}
+
+/**
+ * Check if wallet has enough ETH
+ */
+export async function hasEnoughETH(
+  publicClient: PublicClient,
+  walletAddress: Address,
+  requiredAmount: bigint,
+  buffer: bigint = parseEther('0.01') // Buffer for gas
+): Promise<boolean> {
+  const balance = await publicClient.getBalance({ address: walletAddress });
+  return balance >= requiredAmount + buffer;
+}
+
+/**
+ * Generate unique token parameters for each test
+ */
+export function generateUniqueTokenParams() {
+  const timestamp = Date.now();
+  const random = Math.floor(Math.random() * 10000);
+
+  return {
+    name: `Test Token ${timestamp}-${random}`,
+    symbol: `T${random}`,
+    uri: `https://example.com/token/${timestamp}-${random}.json`,
+  };
+}
+
+/**
+ * Retry wrapper for flaky network operations
+ */
+export async function withTestRetry<T>(
+  fn: () => Promise<T>,
+  maxRetries: number = 3,
+  delayMs: number = 1000
+): Promise<T> {
+  let lastError: Error | undefined;
+
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (i < maxRetries - 1) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs * (i + 1)));
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+/**
+ * Wait for a condition with timeout
+ */
+export async function waitForCondition(
+  condition: () => Promise<boolean>,
+  timeoutMs: number = 30000,
+  intervalMs: number = 1000
+): Promise<boolean> {
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < timeoutMs) {
+    if (await condition()) {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+
+  return false;
+}