@mania-labs/mania-sdk 1.0.0

package/src/abi.ts

@@ -0,0 +1,268 @@
+export const 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,
+  },
+] as const;
+
+export const 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",
+  },
+] as const;

package/src/bondingCurve.ts

@@ -0,0 +1,319 @@
+import type { BondingCurveState, BuyQuote, SellQuote } from "./types.js";
+import {
+  MIGRATION_THRESHOLD,
+  BPS_DENOMINATOR,
+} from "./constants.js";
+
+/**
+ * BondingCurve class for handling bonding curve calculations and state
+ * 
+ * The bonding curve uses a constant product formula (x * y = k) similar to Uniswap V2,
+ * but with virtual reserves to provide initial liquidity.
+ */
+export class BondingCurve {
+  private state: BondingCurveState;
+  private feeBasisPoints: bigint;
+
+  constructor(state: BondingCurveState, feeBasisPoints: bigint) {
+    this.state = state;
+    this.feeBasisPoints = feeBasisPoints;
+  }
+
+  /**
+   * Get the current bonding curve state
+   */
+  getState(): BondingCurveState {
+    return { ...this.state };
+  }
+
+  /**
+   * Check if the bonding curve is complete (reached migration threshold)
+   */
+  isComplete(): boolean {
+    return this.state.complete;
+  }
+
+  /**
+   * Check if the bonding curve has been migrated (all reserves are 0)
+   */
+  isMigrated(): boolean {
+    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(): bigint {
+    if (this.state.virtualTokenReserves === 0n) {
+      return 0n;
+    }
+    // Price in wei per token (scaled by 1e18 for precision)
+    return (this.state.virtualEthReserves * 10n ** 18n) / this.state.virtualTokenReserves;
+  }
+
+  /**
+   * Get the market cap in ETH
+   * 
+   * Market cap = current price * total supply
+   */
+  getMarketCapEth(): bigint {
+    const price = this.getCurrentPrice();
+    return (price * this.state.tokenTotalSupply) / 10n ** 18n;
+  }
+
+  /**
+   * Get the progress towards migration threshold (0-100)
+   */
+  getMigrationProgress(): number {
+    if (this.state.complete) {
+      return 100;
+    }
+    const progress = (this.state.realEthReserves * 100n) / MIGRATION_THRESHOLD;
+    return Number(progress);
+  }
+
+  /**
+   * Calculate ETH remaining until migration
+   */
+  getEthUntilMigration(): bigint {
+    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: bigint): BuyQuote {
+    // Calculate fee
+    const fee = (ethAmount * this.feeBasisPoints) / BPS_DENOMINATOR;
+    const netEth = ethAmount - fee;
+
+    // Calculate tokens out using constant product formula
+    // tokensOut = (virtualTokenReserves * netEth) / (virtualEthReserves + netEth)
+    const tokensOut =
+      (this.state.virtualTokenReserves * netEth) /
+      (this.state.virtualEthReserves + netEth);
+
+    // Cap to available supply
+    const cappedTokensOut = tokensOut > this.state.realTokenReserves 
+      ? this.state.realTokenReserves 
+      : tokensOut;
+
+    // Calculate effective price per token
+    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: bigint): SellQuote {
+    // Calculate ETH out using constant product formula
+    // ethOut = (tokenAmount * virtualEthReserves) / (virtualTokenReserves + tokenAmount)
+    const ethOutGross =
+      (tokenAmount * this.state.virtualEthReserves) /
+      (this.state.virtualTokenReserves + tokenAmount);
+
+    // Calculate fee
+    const fee = (ethOutGross * this.feeBasisPoints) / BPS_DENOMINATOR;
+    const ethOutNet = ethOutGross - fee;
+
+    // Calculate effective price per token
+    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: bigint, slippageBps: number): bigint {
+    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: bigint, slippageBps: number): bigint {
+    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: bigint): number {
+    const currentPrice = this.getCurrentPrice();
+    if (currentPrice === 0n) return 0;
+
+    const quote = this.getBuyQuote(ethAmount);
+    if (quote.tokensOut === 0n) return 0;
+
+    // New price after trade
+    const newVirtualEth = this.state.virtualEthReserves + quote.netEth;
+    const newVirtualTokens = this.state.virtualTokenReserves - quote.tokensOut;
+    const newPrice = (newVirtualEth * 10n ** 18n) / newVirtualTokens;
+
+    // Price impact = (newPrice - currentPrice) / currentPrice * 100
+    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: bigint): number {
+    const currentPrice = this.getCurrentPrice();
+    if (currentPrice === 0n) return 0;
+
+    const quote = this.getSellQuote(tokenAmount);
+
+    // New price after trade
+    const newVirtualEth = this.state.virtualEthReserves - quote.ethOutGross;
+    const newVirtualTokens = this.state.virtualTokenReserves + tokenAmount;
+    
+    if (newVirtualTokens === 0n) return -100;
+    
+    const newPrice = (newVirtualEth * 10n ** 18n) / newVirtualTokens;
+
+    // Price impact = (newPrice - currentPrice) / currentPrice * 100
+    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: bigint): boolean {
+    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(): bigint {
+    if (this.state.complete) {
+      return 0n;
+    }
+
+    const remainingEth = MIGRATION_THRESHOLD - this.state.realEthReserves;
+    
+    // Account for fees: netEth = ethAmount - fee
+    // netEth = ethAmount - (ethAmount * feeBps / 10000)
+    // netEth = ethAmount * (10000 - feeBps) / 10000
+    // ethAmount = netEth * 10000 / (10000 - feeBps)
+    const maxEthWithFees = 
+      (remainingEth * BPS_DENOMINATOR) / 
+      (BPS_DENOMINATOR - this.feeBasisPoints);
+
+    return maxEthWithFees;
+  }
+
+  /**
+   * Update the internal state (used after trades)
+   */
+  updateState(newState: BondingCurveState): void {
+    this.state = { ...newState };
+  }
+
+  /**
+   * Create a BondingCurve instance from raw contract data
+   */
+  static fromContractData(
+    data: readonly [bigint, bigint, bigint, bigint, bigint, boolean, boolean],
+    feeBasisPoints: bigint
+  ): BondingCurve {
+    const state: BondingCurveState = {
+      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);
+  }
+}
+
+/**
+ * Utility function to calculate tokens out without instantiating a class
+ */
+export function calculateBuyAmount(
+  virtualTokenReserves: bigint,
+  virtualEthReserves: bigint,
+  ethAmount: bigint,
+  feeBasisPoints: bigint
+): bigint {
+  const fee = (ethAmount * feeBasisPoints) / BPS_DENOMINATOR;
+  const netEth = ethAmount - fee;
+  return (virtualTokenReserves * netEth) / (virtualEthReserves + netEth);
+}
+
+/**
+ * Utility function to calculate ETH out without instantiating a class
+ */
+export function calculateSellAmount(
+  virtualTokenReserves: bigint,
+  virtualEthReserves: bigint,
+  tokenAmount: bigint,
+  feeBasisPoints: bigint
+): bigint {
+  const ethOutGross = (tokenAmount * virtualEthReserves) / (virtualTokenReserves + tokenAmount);
+  const fee = (ethOutGross * feeBasisPoints) / BPS_DENOMINATOR;
+  return ethOutGross - fee;
+}

package/src/constants.ts

@@ -0,0 +1,72 @@
+import type { Address } from "viem";
+
+/**
+ * Protocol fee constants (matching smart contract)
+ */
+export const PROTOCOL_FEE_BASIS_POINTS = 70n; // 0.70%
+export const CREATOR_FEE_BASIS_POINTS = 30n; // 0.30%
+export const TOTAL_FEE_BASIS_POINTS =
+  PROTOCOL_FEE_BASIS_POINTS + CREATOR_FEE_BASIS_POINTS; // 1.00%
+export const MAX_FEE_BASIS_POINTS = 1000n; // 10% maximum
+
+/**
+ * Migration constants
+ */
+export const MIGRATION_THRESHOLD = 4_000_000_000_000_000_000n; // 4 ETH in wei
+export const TOKENS_FOR_LP = 206_900_000_000_000_000_000_000_000n; // 206.9M tokens
+export const MAX_MIGRATE_FEES = 300_000_000_000_000n; // 0.0003 ETH
+
+/**
+ * Uniswap V3 constants
+ */
+export const UNISWAP_FEE_TIER = 3000; // 0.3%
+export const TICK_LOWER = -887220; // Full range
+export const TICK_UPPER = 887220; // Full range
+
+/**
+ * Default slippage tolerance
+ */
+export const DEFAULT_SLIPPAGE_BPS = 100; // 1%
+
+/**
+ * Basis points denominator
+ */
+export const BPS_DENOMINATOR = 10000n;
+
+/**
+ * Chain configurations
+ */
+export interface ChainConfig {
+  chainId: number;
+  name: string;
+  factoryAddress: Address;
+  wethAddress: Address;
+  nonfungiblePositionManager: Address;
+  uniswapV3Factory: Address;
+  blockExplorer: string;
+}
+
+/**
+ * Supported chain configurations
+ * Add your deployed contract addresses here
+ */
+export const CHAIN_CONFIGS: Record<number, ChainConfig> = {
+  // Mega Eth Testnet
+  6543: {
+    chainId: 6543,
+    name: "Mega Eth Testnet",
+    factoryAddress: "0x0d593cE47EBA2d15a77ddbAc41BdE6d03CC9241b" as Address,
+    wethAddress: "0x4200000000000000000000000000000000000006" as Address,
+    nonfungiblePositionManager:
+      "0xa204A97EF8Bd2E3198f19EB5a804680467BD85f5" as Address,
+    uniswapV3Factory: "0x619fb6C12c36b57a8bAb05e98F42C43745DCf69f" as Address,
+    blockExplorer: "https://megaeth-testnet-v2.blockscout.com",
+  },
+};
+
+/**
+ * Get chain configuration by chain ID
+ */
+export function getChainConfig(chainId: number): ChainConfig | undefined {
+  return CHAIN_CONFIGS[chainId];
+}