@mania-labs/mania-sdk 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1165 @@
+// src/mania.ts
+import {
+  createPublicClient,
+  createWalletClient,
+  http,
+  parseEventLogs
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+
+// src/constants.ts
+var PROTOCOL_FEE_BASIS_POINTS = 70n;
+var CREATOR_FEE_BASIS_POINTS = 30n;
+var TOTAL_FEE_BASIS_POINTS = PROTOCOL_FEE_BASIS_POINTS + CREATOR_FEE_BASIS_POINTS;
+var MAX_FEE_BASIS_POINTS = 1000n;
+var MIGRATION_THRESHOLD = 4000000000000000000n;
+var TOKENS_FOR_LP = 206900000000000000000000000n;
+var MAX_MIGRATE_FEES = 300000000000000n;
+var UNISWAP_FEE_TIER = 3e3;
+var TICK_LOWER = -887220;
+var TICK_UPPER = 887220;
+var DEFAULT_SLIPPAGE_BPS = 100;
+var BPS_DENOMINATOR = 10000n;
+var CHAIN_CONFIGS = {
+  // Mega Eth Testnet
+  6543: {
+    chainId: 6543,
+    name: "Mega Eth Testnet",
+    factoryAddress: "0x0d593cE47EBA2d15a77ddbAc41BdE6d03CC9241b",
+    wethAddress: "0x4200000000000000000000000000000000000006",
+    nonfungiblePositionManager: "0xa204A97EF8Bd2E3198f19EB5a804680467BD85f5",
+    uniswapV3Factory: "0x619fb6C12c36b57a8bAb05e98F42C43745DCf69f",
+    blockExplorer: "https://megaeth-testnet-v2.blockscout.com"
+  }
+};
+function getChainConfig(chainId) {
+  return CHAIN_CONFIGS[chainId];
+}
+
+// src/bondingCurve.ts
+var BondingCurve = class _BondingCurve {
+  state;
+  feeBasisPoints;
+  constructor(state, feeBasisPoints) {
+    this.state = state;
+    this.feeBasisPoints = feeBasisPoints;
+  }
+  /**
+   * Get the current bonding curve state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Check if the bonding curve is complete (reached migration threshold)
+   */
+  isComplete() {
+    return this.state.complete;
+  }
+  /**
+   * Check if the bonding curve has been migrated (all reserves are 0)
+   */
+  isMigrated() {
+    return this.state.realEthReserves === 0n && this.state.virtualEthReserves === 0n && this.state.realTokenReserves === 0n && this.state.virtualTokenReserves === 0n;
+  }
+  /**
+   * Get the current token price in ETH (wei per token)
+   * 
+   * Price is calculated as: virtualEthReserves / virtualTokenReserves
+   */
+  getCurrentPrice() {
+    if (this.state.virtualTokenReserves === 0n) {
+      return 0n;
+    }
+    return this.state.virtualEthReserves * 10n ** 18n / this.state.virtualTokenReserves;
+  }
+  /**
+   * Get the market cap in ETH
+   * 
+   * Market cap = current price * total supply
+   */
+  getMarketCapEth() {
+    const price = this.getCurrentPrice();
+    return price * this.state.tokenTotalSupply / 10n ** 18n;
+  }
+  /**
+   * Get the progress towards migration threshold (0-100)
+   */
+  getMigrationProgress() {
+    if (this.state.complete) {
+      return 100;
+    }
+    const progress = this.state.realEthReserves * 100n / MIGRATION_THRESHOLD;
+    return Number(progress);
+  }
+  /**
+   * Calculate ETH remaining until migration
+   */
+  getEthUntilMigration() {
+    if (this.state.realEthReserves >= MIGRATION_THRESHOLD) {
+      return 0n;
+    }
+    return MIGRATION_THRESHOLD - this.state.realEthReserves;
+  }
+  /**
+   * Get a quote for buying tokens with a specific ETH amount
+   * 
+   * @param ethAmount - Amount of ETH to spend (in wei)
+   * @returns Quote with tokens out, fees, and price impact
+   */
+  getBuyQuote(ethAmount) {
+    const fee = ethAmount * this.feeBasisPoints / BPS_DENOMINATOR;
+    const netEth = ethAmount - fee;
+    const tokensOut = this.state.virtualTokenReserves * netEth / (this.state.virtualEthReserves + netEth);
+    const cappedTokensOut = tokensOut > this.state.realTokenReserves ? this.state.realTokenReserves : tokensOut;
+    const pricePerToken = cappedTokensOut > 0n ? netEth * 10n ** 18n / cappedTokensOut : 0n;
+    return {
+      tokensOut: cappedTokensOut,
+      fee,
+      netEth,
+      pricePerToken
+    };
+  }
+  /**
+   * Get a quote for selling tokens
+   * 
+   * @param tokenAmount - Amount of tokens to sell
+   * @returns Quote with ETH out, fees, and price impact
+   */
+  getSellQuote(tokenAmount) {
+    const ethOutGross = tokenAmount * this.state.virtualEthReserves / (this.state.virtualTokenReserves + tokenAmount);
+    const fee = ethOutGross * this.feeBasisPoints / BPS_DENOMINATOR;
+    const ethOutNet = ethOutGross - fee;
+    const pricePerToken = tokenAmount > 0n ? ethOutNet * 10n ** 18n / tokenAmount : 0n;
+    return {
+      ethOutGross,
+      fee,
+      ethOutNet,
+      pricePerToken
+    };
+  }
+  /**
+   * Calculate minimum tokens out with slippage tolerance
+   * 
+   * @param ethAmount - Amount of ETH to spend
+   * @param slippageBps - Slippage tolerance in basis points (e.g., 100 = 1%)
+   * @returns Minimum tokens to receive
+   */
+  calculateMinTokensOut(ethAmount, slippageBps) {
+    const quote = this.getBuyQuote(ethAmount);
+    const slippageMultiplier = BPS_DENOMINATOR - BigInt(slippageBps);
+    return quote.tokensOut * slippageMultiplier / BPS_DENOMINATOR;
+  }
+  /**
+   * Calculate minimum ETH out with slippage tolerance
+   * 
+   * @param tokenAmount - Amount of tokens to sell
+   * @param slippageBps - Slippage tolerance in basis points (e.g., 100 = 1%)
+   * @returns Minimum ETH to receive
+   */
+  calculateMinEthOut(tokenAmount, slippageBps) {
+    const quote = this.getSellQuote(tokenAmount);
+    const slippageMultiplier = BPS_DENOMINATOR - BigInt(slippageBps);
+    return quote.ethOutNet * slippageMultiplier / BPS_DENOMINATOR;
+  }
+  /**
+   * Calculate price impact for a buy order
+   * 
+   * @param ethAmount - Amount of ETH to spend
+   * @returns Price impact as a percentage (e.g., 2.5 = 2.5%)
+   */
+  calculateBuyPriceImpact(ethAmount) {
+    const currentPrice = this.getCurrentPrice();
+    if (currentPrice === 0n) return 0;
+    const quote = this.getBuyQuote(ethAmount);
+    if (quote.tokensOut === 0n) return 0;
+    const newVirtualEth = this.state.virtualEthReserves + quote.netEth;
+    const newVirtualTokens = this.state.virtualTokenReserves - quote.tokensOut;
+    const newPrice = newVirtualEth * 10n ** 18n / newVirtualTokens;
+    const impact = Number((newPrice - currentPrice) * 10000n / currentPrice) / 100;
+    return impact;
+  }
+  /**
+   * Calculate price impact for a sell order
+   * 
+   * @param tokenAmount - Amount of tokens to sell
+   * @returns Price impact as a percentage (negative for sells)
+   */
+  calculateSellPriceImpact(tokenAmount) {
+    const currentPrice = this.getCurrentPrice();
+    if (currentPrice === 0n) return 0;
+    const quote = this.getSellQuote(tokenAmount);
+    const newVirtualEth = this.state.virtualEthReserves - quote.ethOutGross;
+    const newVirtualTokens = this.state.virtualTokenReserves + tokenAmount;
+    if (newVirtualTokens === 0n) return -100;
+    const newPrice = newVirtualEth * 10n ** 18n / newVirtualTokens;
+    const impact = Number((newPrice - currentPrice) * 10000n / currentPrice) / 100;
+    return impact;
+  }
+  /**
+   * Check if a buy would exceed the migration threshold
+   * 
+   * @param ethAmount - Amount of ETH to spend
+   * @returns True if the buy would exceed threshold
+   */
+  wouldExceedMigrationThreshold(ethAmount) {
+    const fee = ethAmount * this.feeBasisPoints / BPS_DENOMINATOR;
+    const netEth = ethAmount - fee;
+    return this.state.realEthReserves + netEth > MIGRATION_THRESHOLD;
+  }
+  /**
+   * Calculate maximum ETH that can be spent before hitting migration threshold
+   * 
+   * @returns Maximum ETH amount (in wei)
+   */
+  getMaxBuyAmount() {
+    if (this.state.complete) {
+      return 0n;
+    }
+    const remainingEth = MIGRATION_THRESHOLD - this.state.realEthReserves;
+    const maxEthWithFees = remainingEth * BPS_DENOMINATOR / (BPS_DENOMINATOR - this.feeBasisPoints);
+    return maxEthWithFees;
+  }
+  /**
+   * Update the internal state (used after trades)
+   */
+  updateState(newState) {
+    this.state = { ...newState };
+  }
+  /**
+   * Create a BondingCurve instance from raw contract data
+   */
+  static fromContractData(data, feeBasisPoints) {
+    const state = {
+      virtualTokenReserves: data[0],
+      virtualEthReserves: data[1],
+      realTokenReserves: data[2],
+      realEthReserves: data[3],
+      tokenTotalSupply: data[4],
+      complete: data[5],
+      trackVolume: data[6]
+    };
+    return new _BondingCurve(state, feeBasisPoints);
+  }
+};
+function calculateBuyAmount(virtualTokenReserves, virtualEthReserves, ethAmount, feeBasisPoints) {
+  const fee = ethAmount * feeBasisPoints / BPS_DENOMINATOR;
+  const netEth = ethAmount - fee;
+  return virtualTokenReserves * netEth / (virtualEthReserves + netEth);
+}
+function calculateSellAmount(virtualTokenReserves, virtualEthReserves, tokenAmount, feeBasisPoints) {
+  const ethOutGross = tokenAmount * virtualEthReserves / (virtualTokenReserves + tokenAmount);
+  const fee = ethOutGross * feeBasisPoints / BPS_DENOMINATOR;
+  return ethOutGross - fee;
+}
+
+// src/abi.ts
+var MANIA_FACTORY_ABI = [
+  {
+    type: "function",
+    name: "bondingCurves",
+    inputs: [{ name: "mint", type: "address" }],
+    outputs: [
+      { name: "virtualTokenReserves", type: "uint256" },
+      { name: "virtualEthReserves", type: "uint64" },
+      { name: "realTokenReserves", type: "uint256" },
+      { name: "realEthReserves", type: "uint64" },
+      { name: "tokenTotalSupply", type: "uint256" },
+      { name: "complete", type: "bool" },
+      { name: "trackVolume", type: "bool" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "buy",
+    inputs: [
+      { name: "token", type: "address" },
+      { name: "minTokensOut", type: "uint256" },
+      { name: "recipient", type: "address" }
+    ],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "create",
+    inputs: [
+      { name: "name", type: "string" },
+      { name: "symbol", type: "string" },
+      { name: "uri", type: "string" },
+      { name: "creator", type: "address" }
+    ],
+    outputs: [{ name: "token", type: "address" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "createAndBuy",
+    inputs: [
+      { name: "name", type: "string" },
+      { name: "symbol", type: "string" },
+      { name: "uri", type: "string" },
+      { name: "creator", type: "address" },
+      { name: "minTokensOut", type: "uint256" }
+    ],
+    outputs: [{ name: "token", type: "address" }],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "getBondingCurve",
+    inputs: [{ name: "token", type: "address" }],
+    outputs: [
+      {
+        name: "curve",
+        type: "tuple",
+        components: [
+          { name: "virtualTokenReserves", type: "uint256" },
+          { name: "virtualEthReserves", type: "uint64" },
+          { name: "realTokenReserves", type: "uint256" },
+          { name: "realEthReserves", type: "uint64" },
+          { name: "tokenTotalSupply", type: "uint256" },
+          { name: "complete", type: "bool" },
+          { name: "trackVolume", type: "bool" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getBuyQuote",
+    inputs: [
+      { name: "token", type: "address" },
+      { name: "ethAmount", type: "uint64" }
+    ],
+    outputs: [{ name: "tokenAmount", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getFee",
+    inputs: [{ name: "amount", type: "uint64" }],
+    outputs: [{ name: "fee", type: "uint128" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getSellQuote",
+    inputs: [
+      { name: "token", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "ethOutput", type: "uint128" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "global",
+    inputs: [],
+    outputs: [
+      { name: "initialized", type: "bool" },
+      { name: "authority", type: "address" },
+      { name: "feeRecipient", type: "address" },
+      { name: "initialVirtualTokenReserves", type: "uint256" },
+      { name: "initialVirtualEthReserves", type: "uint64" },
+      { name: "initialRealTokenReserves", type: "uint256" },
+      { name: "tokenTotalSupply", type: "uint256" },
+      { name: "feeBasisPoints", type: "uint64" },
+      { name: "withdrawAuthority", type: "address" },
+      { name: "enableMigrate", type: "bool" },
+      { name: "poolMigrationFee", type: "uint64" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "migrate",
+    inputs: [{ name: "token", type: "address" }],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "sell",
+    inputs: [
+      { name: "token", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "minEthOutput", type: "uint64" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "userVolume",
+    inputs: [{ name: "user", type: "address" }],
+    outputs: [{ name: "volume", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    name: "CreateEvent",
+    inputs: [
+      { name: "name", type: "string", indexed: false },
+      { name: "symbol", type: "string", indexed: false },
+      { name: "uri", type: "string", indexed: false },
+      { name: "mint", type: "address", indexed: true },
+      { name: "user", type: "address", indexed: true },
+      { name: "creator", type: "address", indexed: true },
+      { name: "timestamp", type: "uint256", indexed: false }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "TradeEvent",
+    inputs: [
+      { name: "mint", type: "address", indexed: true },
+      { name: "ethAmount", type: "uint64", indexed: false },
+      { name: "tokenAmount", type: "uint256", indexed: false },
+      { name: "isBuy", type: "bool", indexed: false },
+      { name: "user", type: "address", indexed: true },
+      { name: "timestamp", type: "uint256", indexed: false },
+      { name: "virtualEthReserves", type: "uint64", indexed: false },
+      { name: "virtualTokenReserves", type: "uint256", indexed: false },
+      { name: "realEthReserves", type: "uint64", indexed: false },
+      { name: "realTokenReserves", type: "uint256", indexed: false }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "CompleteEvent",
+    inputs: [
+      { name: "user", type: "address", indexed: true },
+      { name: "mint", type: "address", indexed: true },
+      { name: "timestamp", type: "uint256", indexed: false }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "CompleteManiaAmmMigrationEvent",
+    inputs: [
+      { name: "user", type: "address", indexed: true },
+      { name: "mint", type: "address", indexed: true },
+      { name: "mintAmount", type: "uint256", indexed: false },
+      { name: "ethAmount", type: "uint64", indexed: false },
+      { name: "poolMigrationFee", type: "uint64", indexed: false },
+      { name: "timestamp", type: "uint256", indexed: false },
+      { name: "pool", type: "address", indexed: true }
+    ],
+    anonymous: false
+  }
+];
+var ERC20_ABI = [
+  {
+    type: "function",
+    name: "name",
+    inputs: [],
+    outputs: [{ type: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "symbol",
+    inputs: [],
+    outputs: [{ type: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "decimals",
+    inputs: [],
+    outputs: [{ type: "uint8" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "totalSupply",
+    inputs: [],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "allowance",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "approve",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ type: "bool" }],
+    stateMutability: "nonpayable"
+  }
+];
+
+// src/mania.ts
+var ManiaSDK = class _ManiaSDK {
+  publicClient;
+  walletClient = null;
+  factoryAddress;
+  chainId;
+  /**
+   * Create a new ManiaSDK instance
+   * 
+   * @param config - SDK configuration
+   * @param config.factoryAddress - ManiaFactory contract address
+   * @param config.rpcUrl - RPC URL for the chain
+   * @param config.chainId - Chain ID (optional, will be fetched if not provided)
+   */
+  constructor(config) {
+    this.factoryAddress = config.factoryAddress;
+    this.chainId = config.chainId ?? 1;
+    this.publicClient = createPublicClient({
+      transport: http(config.rpcUrl)
+    });
+  }
+  /**
+   * Create SDK instance from chain ID using default configuration
+   * 
+   * @param chainId - Chain ID
+   * @param rpcUrl - RPC URL (optional, uses public RPC if not provided)
+   * @returns ManiaSDK instance
+   */
+  static fromChainId(chainId, rpcUrl) {
+    const chainConfig = getChainConfig(chainId);
+    if (!chainConfig) {
+      throw new Error(`Unsupported chain ID: ${chainId}`);
+    }
+    return new _ManiaSDK({
+      factoryAddress: chainConfig.factoryAddress,
+      rpcUrl,
+      chainId
+    });
+  }
+  /**
+   * Connect a wallet for signing transactions
+   * 
+   * @param privateKey - Private key (with or without 0x prefix)
+   * @param chain - Viem chain object
+   */
+  connectWallet(privateKey, chain) {
+    const account = privateKeyToAccount(
+      privateKey.startsWith("0x") ? privateKey : `0x${privateKey}`
+    );
+    this.walletClient = createWalletClient({
+      account,
+      chain,
+      transport: http()
+    });
+  }
+  /**
+   * Connect an existing wallet client
+   * 
+   * @param walletClient - Viem wallet client
+   */
+  setWalletClient(walletClient) {
+    this.walletClient = walletClient;
+  }
+  /**
+   * Set a custom public client
+   * 
+   * @param publicClient - Viem public client
+   */
+  setPublicClient(publicClient) {
+    this.publicClient = publicClient;
+  }
+  /**
+   * Get the connected wallet address
+   */
+  getWalletAddress() {
+    return this.walletClient?.account?.address;
+  }
+  // ========== READ METHODS ==========
+  /**
+   * Get global protocol configuration
+   */
+  async getGlobalState() {
+    const result = await this.publicClient.readContract({
+      address: this.factoryAddress,
+      abi: MANIA_FACTORY_ABI,
+      functionName: "global"
+    });
+    const [
+      initialized,
+      authority,
+      feeRecipient,
+      initialVirtualTokenReserves,
+      initialVirtualEthReserves,
+      initialRealTokenReserves,
+      tokenTotalSupply,
+      feeBasisPoints,
+      withdrawAuthority,
+      enableMigrate,
+      poolMigrationFee
+    ] = result;
+    return {
+      initialized,
+      authority,
+      feeRecipient,
+      initialVirtualTokenReserves,
+      initialVirtualEthReserves,
+      initialRealTokenReserves,
+      tokenTotalSupply,
+      feeBasisPoints,
+      withdrawAuthority,
+      enableMigrate,
+      poolMigrationFee
+    };
+  }
+  /**
+   * Get bonding curve state for a token
+   * 
+   * @param token - Token address
+   */
+  async getBondingCurve(token) {
+    const result = await this.publicClient.readContract({
+      address: this.factoryAddress,
+      abi: MANIA_FACTORY_ABI,
+      functionName: "getBondingCurve",
+      args: [token]
+    });
+    const curve = result;
+    return {
+      virtualTokenReserves: curve.virtualTokenReserves,
+      virtualEthReserves: curve.virtualEthReserves,
+      realTokenReserves: curve.realTokenReserves,
+      realEthReserves: curve.realEthReserves,
+      tokenTotalSupply: curve.tokenTotalSupply,
+      complete: curve.complete,
+      trackVolume: curve.trackVolume
+    };
+  }
+  /**
+   * Get a BondingCurve instance for calculations
+   * 
+   * @param token - Token address
+   */
+  async getBondingCurveInstance(token) {
+    const [curveState, globalState] = await Promise.all([
+      this.getBondingCurve(token),
+      this.getGlobalState()
+    ]);
+    return new BondingCurve(curveState, globalState.feeBasisPoints);
+  }
+  /**
+   * Get comprehensive token information
+   * 
+   * @param token - Token address
+   */
+  async getTokenInfo(token) {
+    const curve = await this.getBondingCurveInstance(token);
+    const state = curve.getState();
+    return {
+      address: token,
+      bondingCurve: state,
+      currentPrice: curve.getCurrentPrice(),
+      marketCapEth: curve.getMarketCapEth(),
+      migrationProgress: curve.getMigrationProgress()
+    };
+  }
+  /**
+   * Get buy quote from contract
+   * 
+   * @param token - Token address
+   * @param ethAmount - ETH amount in wei
+   */
+  async getBuyQuote(token, ethAmount) {
+    const result = await this.publicClient.readContract({
+      address: this.factoryAddress,
+      abi: MANIA_FACTORY_ABI,
+      functionName: "getBuyQuote",
+      args: [token, ethAmount]
+    });
+    return result;
+  }
+  /**
+   * Get sell quote from contract
+   * 
+   * @param token - Token address
+   * @param tokenAmount - Token amount
+   */
+  async getSellQuote(token, tokenAmount) {
+    const result = await this.publicClient.readContract({
+      address: this.factoryAddress,
+      abi: MANIA_FACTORY_ABI,
+      functionName: "getSellQuote",
+      args: [token, tokenAmount]
+    });
+    return result;
+  }
+  /**
+   * Get fee for a given amount
+   * 
+   * @param amount - Amount in wei
+   */
+  async getFee(amount) {
+    const result = await this.publicClient.readContract({
+      address: this.factoryAddress,
+      abi: MANIA_FACTORY_ABI,
+      functionName: "getFee",
+      args: [amount]
+    });
+    return result;
+  }
+  /**
+   * Get user volume
+   * 
+   * @param user - User address
+   */
+  async getUserVolume(user) {
+    const result = await this.publicClient.readContract({
+      address: this.factoryAddress,
+      abi: MANIA_FACTORY_ABI,
+      functionName: "userVolume",
+      args: [user]
+    });
+    return result;
+  }
+  // ========== WRITE METHODS ==========
+  getConnectedWallet() {
+    if (!this.walletClient?.account) {
+      throw new Error("Wallet not connected. Call connectWallet() first.");
+    }
+    return this.walletClient;
+  }
+  /**
+   * Create a new token with bonding curve
+   * 
+   * @param params - Token creation parameters
+   * @returns Transaction result with token address
+   */
+  async create(params) {
+    const wallet = this.getConnectedWallet();
+    const hash = await wallet.writeContract({
+      chain: null,
+      account: null,
+      address: this.factoryAddress,
+      abi: MANIA_FACTORY_ABI,
+      functionName: "create",
+      args: [params.name, params.symbol, params.uri, params.creator]
+    });
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+    const logs = parseEventLogs({
+      abi: MANIA_FACTORY_ABI,
+      logs: receipt.logs,
+      eventName: "CreateEvent"
+    });
+    const tokenAddress = logs[0]?.args?.mint;
+    return {
+      hash,
+      success: receipt.status === "success",
+      tokenAddress
+    };
+  }
+  /**
+   * Create a new token and buy in a single transaction
+   * 
+   * @param params - Creation and buy parameters
+   * @returns Transaction result with token address
+   */
+  async createAndBuy(params) {
+    const wallet = this.getConnectedWallet();
+    const hash = await wallet.writeContract({
+      chain: null,
+      account: null,
+      address: this.factoryAddress,
+      abi: MANIA_FACTORY_ABI,
+      functionName: "createAndBuy",
+      args: [params.name, params.symbol, params.uri, params.creator, params.minTokensOut],
+      value: params.buyAmountEth
+    });
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+    const logs = parseEventLogs({
+      abi: MANIA_FACTORY_ABI,
+      logs: receipt.logs,
+      eventName: "CreateEvent"
+    });
+    const tokenAddress = logs[0]?.args?.mint;
+    return {
+      hash,
+      success: receipt.status === "success",
+      tokenAddress
+    };
+  }
+  /**
+   * Buy tokens from bonding curve
+   * 
+   * @param params - Buy parameters
+   * @returns Transaction result
+   */
+  async buy(params) {
+    const wallet = this.getConnectedWallet();
+    const recipient = params.recipient ?? wallet.account.address;
+    const hash = await wallet.writeContract({
+      chain: null,
+      account: null,
+      address: this.factoryAddress,
+      abi: MANIA_FACTORY_ABI,
+      functionName: "buy",
+      args: [params.token, params.minTokensOut, recipient],
+      value: params.amountEth
+    });
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+    return {
+      hash,
+      success: receipt.status === "success"
+    };
+  }
+  /**
+   * Buy tokens with automatic slippage calculation
+   * 
+   * @param token - Token address
+   * @param ethAmount - ETH amount to spend
+   * @param slippageBps - Slippage tolerance in basis points (default: 100 = 1%)
+   */
+  async buyWithSlippage(token, ethAmount, slippageBps = DEFAULT_SLIPPAGE_BPS) {
+    const curve = await this.getBondingCurveInstance(token);
+    const minTokensOut = curve.calculateMinTokensOut(ethAmount, slippageBps);
+    return this.buy({
+      token,
+      amountEth: ethAmount,
+      minTokensOut
+    });
+  }
+  /**
+   * Sell tokens to bonding curve
+   * 
+   * @param params - Sell parameters
+   * @returns Transaction result
+   */
+  async sell(params) {
+    const wallet = this.getConnectedWallet();
+    const hash = await wallet.writeContract({
+      chain: null,
+      account: null,
+      address: this.factoryAddress,
+      abi: MANIA_FACTORY_ABI,
+      functionName: "sell",
+      args: [params.token, params.amountTokens, params.minEthOut]
+    });
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+    return {
+      hash,
+      success: receipt.status === "success"
+    };
+  }
+  /**
+   * Sell tokens with automatic slippage calculation
+   * 
+   * @param token - Token address
+   * @param tokenAmount - Token amount to sell
+   * @param slippageBps - Slippage tolerance in basis points (default: 100 = 1%)
+   */
+  async sellWithSlippage(token, tokenAmount, slippageBps = DEFAULT_SLIPPAGE_BPS) {
+    const curve = await this.getBondingCurveInstance(token);
+    const minEthOut = curve.calculateMinEthOut(tokenAmount, slippageBps);
+    return this.sell({
+      token,
+      amountTokens: tokenAmount,
+      minEthOut
+    });
+  }
+  /**
+   * Migrate liquidity to Uniswap V3
+   * 
+   * @param params - Migration parameters
+   * @returns Transaction result with pool address
+   */
+  async migrate(params) {
+    const wallet = this.getConnectedWallet();
+    const globalState = await this.getGlobalState();
+    const hash = await wallet.writeContract({
+      chain: null,
+      account: null,
+      address: this.factoryAddress,
+      abi: MANIA_FACTORY_ABI,
+      functionName: "migrate",
+      args: [params.token],
+      value: globalState.poolMigrationFee
+    });
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+    const logs = parseEventLogs({
+      abi: MANIA_FACTORY_ABI,
+      logs: receipt.logs,
+      eventName: "CompleteManiaAmmMigrationEvent"
+    });
+    const poolAddress = logs[0]?.args?.pool;
+    return {
+      hash,
+      success: receipt.status === "success",
+      poolAddress
+    };
+  }
+  // ========== EVENT WATCHING ==========
+  /**
+   * Watch for new token creation events
+   * 
+   * @param callback - Callback function for each event
+   * @returns Unwatch function
+   */
+  watchCreateEvents(callback) {
+    return this.publicClient.watchContractEvent({
+      address: this.factoryAddress,
+      abi: MANIA_FACTORY_ABI,
+      eventName: "CreateEvent",
+      onLogs: (logs) => {
+        for (const log of logs) {
+          const args = log.args;
+          callback(args);
+        }
+      }
+    });
+  }
+  /**
+   * Watch for trade events on a specific token
+   * 
+   * @param token - Token address (optional, watches all if not provided)
+   * @param callback - Callback function for each event
+   * @returns Unwatch function
+   */
+  watchTradeEvents(token, callback) {
+    return this.publicClient.watchContractEvent({
+      address: this.factoryAddress,
+      abi: MANIA_FACTORY_ABI,
+      eventName: "TradeEvent",
+      args: token ? { mint: token } : void 0,
+      onLogs: (logs) => {
+        for (const log of logs) {
+          const args = log.args;
+          callback(args);
+        }
+      }
+    });
+  }
+  /**
+   * Watch for bonding curve completion events
+   * 
+   * @param callback - Callback function for each event
+   * @returns Unwatch function
+   */
+  watchCompleteEvents(callback) {
+    return this.publicClient.watchContractEvent({
+      address: this.factoryAddress,
+      abi: MANIA_FACTORY_ABI,
+      eventName: "CompleteEvent",
+      onLogs: (logs) => {
+        for (const log of logs) {
+          const args = log.args;
+          callback(args);
+        }
+      }
+    });
+  }
+  /**
+   * Watch for migration events
+   * 
+   * @param callback - Callback function for each event
+   * @returns Unwatch function
+   */
+  watchMigrationEvents(callback) {
+    return this.publicClient.watchContractEvent({
+      address: this.factoryAddress,
+      abi: MANIA_FACTORY_ABI,
+      eventName: "CompleteManiaAmmMigrationEvent",
+      onLogs: (logs) => {
+        for (const log of logs) {
+          const args = log.args;
+          callback(args);
+        }
+      }
+    });
+  }
+  // ========== UTILITY METHODS ==========
+  /**
+   * Check if a token's bonding curve is complete
+   * 
+   * @param token - Token address
+   */
+  async isComplete(token) {
+    const curve = await this.getBondingCurve(token);
+    return curve.complete;
+  }
+  /**
+   * Check if a token has been migrated
+   * 
+   * @param token - Token address
+   */
+  async isMigrated(token) {
+    const curve = await this.getBondingCurve(token);
+    return curve.realEthReserves === 0n && curve.virtualEthReserves === 0n && curve.realTokenReserves === 0n && curve.virtualTokenReserves === 0n;
+  }
+  /**
+   * Get the factory contract address
+   */
+  getFactoryAddress() {
+    return this.factoryAddress;
+  }
+  /**
+   * Get the public client
+   */
+  getPublicClient() {
+    return this.publicClient;
+  }
+  /**
+   * Get the wallet client
+   */
+  getWalletClient() {
+    return this.walletClient;
+  }
+};
+
+// src/utils.ts
+import { formatEther, parseEther } from "viem";
+function formatEthValue(wei, decimals = 4) {
+  const ethValue = formatEther(wei);
+  const num = parseFloat(ethValue);
+  return num.toFixed(decimals);
+}
+function formatTokenAmount(amount, decimals = 2) {
+  const ethValue = formatEther(amount);
+  const num = parseFloat(ethValue);
+  if (num >= 1e9) {
+    return (num / 1e9).toFixed(decimals) + "B";
+  }
+  if (num >= 1e6) {
+    return (num / 1e6).toFixed(decimals) + "M";
+  }
+  if (num >= 1e3) {
+    return (num / 1e3).toFixed(decimals) + "K";
+  }
+  return num.toFixed(decimals);
+}
+function parseEthValue(eth) {
+  return parseEther(eth);
+}
+function calculateWithSlippage(amount, slippageBps) {
+  const slippageMultiplier = BPS_DENOMINATOR - BigInt(slippageBps);
+  return amount * slippageMultiplier / BPS_DENOMINATOR;
+}
+function calculateMigrationProgress(realEthReserves) {
+  if (realEthReserves >= MIGRATION_THRESHOLD) {
+    return 100;
+  }
+  return Number(realEthReserves * 10000n / MIGRATION_THRESHOLD) / 100;
+}
+function formatPrice(priceWei) {
+  const price = Number(priceWei) / 1e18;
+  if (price < 1e-6) {
+    return price.toExponential(4);
+  }
+  if (price < 1e-4) {
+    return price.toFixed(8);
+  }
+  if (price < 0.01) {
+    return price.toFixed(6);
+  }
+  return price.toFixed(4);
+}
+function formatMarketCap(marketCapWei) {
+  const ethValue = Number(formatEther(marketCapWei));
+  if (ethValue >= 1e3) {
+    return (ethValue / 1e3).toFixed(2) + "K ETH";
+  }
+  return ethValue.toFixed(2) + " ETH";
+}
+function isValidAddress(address) {
+  return /^0x[a-fA-F0-9]{40}$/.test(address);
+}
+function truncateAddress(address, chars = 4) {
+  const start = address.slice(0, chars + 2);
+  const end = address.slice(-chars);
+  return start + "..." + end;
+}
+function bpsToPercent(bps) {
+  return Number(bps) / 100;
+}
+function percentToBps(percent) {
+  return Math.round(percent * 100);
+}
+function calculatePriceImpact(currentPrice, newPrice) {
+  if (currentPrice === 0n) return 0;
+  return Number((newPrice - currentPrice) * 10000n / currentPrice) / 100;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRetry(fn, maxRetries = 3, baseDelayMs = 1e3) {
+  let lastError;
+  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 sleep(baseDelayMs * Math.pow(2, i));
+      }
+    }
+  }
+  throw lastError;
+}
+export {
+  BPS_DENOMINATOR,
+  BondingCurve,
+  CHAIN_CONFIGS,
+  CREATOR_FEE_BASIS_POINTS,
+  DEFAULT_SLIPPAGE_BPS,
+  ERC20_ABI,
+  MANIA_FACTORY_ABI,
+  MAX_FEE_BASIS_POINTS,
+  MAX_MIGRATE_FEES,
+  MIGRATION_THRESHOLD,
+  ManiaSDK,
+  PROTOCOL_FEE_BASIS_POINTS,
+  TICK_LOWER,
+  TICK_UPPER,
+  TOKENS_FOR_LP,
+  TOTAL_FEE_BASIS_POINTS,
+  UNISWAP_FEE_TIER,
+  bpsToPercent,
+  calculateBuyAmount,
+  calculateMigrationProgress,
+  calculatePriceImpact,
+  calculateSellAmount,
+  calculateWithSlippage,
+  formatEthValue,
+  formatMarketCap,
+  formatPrice,
+  formatTokenAmount,
+  getChainConfig,
+  isValidAddress,
+  parseEthValue,
+  percentToBps,
+  sleep,
+  truncateAddress,
+  withRetry
+};