@mania-labs/mania-sdk 1.0.0

package/src/types.ts

@@ -0,0 +1,238 @@
+import type { Address, Hash } from "viem";
+
+/**
+ * Bonding curve state for a token
+ */
+export interface BondingCurveState {
+  /** Virtual token reserves used in AMM calculation */
+  virtualTokenReserves: bigint;
+  /** Virtual ETH reserves used in AMM calculation */
+  virtualEthReserves: bigint;
+  /** Real token reserves available for purchase */
+  realTokenReserves: bigint;
+  /** Real ETH reserves collected from sales */
+  realEthReserves: bigint;
+  /** Total supply of the token */
+  tokenTotalSupply: bigint;
+  /** Whether the bonding curve has completed (reached migration threshold) */
+  complete: boolean;
+  /** Whether volume tracking is enabled for this token */
+  trackVolume: boolean;
+}
+
+/**
+ * Global protocol configuration
+ */
+export interface GlobalState {
+  /** Whether the protocol has been initialized */
+  initialized: boolean;
+  /** Protocol authority address */
+  authority: Address;
+  /** Fee recipient address */
+  feeRecipient: Address;
+  /** Initial virtual token reserves for new curves */
+  initialVirtualTokenReserves: bigint;
+  /** Initial virtual ETH reserves for new curves */
+  initialVirtualEthReserves: bigint;
+  /** Initial real token reserves for new curves */
+  initialRealTokenReserves: bigint;
+  /** Token total supply for new tokens */
+  tokenTotalSupply: bigint;
+  /** Fee basis points (1 bp = 0.01%) */
+  feeBasisPoints: bigint;
+  /** Withdraw authority address */
+  withdrawAuthority: Address;
+  /** Whether migration to Uniswap is enabled */
+  enableMigrate: boolean;
+  /** Fee charged for pool migration */
+  poolMigrationFee: bigint;
+}
+
+/**
+ * Parameters for setting global protocol configuration
+ */
+export interface SetParamsInput {
+  initialVirtualTokenReserves: bigint;
+  initialVirtualEthReserves: bigint;
+  initialRealTokenReserves: bigint;
+  tokenTotalSupply: bigint;
+  feeBasisPoints: bigint;
+  withdrawAuthority: Address;
+  enableMigrate: boolean;
+  poolMigrationFee: bigint;
+  feeRecipient: Address;
+}
+
+/**
+ * Token creation parameters
+ */
+export interface CreateTokenParams {
+  /** Token name */
+  name: string;
+  /** Token symbol */
+  symbol: string;
+  /** Token metadata URI (e.g., IPFS link) */
+  uri: string;
+  /** Creator address (receives creator fees) */
+  creator: Address;
+}
+
+/**
+ * Parameters for creating a token and buying in a single transaction
+ */
+export interface CreateAndBuyParams extends CreateTokenParams {
+  /** ETH amount to spend on initial buy */
+  buyAmountEth: bigint;
+  /** Minimum tokens to receive (slippage protection) */
+  minTokensOut: bigint;
+}
+
+/**
+ * Buy transaction parameters
+ */
+export interface BuyParams {
+  /** Token address to buy */
+  token: Address;
+  /** ETH amount to spend */
+  amountEth: bigint;
+  /** Minimum tokens to receive (slippage protection) */
+  minTokensOut: bigint;
+  /** Recipient address for tokens (defaults to sender) */
+  recipient?: Address;
+}
+
+/**
+ * Sell transaction parameters
+ */
+export interface SellParams {
+  /** Token address to sell */
+  token: Address;
+  /** Amount of tokens to sell */
+  amountTokens: bigint;
+  /** Minimum ETH to receive (slippage protection) */
+  minEthOut: bigint;
+}
+
+/**
+ * Migration parameters
+ */
+export interface MigrateParams {
+  /** Token address to migrate */
+  token: Address;
+}
+
+/**
+ * Quote result for buy operations
+ */
+export interface BuyQuote {
+  /** Tokens that would be received */
+  tokensOut: bigint;
+  /** Fee amount in ETH */
+  fee: bigint;
+  /** Net ETH after fees */
+  netEth: bigint;
+  /** Price per token in ETH */
+  pricePerToken: bigint;
+}
+
+/**
+ * Quote result for sell operations
+ */
+export interface SellQuote {
+  /** ETH that would be received (before fees) */
+  ethOutGross: bigint;
+  /** Fee amount in ETH */
+  fee: bigint;
+  /** Net ETH after fees */
+  ethOutNet: bigint;
+  /** Price per token in ETH */
+  pricePerToken: bigint;
+}
+
+/**
+ * Token information combining on-chain data
+ */
+export interface TokenInfo {
+  /** Token contract address */
+  address: Address;
+  /** Bonding curve state */
+  bondingCurve: BondingCurveState;
+  /** Current token price in ETH */
+  currentPrice: bigint;
+  /** Market cap in ETH */
+  marketCapEth: bigint;
+  /** Progress towards migration (0-100) */
+  migrationProgress: number;
+}
+
+/**
+ * Transaction result
+ */
+export interface TransactionResult {
+  /** Transaction hash */
+  hash: Hash;
+  /** Whether the transaction was successful */
+  success: boolean;
+}
+
+/**
+ * Event types emitted by the contract
+ */
+export interface CreateEvent {
+  name: string;
+  symbol: string;
+  uri: string;
+  mint: Address;
+  user: Address;
+  creator: Address;
+  timestamp: bigint;
+}
+
+export interface TradeEvent {
+  mint: Address;
+  ethAmount: bigint;
+  tokenAmount: bigint;
+  isBuy: boolean;
+  user: Address;
+  timestamp: bigint;
+  virtualEthReserves: bigint;
+  virtualTokenReserves: bigint;
+  realEthReserves: bigint;
+  realTokenReserves: bigint;
+}
+
+export interface CompleteEvent {
+  user: Address;
+  mint: Address;
+  timestamp: bigint;
+}
+
+export interface MigrationEvent {
+  user: Address;
+  mint: Address;
+  mintAmount: bigint;
+  ethAmount: bigint;
+  poolMigrationFee: bigint;
+  timestamp: bigint;
+  pool: Address;
+}
+
+/**
+ * SDK Configuration
+ */
+export interface ManiaSDKConfig {
+  /** ManiaFactory contract address */
+  factoryAddress: Address;
+  /** RPC URL or viem public client */
+  rpcUrl?: string;
+  /** Chain ID */
+  chainId?: number;
+}
+
+/**
+ * Slippage configuration
+ */
+export interface SlippageConfig {
+  /** Slippage tolerance in basis points (e.g., 100 = 1%) */
+  slippageBps: number;
+}

package/src/utils.ts

@@ -0,0 +1,154 @@
+import { formatEther, parseEther, type Address } from "viem";
+import { BPS_DENOMINATOR, MIGRATION_THRESHOLD } from "./constants.js";
+
+/**
+ * Format a bigint wei value to a human-readable ETH string
+ */
+export function formatEthValue(wei: bigint, decimals: number = 4): string {
+  const ethValue = formatEther(wei);
+  const num = parseFloat(ethValue);
+  return num.toFixed(decimals);
+}
+
+/**
+ * Format a token amount to a human-readable string
+ */
+export function formatTokenAmount(amount: bigint, decimals: number = 2): string {
+  const ethValue = formatEther(amount);
+  const num = parseFloat(ethValue);
+  
+  if (num >= 1_000_000_000) {
+    return (num / 1_000_000_000).toFixed(decimals) + "B";
+  }
+  if (num >= 1_000_000) {
+    return (num / 1_000_000).toFixed(decimals) + "M";
+  }
+  if (num >= 1_000) {
+    return (num / 1_000).toFixed(decimals) + "K";
+  }
+  return num.toFixed(decimals);
+}
+
+/**
+ * Parse an ETH string to wei
+ */
+export function parseEthValue(eth: string): bigint {
+  return parseEther(eth);
+}
+
+/**
+ * Calculate slippage-adjusted minimum amount
+ */
+export function calculateWithSlippage(amount: bigint, slippageBps: number): bigint {
+  const slippageMultiplier = BPS_DENOMINATOR - BigInt(slippageBps);
+  return (amount * slippageMultiplier) / BPS_DENOMINATOR;
+}
+
+/**
+ * Calculate percentage of migration threshold reached
+ */
+export function calculateMigrationProgress(realEthReserves: bigint): number {
+  if (realEthReserves >= MIGRATION_THRESHOLD) {
+    return 100;
+  }
+  return Number((realEthReserves * 10000n) / MIGRATION_THRESHOLD) / 100;
+}
+
+/**
+ * Format price with appropriate precision
+ */
+export function formatPrice(priceWei: bigint): string {
+  const price = Number(priceWei) / 1e18;
+  
+  if (price < 0.000001) {
+    return price.toExponential(4);
+  }
+  if (price < 0.0001) {
+    return price.toFixed(8);
+  }
+  if (price < 0.01) {
+    return price.toFixed(6);
+  }
+  return price.toFixed(4);
+}
+
+/**
+ * Format market cap in ETH
+ */
+export function formatMarketCap(marketCapWei: bigint): string {
+  const ethValue = Number(formatEther(marketCapWei));
+  
+  if (ethValue >= 1000) {
+    return (ethValue / 1000).toFixed(2) + "K ETH";
+  }
+  return ethValue.toFixed(2) + " ETH";
+}
+
+/**
+ * Validate Ethereum address format
+ */
+export function isValidAddress(address: string): address is Address {
+  return /^0x[a-fA-F0-9]{40}$/.test(address);
+}
+
+/**
+ * Truncate address for display
+ */
+export function truncateAddress(address: Address, chars: number = 4): string {
+  const start = address.slice(0, chars + 2);
+  const end = address.slice(-chars);
+  return start + "..." + end;
+}
+
+/**
+ * Convert basis points to percentage
+ */
+export function bpsToPercent(bps: number | bigint): number {
+  return Number(bps) / 100;
+}
+
+/**
+ * Convert percentage to basis points
+ */
+export function percentToBps(percent: number): number {
+  return Math.round(percent * 100);
+}
+
+/**
+ * Calculate price impact as a percentage
+ */
+export function calculatePriceImpact(currentPrice: bigint, newPrice: bigint): number {
+  if (currentPrice === 0n) return 0;
+  return Number(((newPrice - currentPrice) * 10000n) / currentPrice) / 100;
+}
+
+/**
+ * Sleep utility for polling
+ */
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Retry a function with exponential backoff
+ */
+export async function withRetry<T>(
+  fn: () => Promise<T>,
+  maxRetries: number = 3,
+  baseDelayMs: 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 sleep(baseDelayMs * Math.pow(2, i));
+      }
+    }
+  }
+  
+  throw lastError;
+}