pons-client 0.1.0

package/dist/index.js

@@ -0,0 +1,1021 @@
+import { parseAbi, isAddress, createPublicClient, http, getAddress, formatEther, formatUnits, decodeEventLog, keccak256, encodeAbiParameters, parseAbiItem } from 'viem';
+export { decodeEventLog } from 'viem';
+
+// src/client.ts
+
+// src/constants.ts
+var ROBINHOOD_CHAIN_ID = 4663;
+var BPS = 10000n;
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var ADDRESSES = {
+  factory: "0x7eD598BcEf8bd9Edd8C97A195C6d13f40801EC7e",
+  memeHook: "0xE5e702641Ea86F4ae6cC3cDaeD2B886f976Be044",
+  feeEscrow: "0xd3AFEB2a57f70eF218Aa82451c51B2fb0416Ac9e",
+  buybackVault: "0x42df2a798f82289E177311362e8f5ccC45c1219c",
+  launchLocker: "0x267444D099b10fB5Ed7c3Cc7B7c767AdcA574952",
+  launchAndBuy: "0xe33E9E479dF8802cb0866d5d05258bEc4cF62948",
+  launchDeployer: "0x3711ceA4feaDE896C913C68F01Eda97Cb06D1A42",
+  graduationExecutor: "0xC7819B64A1dAECD7eC19856d026cb14EfBd89046",
+  graduationGuard: "0xf5695117b99B6f6401e67d4195BD653628176C6C"
+};
+var PHASE = {
+  NotGraduated: 0,
+  Swept: 1,
+  PoolCreated: 2,
+  Rescued: 3
+};
+var SNIPE_TAX_DECAY_NS = 5000000000n;
+var MAX_SNIPE_EXEMPTIONS = 32;
+var VESTING_DURATION_SECS = 157680000n;
+var MIGRATION_CLAIM_WINDOW_SECS = 7776000n;
+var factoryAbi = parseAbi([
+  // ── Structs ──────────────────────────────────────────────────────────────
+  "struct LaunchConfig { uint256 supply; uint256 curveFeeBps; uint256 phantomQuote; uint256 graduationThreshold; uint24 poolFee; int24 tickSpacing; bool enabled; }",
+  "struct Socials { string twitter; string telegram; string discord; string website; string farcaster; }",
+  "struct TokenParams { string name; string symbol; string logo; string description; Socials socials; address creatorFeeRecipient; uint16 creatorTaxBps; bool buybackEnabled; bytes32 expectedEconomics; bytes32 salt; }",
+  "struct LaunchedToken { address token; address curve; address deployer; address creatorFeeRecipient; address pairToken; uint256 graduationThreshold; uint24 poolFee; int24 tickSpacing; uint16 creatorTaxBps; bool buybackEnabled; uint8 phase; uint256 sweptQuote; uint256 sweptTokens; uint256 sweptAt; bool exists; }",
+  "struct FeePolicy { address protocolFeeRecipient; uint16 protocolFeeShareBps; uint16 buybackBurnBps; uint16 hookFeeBps; uint16 maxInternalPriceImpactBps; }",
+  // ── Read Functions ───────────────────────────────────────────────────────
+  "function launchConfigCount() view returns (uint256)",
+  "function getLaunchConfig(uint256 id) view returns (LaunchConfig)",
+  "function getLaunchedToken(address token) view returns (LaunchedToken)",
+  "function previewLaunchEconomics(uint256 launchConfigId, address pairToken) view returns (bytes32)",
+  "function launchFee() view returns (uint256)",
+  "function canLaunch(address launcher) view returns (bool)",
+  "function maxCreatorTaxBps() view returns (uint16)",
+  "function approvedPairTokens(address pairToken) view returns (bool)",
+  "function pairTokenEconomics(address pairToken) view returns (uint256 phantomQuote, uint256 graduationThreshold, uint8 decimals)",
+  "function getLaunchFeePolicy(address token) view returns (FeePolicy)",
+  "function pendingCreatorFeeRecipient(address token) view returns (address recipient, uint256 effectiveAt, uint256 expiresAt)",
+  // ── Write Functions ──────────────────────────────────────────────────────
+  "function launchToken(TokenParams params, uint256 launchConfigId, address pairToken) payable returns (address token, address curve)",
+  "function launchToken(TokenParams params, uint256 launchConfigId, address pairToken, address[] snipeTaxExemptions) payable returns (address token, address curve)",
+  "function createGraduatedPool(address token)",
+  "function transferCreatorFeeRecipient(address token, address newRecipient)",
+  // ── Events ───────────────────────────────────────────────────────────────
+  "event TokenLaunched(address indexed token, address indexed curve, address indexed deployer, address pairToken, uint256 launchConfigId, uint256 graduationThreshold)",
+  "event LaunchSwept(address indexed token, uint256 sweptQuote, uint256 sweptTokens)",
+  "event PoolGraduated(address indexed token, address indexed pool)",
+  "event CreatorFeeRecipientChangeProposed(address indexed token, address indexed newRecipient, uint256 effectiveAt)",
+  "event CreatorFeeRecipientUpdated(address indexed token, address indexed oldRecipient, address indexed newRecipient)"
+]);
+var routerAbi = parseAbi([
+  // ── Structs ──────────────────────────────────────────────────────────────
+  "struct Socials { string twitter; string telegram; string discord; string website; string farcaster; }",
+  "struct TokenParams { string name; string symbol; string logo; string description; Socials socials; address creatorFeeRecipient; uint16 creatorTaxBps; bool buybackEnabled; bytes32 expectedEconomics; bytes32 salt; }",
+  // ── Write Functions ──────────────────────────────────────────────────────
+  "function launchAndBuy(TokenParams params, uint256 launchConfigId, address pairToken, uint256 quoteIn, uint256 minTokensOut, address recipient, address[] snipeTaxExemptions) payable returns (address token, address curve, uint256 tokensOut)"
+]);
+function requireValidAddress(address, label) {
+  if (!isAddress(address)) {
+    throw new Error(`Invalid ${label} address: ${address}`);
+  }
+}
+function requireValidCreatorTax(taxBps, maxBps) {
+  if (taxBps < 0) {
+    throw new Error("Creator tax cannot be negative");
+  }
+  if (BigInt(taxBps) > maxBps) {
+    throw new Error(`Creator tax ${taxBps} bps exceeds protocol max ${maxBps} bps`);
+  }
+}
+function requireValidExemptions(exemptions) {
+  if (exemptions.length > MAX_SNIPE_EXEMPTIONS) {
+    throw new Error(
+      `Snipe tax exemption list too long: ${exemptions.length} (max ${MAX_SNIPE_EXEMPTIONS})`
+    );
+  }
+}
+function requirePositiveAmount(amount, label) {
+  if (amount <= 0n) {
+    throw new Error(`${label} must be positive, got ${amount}`);
+  }
+}
+function requireValidSlippage(slippageBps) {
+  if (slippageBps < 0 || slippageBps > Number(BPS)) {
+    throw new Error(`Invalid slippage: ${slippageBps} bps (must be 0-${BPS})`);
+  }
+}
+function minOutputWithSlippage(quoted, slippageBps) {
+  const tolerance = quoted * BigInt(slippageBps) / BPS;
+  return quoted - tolerance;
+}
+
+// src/modules/factory/index.ts
+function createFactoryModule(publicClient, wallet, addresses) {
+  const read = async (functionName, args) => publicClient.readContract({
+    address: addresses.factory,
+    abi: factoryAbi,
+    functionName,
+    args
+  });
+  const write = async (functionName, args, value) => {
+    if (!wallet) throw new Error("Wallet required for write operations");
+    const { request } = await publicClient.simulateContract({
+      address: addresses.factory,
+      abi: factoryAbi,
+      functionName,
+      args,
+      account: wallet.account,
+      value
+    });
+    return wallet.writeContract(request);
+  };
+  return {
+    async openLaunchConfigs() {
+      const count = await read("launchConfigCount");
+      const configs = await Promise.all(
+        Array.from(
+          { length: Number(count) },
+          (_, id) => read("getLaunchConfig", [BigInt(id)])
+        )
+      );
+      return configs.map((config, id) => ({
+        id: BigInt(id),
+        supply: config.supply,
+        curveFeeBps: config.curveFeeBps,
+        phantomQuote: config.phantomQuote,
+        graduationThreshold: config.graduationThreshold,
+        poolFee: config.poolFee,
+        tickSpacing: config.tickSpacing,
+        enabled: config.enabled
+      })).filter((config) => config.enabled);
+    },
+    async getLaunchConfig(id) {
+      return read("getLaunchConfig", [id]);
+    },
+    async getLaunchedToken(token) {
+      return read("getLaunchedToken", [token]);
+    },
+    async previewLaunchEconomics(configId, pairToken) {
+      return read("previewLaunchEconomics", [configId, pairToken]);
+    },
+    async launchFee() {
+      return read("launchFee");
+    },
+    async canLaunch(address) {
+      return read("canLaunch", [address]);
+    },
+    async maxCreatorTaxBps() {
+      return read("maxCreatorTaxBps");
+    },
+    async approvedPairTokens(pairToken) {
+      return read("approvedPairTokens", [pairToken]);
+    },
+    async pairTokenEconomics(pairToken) {
+      const result = await read("pairTokenEconomics", [
+        pairToken
+      ]);
+      return {
+        phantomQuote: result[0],
+        graduationThreshold: result[1],
+        decimals: Number(result[2])
+      };
+    },
+    async launchToken(params, configId, pairToken, snipeTaxExemptions = []) {
+      requireValidAddress(pairToken, "pairToken");
+      requireValidCreatorTax(params.creatorTaxBps, await this.maxCreatorTaxBps());
+      requireValidExemptions(snipeTaxExemptions);
+      const [expectedEconomics, launchFeeAmount] = await Promise.all([
+        this.previewLaunchEconomics(configId, pairToken),
+        this.launchFee()
+      ]);
+      const pinnedParams = {
+        name: params.name,
+        symbol: params.symbol,
+        logo: params.logo,
+        description: params.description,
+        socials: params.socials,
+        creatorFeeRecipient: params.creatorFeeRecipient,
+        creatorTaxBps: params.creatorTaxBps,
+        buybackEnabled: params.buybackEnabled,
+        expectedEconomics,
+        salt: params.salt
+      };
+      if (snipeTaxExemptions.length > 0) {
+        return write(
+          "launchToken",
+          [pinnedParams, configId, pairToken, snipeTaxExemptions],
+          launchFeeAmount
+        );
+      }
+      return write("launchToken", [pinnedParams, configId, pairToken], launchFeeAmount);
+    },
+    async launchAndBuy(params, configId, pairToken, quoteIn, minTokensOut, recipient, snipeTaxExemptions = []) {
+      requireValidAddress(pairToken, "pairToken");
+      requireValidAddress(recipient, "recipient");
+      requireValidCreatorTax(params.creatorTaxBps, await this.maxCreatorTaxBps());
+      requireValidExemptions(snipeTaxExemptions);
+      if (!wallet) throw new Error("Wallet required for write operations");
+      const [expectedEconomics, launchFeeAmount] = await Promise.all([
+        this.previewLaunchEconomics(configId, pairToken),
+        this.launchFee()
+      ]);
+      const pinnedParams = {
+        name: params.name,
+        symbol: params.symbol,
+        logo: params.logo,
+        description: params.description,
+        socials: params.socials,
+        creatorFeeRecipient: params.creatorFeeRecipient,
+        creatorTaxBps: params.creatorTaxBps,
+        buybackEnabled: params.buybackEnabled,
+        expectedEconomics,
+        salt: params.salt
+      };
+      const value = pairToken === ZERO_ADDRESS ? launchFeeAmount + quoteIn : launchFeeAmount;
+      const { request, result } = await publicClient.simulateContract({
+        address: addresses.launchAndBuy,
+        abi: routerAbi,
+        functionName: "launchAndBuy",
+        args: [
+          pinnedParams,
+          configId,
+          pairToken,
+          quoteIn,
+          minTokensOut,
+          recipient,
+          snipeTaxExemptions
+        ],
+        account: wallet.account,
+        value
+      });
+      const hash = await wallet.writeContract(request);
+      const typedResult = result;
+      return {
+        hash,
+        token: typedResult[0],
+        curve: typedResult[1],
+        tokensOut: typedResult[2]
+      };
+    }
+  };
+}
+var curveAbi = parseAbi([
+  // ── Read Functions ───────────────────────────────────────────────────────
+  "function getReserves() view returns (uint256 quoteReserve, uint256 tokenReserve)",
+  "function realQuoteReserve() view returns (uint256)",
+  "function sellableTokens() view returns (uint256)",
+  "function reservedTokens() view returns (uint256)",
+  "function graduationThreshold() view returns (uint256)",
+  "function readyToGraduate() view returns (bool)",
+  "function graduated() view returns (bool)",
+  "function feeBps() view returns (uint256)",
+  "function creatorTaxBps() view returns (uint256)",
+  "function buybackEnabled() view returns (bool)",
+  "function isNativeQuote() view returns (bool)",
+  "function pairToken() view returns (address)",
+  "function currentSnipeTaxBps(address recipient) view returns (uint256)",
+  "function quoteFeeBalance() view returns (uint256)",
+  "function creatorTaxBalance() view returns (uint256)",
+  // ── Write Functions ──────────────────────────────────────────────────────
+  "function buy(uint256 quoteIn, uint256 minTokensOut, address recipient) payable returns (uint256 tokensOut)",
+  "function sell(uint256 tokensIn, uint256 minQuoteOut, address recipient) returns (uint256 quoteOut)",
+  "function sweepFees(uint256 minBuybackTokensOut)",
+  // ── Events ───────────────────────────────────────────────────────────────
+  "event CurveBuy(address indexed buyer, address indexed recipient, uint256 quoteIn, uint256 tokensOut, uint256 fee, uint256 tax)",
+  "event CurveSell(address indexed seller, address indexed recipient, uint256 tokensIn, uint256 quoteOut, uint256 fee, uint256 tax)",
+  "event CurveBuyRefunded(address indexed buyer, uint256 refundedQuote)",
+  "event CurveCompleted(address indexed token)",
+  "event CurveGraduated(address indexed token)",
+  "event AutoGraduationFailed(address indexed token)",
+  "event FeesSwept(uint256 quoteFees, uint256 tokenFees, uint256 buybackTokens)",
+  "event BuybackLocked(address indexed token, uint256 quoteSpent, uint256 tokensLocked)"
+]);
+
+// src/utils/math.ts
+function ceilDiv(a, b) {
+  if (b === 0n) throw new Error("Division by zero");
+  return (a + b - 1n) / b;
+}
+function amountOut(inAmount, reserveIn, reserveOut) {
+  if (inAmount === 0n || reserveIn === 0n || reserveOut === 0n) return 0n;
+  return inAmount * reserveOut / (reserveIn + inAmount);
+}
+function amountIn(outAmount, reserveIn, reserveOut) {
+  if (outAmount === 0n || reserveOut === 0n) return 0n;
+  if (outAmount >= reserveOut) throw new Error("Output exceeds reserve");
+  return outAmount * reserveIn / (reserveOut - outAmount) + 1n;
+}
+function applyBps(amount, bps) {
+  return amount * bps / BPS;
+}
+function subtractBps(amount, bps) {
+  return amount - applyBps(amount, bps);
+}
+function marginalPrice(quoteReserve, tokenReserve) {
+  if (tokenReserve === 0n) return 0;
+  return Number(quoteReserve) / Number(tokenReserve);
+}
+function graduationProgress(raised, threshold) {
+  if (threshold === 0n) return 0;
+  const clamped = raised > threshold ? threshold : raised;
+  return Number(clamped) / Number(threshold);
+}
+
+// src/modules/curve/index.ts
+function createCurveModule(publicClient, wallet, _addresses) {
+  const read = async (contractAddress, functionName, args) => publicClient.readContract({
+    address: contractAddress,
+    abi: curveAbi,
+    functionName,
+    args
+  });
+  const write = async (contractAddress, functionName, args, value) => {
+    if (!wallet) throw new Error("Wallet required for write operations");
+    const { request } = await publicClient.simulateContract({
+      address: contractAddress,
+      abi: curveAbi,
+      functionName,
+      args,
+      account: wallet.account,
+      value
+    });
+    return wallet.writeContract(request);
+  };
+  return {
+    async buy(curve, quoteIn, minTokensOut, recipient, value) {
+      const isNative = await read(curve, "isNativeQuote");
+      const sendValue = isNative ? quoteIn : value ?? 0n;
+      const hash = await write(curve, "buy", [quoteIn, minTokensOut, recipient], sendValue);
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      let tokensOut = 0n;
+      for (const log of receipt.logs) {
+        try {
+          const decoded = decodeEventLog({
+            abi: curveAbi,
+            eventName: "CurveBuy",
+            data: log.data,
+            topics: log.topics
+          });
+          if (decoded.eventName === "CurveBuy") {
+            tokensOut = decoded.args.tokensOut;
+            break;
+          }
+        } catch {
+        }
+      }
+      return { tokensOut, hash };
+    },
+    async sell(curve, tokensIn, minQuoteOut, recipient) {
+      const hash = await write(curve, "sell", [tokensIn, minQuoteOut, recipient]);
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      let quoteOut = 0n;
+      for (const log of receipt.logs) {
+        try {
+          const decoded = decodeEventLog({
+            abi: curveAbi,
+            eventName: "CurveSell",
+            data: log.data,
+            topics: log.topics
+          });
+          if (decoded.eventName === "CurveSell") {
+            quoteOut = decoded.args.quoteOut;
+            break;
+          }
+        } catch {
+        }
+      }
+      return { quoteOut, hash };
+    },
+    async quoteBuy(curve, quoteIn, recipient) {
+      const results = await Promise.all([
+        read(curve, "getReserves"),
+        read(curve, "sellableTokens"),
+        read(curve, "feeBps"),
+        read(curve, "creatorTaxBps"),
+        read(curve, "currentSnipeTaxBps", [recipient])
+      ]);
+      const reserves = results[0];
+      const sellable = results[1];
+      const feeBps = results[2];
+      const creatorTaxBps = results[3];
+      const rawSnipeBps = results[4];
+      const quoteReserve = reserves[0];
+      const tokenReserve = reserves[1];
+      let snipeBps = rawSnipeBps;
+      if (snipeBps > 0n) {
+        const maxSnipeBps = BPS - feeBps - creatorTaxBps - 100n;
+        if (snipeBps > maxSnipeBps) snipeBps = maxSnipeBps;
+      }
+      let spent = quoteIn;
+      const fee = spent * feeBps / BPS;
+      const tax = spent * creatorTaxBps / BPS;
+      const snipeTax = spent * snipeBps / BPS;
+      let tokensOut = amountOut(spent - fee - tax - snipeTax, quoteReserve, tokenReserve);
+      if (tokensOut > sellable) {
+        tokensOut = sellable;
+        const net = amountIn(sellable, quoteReserve, tokenReserve);
+        const totalBps = BPS - feeBps - creatorTaxBps - snipeBps;
+        if (totalBps <= 0n) {
+          return { tokensOut, spent: 0n, refund: quoteIn };
+        }
+        const grossed = ceilDiv(net * BPS, totalBps);
+        spent = grossed < quoteIn ? grossed : quoteIn;
+      }
+      return { tokensOut, spent, refund: quoteIn - spent };
+    },
+    async quoteSell(curve, tokensIn) {
+      const results = await Promise.all([
+        read(curve, "getReserves"),
+        read(curve, "feeBps"),
+        read(curve, "creatorTaxBps")
+      ]);
+      const reserves = results[0];
+      const feeBps = results[1];
+      const creatorTaxBps = results[2];
+      const quoteReserve = reserves[0];
+      const tokenReserve = reserves[1];
+      const gross = amountOut(tokensIn, tokenReserve, quoteReserve);
+      const fee = gross * feeBps / BPS;
+      const tax = gross * creatorTaxBps / BPS;
+      return { quoteOut: gross - fee - tax };
+    },
+    async getState(curve) {
+      const reserves = await read(curve, "getReserves");
+      const [
+        realQuoteReserve,
+        sellableTokens,
+        graduationThreshold,
+        readyToGraduate,
+        graduated,
+        feeBps,
+        creatorTaxBps,
+        buybackEnabled,
+        isNativeQuote,
+        pairToken
+      ] = await Promise.all([
+        read(curve, "realQuoteReserve"),
+        read(curve, "sellableTokens"),
+        read(curve, "graduationThreshold"),
+        read(curve, "readyToGraduate"),
+        read(curve, "graduated"),
+        read(curve, "feeBps"),
+        read(curve, "creatorTaxBps"),
+        read(curve, "buybackEnabled"),
+        read(curve, "isNativeQuote"),
+        read(curve, "pairToken")
+      ]);
+      return {
+        reserves: {
+          quoteReserve: reserves[0],
+          tokenReserve: reserves[1]
+        },
+        realQuoteReserve,
+        sellableTokens,
+        graduationThreshold,
+        readyToGraduate,
+        graduated,
+        feeBps,
+        creatorTaxBps,
+        buybackEnabled,
+        isNativeQuote,
+        pairToken
+      };
+    },
+    async getReserves(curve) {
+      const reserves = await read(curve, "getReserves");
+      return { quoteReserve: reserves[0], tokenReserve: reserves[1] };
+    },
+    async sellableTokens(curve) {
+      return read(curve, "sellableTokens");
+    },
+    async readyToGraduate(curve) {
+      return read(curve, "readyToGraduate");
+    },
+    async currentSnipeTaxBps(curve, recipient) {
+      return read(curve, "currentSnipeTaxBps", [recipient]);
+    }
+  };
+}
+var hookAbi = parseAbi([
+  // ── Read Functions ───────────────────────────────────────────────────────
+  "function pendingFees(bytes32 poolId, address currency) view returns (uint256)",
+  "function pendingCreatorTax(bytes32 poolId, address currency) view returns (uint256)",
+  // ── Events ───────────────────────────────────────────────────────────────
+  "event PoolRegistered(bytes32 indexed poolId, address indexed token, address indexed quoteToken)",
+  "event PoolFeesSwept(bytes32 indexed poolId, uint256 quoteFees, uint256 tokenFees, uint256 buybackTokens)",
+  "event PoolConversionSkipped(bytes32 indexed poolId, string reason)",
+  "event PoolBuybackSkipped(bytes32 indexed poolId, string reason)"
+]);
+
+// src/modules/pool/index.ts
+function createPoolModule(publicClient, addresses) {
+  return {
+    buildPoolKey(launch) {
+      const [currency0, currency1] = launch.pairToken.toLowerCase() < launch.token.toLowerCase() ? [launch.pairToken, launch.token] : [launch.token, launch.pairToken];
+      return {
+        currency0,
+        currency1,
+        fee: launch.poolFee,
+        tickSpacing: launch.tickSpacing,
+        hooks: addresses.memeHook
+      };
+    },
+    getPoolId(launch) {
+      const poolKey = this.buildPoolKey(launch);
+      return keccak256(
+        encodeAbiParameters(
+          [
+            { type: "address" },
+            { type: "address" },
+            { type: "uint24" },
+            { type: "int24" },
+            { type: "address" }
+          ],
+          [poolKey.currency0, poolKey.currency1, poolKey.fee, poolKey.tickSpacing, poolKey.hooks]
+        )
+      );
+    },
+    async pendingFees(poolId, currency) {
+      return publicClient.readContract({
+        address: addresses.memeHook,
+        abi: hookAbi,
+        functionName: "pendingFees",
+        args: [poolId, currency]
+      });
+    },
+    async pendingCreatorTax(poolId, currency) {
+      return publicClient.readContract({
+        address: addresses.memeHook,
+        abi: hookAbi,
+        functionName: "pendingCreatorTax",
+        args: [poolId, currency]
+      });
+    }
+  };
+}
+var escrowAbi = parseAbi([
+  // ── Read Functions ───────────────────────────────────────────────────────
+  "function balanceOf(address recipient) view returns (uint256)",
+  "function balanceOfToken(address recipient, address token) view returns (uint256)",
+  // ── Write Functions ──────────────────────────────────────────────────────
+  "function claim()",
+  "function claimToken(address token)",
+  // ── Events ───────────────────────────────────────────────────────────────
+  "event Credited(address indexed recipient, uint256 amount)",
+  "event Claimed(address indexed recipient, uint256 amount)",
+  "event CreditedToken(address indexed recipient, address indexed token, uint256 amount)",
+  "event ClaimedToken(address indexed recipient, address indexed token, uint256 amount)"
+]);
+
+// src/modules/fees/index.ts
+function createFesModule(publicClient, wallet, addresses) {
+  return {
+    async getBalance(recipient) {
+      return publicClient.readContract({
+        address: addresses.feeEscrow,
+        abi: escrowAbi,
+        functionName: "balanceOf",
+        args: [recipient]
+      });
+    },
+    async getERC20Balance(recipient, token) {
+      return publicClient.readContract({
+        address: addresses.feeEscrow,
+        abi: escrowAbi,
+        functionName: "balanceOfToken",
+        args: [recipient, token]
+      });
+    },
+    async claim() {
+      if (!wallet) throw new Error("Wallet required for claim");
+      const { request } = await publicClient.simulateContract({
+        address: addresses.feeEscrow,
+        abi: escrowAbi,
+        functionName: "claim",
+        account: wallet.account
+      });
+      return wallet.writeContract(request);
+    },
+    async claimToken(token) {
+      if (!wallet) throw new Error("Wallet required for claimToken");
+      const { request } = await publicClient.simulateContract({
+        address: addresses.feeEscrow,
+        abi: escrowAbi,
+        functionName: "claimToken",
+        args: [token],
+        account: wallet.account
+      });
+      return wallet.writeContract(request);
+    },
+    async getUnsweptBalance(curve, _creatorFeeRecipient) {
+      const [pendingFees, pendingCreatorTax] = await Promise.all([
+        publicClient.readContract({
+          address: curve,
+          abi: curveAbi,
+          functionName: "quoteFeeBalance"
+        }),
+        publicClient.readContract({
+          address: curve,
+          abi: curveAbi,
+          functionName: "creatorTaxBalance"
+        })
+      ]);
+      return { pendingFees, pendingCreatorTax };
+    },
+    async getHookPendingFees(poolId, quoteCurrency) {
+      const [pendingFees, pendingCreatorTax] = await Promise.all([
+        publicClient.readContract({
+          address: addresses.memeHook,
+          abi: hookAbi,
+          functionName: "pendingFees",
+          args: [poolId, quoteCurrency]
+        }),
+        publicClient.readContract({
+          address: addresses.memeHook,
+          abi: hookAbi,
+          functionName: "pendingCreatorTax",
+          args: [poolId, quoteCurrency]
+        })
+      ]);
+      return { pendingFees, pendingCreatorTax };
+    },
+    async getFeePolicy(token) {
+      return publicClient.readContract({
+        address: addresses.factory,
+        abi: factoryAbi,
+        functionName: "getLaunchFeePolicy",
+        args: [token]
+      });
+    }
+  };
+}
+var vaultAbi = parseAbi([
+  // ── Read Functions ───────────────────────────────────────────────────────
+  "function totalLocked(address token) view returns (uint256)",
+  "function totalReleased(address token) view returns (uint256)",
+  "function vestedAmount(address token) view returns (uint256)",
+  "function releasable(address token) view returns (uint256)",
+  "function vestingStart(address token) view returns (uint256)",
+  "function VESTING_DURATION() view returns (uint256)",
+  // ── Write Functions ──────────────────────────────────────────────────────
+  "function release(address token) returns (uint256 released)",
+  // ── Events ───────────────────────────────────────────────────────────────
+  "event Locked(address indexed token, uint256 amount, uint256 vestingStart)",
+  "event Released(address indexed token, address indexed recipient, uint256 amount)"
+]);
+
+// src/modules/buyback/index.ts
+function createBuybackModule(publicClient, wallet, addresses) {
+  return {
+    async getState(token) {
+      const [totalLocked, totalReleased, vestedAmount, releasable, vestingStart, vestingDuration] = await Promise.all([
+        publicClient.readContract({
+          address: addresses.buybackVault,
+          abi: vaultAbi,
+          functionName: "totalLocked",
+          args: [token]
+        }),
+        publicClient.readContract({
+          address: addresses.buybackVault,
+          abi: vaultAbi,
+          functionName: "totalReleased",
+          args: [token]
+        }),
+        publicClient.readContract({
+          address: addresses.buybackVault,
+          abi: vaultAbi,
+          functionName: "vestedAmount",
+          args: [token]
+        }),
+        publicClient.readContract({
+          address: addresses.buybackVault,
+          abi: vaultAbi,
+          functionName: "releasable",
+          args: [token]
+        }),
+        publicClient.readContract({
+          address: addresses.buybackVault,
+          abi: vaultAbi,
+          functionName: "vestingStart",
+          args: [token]
+        }),
+        publicClient.readContract({
+          address: addresses.buybackVault,
+          abi: vaultAbi,
+          functionName: "VESTING_DURATION"
+        })
+      ]);
+      const progress = totalLocked > 0n ? Number(vestedAmount) / Number(totalLocked) : 0;
+      return {
+        totalLocked,
+        totalReleased,
+        vestedAmount,
+        releasable,
+        vestingStart,
+        vestingDuration,
+        progress
+      };
+    },
+    async release(token) {
+      if (!wallet) throw new Error("Wallet required for release");
+      const { request } = await publicClient.simulateContract({
+        address: addresses.buybackVault,
+        abi: vaultAbi,
+        functionName: "release",
+        args: [token],
+        account: wallet.account
+      });
+      return wallet.writeContract(request);
+    }
+  };
+}
+function createEventsModule(publicClient, addresses) {
+  return {
+    async getLaunches(fromBlock, toBlock = "latest") {
+      const logs = await publicClient.getLogs({
+        address: addresses.factory,
+        event: parseAbiItem(
+          "event TokenLaunched(address indexed token, address indexed curve, address indexed deployer, address pairToken, uint256 launchConfigId, uint256 graduationThreshold)"
+        ),
+        fromBlock,
+        toBlock
+      });
+      return logs.map((log) => ({
+        token: log.args.token,
+        curve: log.args.curve,
+        deployer: log.args.deployer,
+        pairToken: log.args.pairToken,
+        launchConfigId: log.args.launchConfigId,
+        graduationThreshold: log.args.graduationThreshold,
+        blockNumber: log.blockNumber,
+        transactionHash: log.transactionHash
+      }));
+    },
+    async getTrades(curve, fromBlock, toBlock = "latest") {
+      const logs = await publicClient.getLogs({
+        address: curve,
+        events: [
+          parseAbiItem(
+            "event CurveBuy(address indexed buyer, address indexed recipient, uint256 quoteIn, uint256 tokensOut, uint256 fee, uint256 tax)"
+          ),
+          parseAbiItem(
+            "event CurveSell(address indexed seller, address indexed recipient, uint256 tokensIn, uint256 quoteOut, uint256 fee, uint256 tax)"
+          )
+        ],
+        fromBlock,
+        toBlock
+      });
+      const events = [];
+      for (const log of logs) {
+        if (log.eventName === "CurveBuy") {
+          events.push({
+            type: "buy",
+            buyer: log.args.buyer,
+            recipient: log.args.recipient,
+            quoteIn: log.args.quoteIn,
+            tokensOut: log.args.tokensOut,
+            fee: log.args.fee,
+            tax: log.args.tax,
+            blockNumber: log.blockNumber,
+            transactionHash: log.transactionHash
+          });
+        } else if (log.eventName === "CurveSell") {
+          events.push({
+            type: "sell",
+            seller: log.args.seller,
+            recipient: log.args.recipient,
+            tokensIn: log.args.tokensIn,
+            quoteOut: log.args.quoteOut,
+            fee: log.args.fee,
+            tax: log.args.tax,
+            blockNumber: log.blockNumber,
+            transactionHash: log.transactionHash
+          });
+        }
+      }
+      return events;
+    },
+    async getFeeSweeps(hook, fromBlock, toBlock = "latest") {
+      const logs = await publicClient.getLogs({
+        address: hook,
+        event: parseAbiItem(
+          "event PoolFeesSwept(bytes32 indexed poolId, uint256 quoteFees, uint256 tokenFees, uint256 buybackTokens)"
+        ),
+        fromBlock,
+        toBlock
+      });
+      return logs.map((log) => ({
+        poolId: log.args.poolId,
+        quoteFees: log.args.quoteFees,
+        tokenFees: log.args.tokenFees,
+        blockNumber: log.blockNumber,
+        transactionHash: log.transactionHash
+      }));
+    },
+    async getTakeoverProposals(fromBlock, toBlock = "latest") {
+      const logs = await publicClient.getLogs({
+        address: addresses.factory,
+        event: parseAbiItem(
+          "event CreatorFeeRecipientChangeProposed(address indexed token, address indexed newRecipient, uint256 effectiveAt)"
+        ),
+        fromBlock,
+        toBlock
+      });
+      return logs.map((log) => ({
+        token: log.args.token,
+        newRecipient: log.args.newRecipient,
+        effectiveAt: log.args.effectiveAt,
+        blockNumber: log.blockNumber,
+        transactionHash: log.transactionHash
+      }));
+    }
+  };
+}
+
+// src/modules/takeover/index.ts
+function createTakeoverModule(publicClient, addresses) {
+  return {
+    async getPending(token) {
+      const [recipient, effectiveAt, expiresAt] = await publicClient.readContract({
+        address: addresses.factory,
+        abi: factoryAbi,
+        functionName: "pendingCreatorFeeRecipient",
+        args: [token]
+      });
+      const isPending = recipient !== ZERO_ADDRESS && effectiveAt > 0n && expiresAt > 0n;
+      return {
+        proposedRecipient: recipient,
+        effectiveAt,
+        expiresAt,
+        isPending
+      };
+    }
+  };
+}
+var migrationAbi = parseAbi([
+  "function mandate() view returns (uint256)",
+  "function totalDeposited() view returns (uint256)",
+  "function settled() view returns (bool)",
+  "function claimable() view returns (bool)",
+  "function epochCount() view returns (uint256)",
+  "function getEpoch(uint256 index) view returns (uint256 rate, uint256 cap, uint256 deposited, bool closed)",
+  "function deposit(uint256 amount)",
+  "function claim()"
+]);
+function createMigrationModule(publicClient, wallet, _addresses) {
+  return {
+    async getStatus(migrationAddress) {
+      const mandate = await publicClient.readContract({
+        address: migrationAddress,
+        abi: migrationAbi,
+        functionName: "mandate"
+      });
+      const totalDeposited = await publicClient.readContract({
+        address: migrationAddress,
+        abi: migrationAbi,
+        functionName: "totalDeposited"
+      });
+      const settled = await publicClient.readContract({
+        address: migrationAddress,
+        abi: migrationAbi,
+        functionName: "settled"
+      });
+      const claimable = await publicClient.readContract({
+        address: migrationAddress,
+        abi: migrationAbi,
+        functionName: "claimable"
+      });
+      const epochCount = await publicClient.readContract({
+        address: migrationAddress,
+        abi: migrationAbi,
+        functionName: "epochCount"
+      });
+      const epochPromises = [];
+      for (let i = 0; i < Number(epochCount); i++) {
+        epochPromises.push(
+          publicClient.readContract({
+            address: migrationAddress,
+            abi: migrationAbi,
+            functionName: "getEpoch",
+            args: [BigInt(i)]
+          }).then((result) => ({
+            rate: result[0],
+            cap: result[1],
+            deposited: result[2],
+            closed: result[3]
+          }))
+        );
+      }
+      const epochs = await Promise.all(epochPromises);
+      return { mandate, totalDeposited, settled, claimable, epochs };
+    },
+    async deposit(migrationAddress, amount) {
+      if (!wallet) throw new Error("Wallet required for deposit");
+      const { request } = await publicClient.simulateContract({
+        address: migrationAddress,
+        abi: migrationAbi,
+        functionName: "deposit",
+        args: [amount],
+        account: wallet.account
+      });
+      return wallet.writeContract(request);
+    },
+    async claim(migrationAddress) {
+      if (!wallet) throw new Error("Wallet required for claim");
+      const { request } = await publicClient.simulateContract({
+        address: migrationAddress,
+        abi: migrationAbi,
+        functionName: "claim",
+        account: wallet.account
+      });
+      return wallet.writeContract(request);
+    }
+  };
+}
+
+// src/client.ts
+var robinhoodChain = {
+  id: ROBINHOOD_CHAIN_ID,
+  name: "Robinhood Chain",
+  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+  rpcUrls: {
+    default: { http: ["https://rpc.robinhood.com"] }
+  }
+};
+function createPonsClient(config) {
+  const chain = {
+    ...robinhoodChain,
+    id: config.chainId ?? ROBINHOOD_CHAIN_ID
+  };
+  const publicClient = config.publicClient ?? createPublicClient({
+    chain,
+    transport: http(config.rpcUrl)
+  });
+  const wallet = config.wallet;
+  const addresses = ADDRESSES;
+  const factory = createFactoryModule(publicClient, wallet, addresses);
+  const curve = createCurveModule(publicClient, wallet);
+  const pool = createPoolModule(publicClient, addresses);
+  const fees = createFesModule(publicClient, wallet, addresses);
+  const buyback = createBuybackModule(publicClient, wallet, addresses);
+  const events = createEventsModule(publicClient, addresses);
+  const takeover = createTakeoverModule(publicClient, addresses);
+  const migration = createMigrationModule(publicClient, wallet);
+  return {
+    publicClient,
+    wallet,
+    chainId: chain.id,
+    factory,
+    curve,
+    pool,
+    fees,
+    buyback,
+    events,
+    takeover,
+    migration
+  };
+}
+var tokenAbi = parseAbi([
+  // ── ERC-20 Standard ──────────────────────────────────────────────────────
+  "function name() view returns (string)",
+  "function symbol() view returns (string)",
+  "function decimals() view returns (uint8)",
+  "function totalSupply() view returns (uint256)",
+  "function balanceOf(address account) view returns (uint256)",
+  "function transfer(address to, uint256 amount) returns (bool)",
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function approve(address spender, uint256 amount) returns (bool)",
+  "function transferFrom(address from, address to, uint256 amount) returns (bool)",
+  // ── Pons Token Info ──────────────────────────────────────────────────────
+  "struct Socials { string twitter; string telegram; string discord; string website; string farcaster; }",
+  "function getTokenInfo() view returns (address tokenDeployer, string tokenLogo, string tokenDescription, Socials tokenSocials)",
+  // ── Events ───────────────────────────────────────────────────────────────
+  "event Transfer(address indexed from, address indexed to, uint256 value)",
+  "event Approval(address indexed owner, address indexed spender, uint256 value)"
+]);
+var poolManagerAbi = parseAbi([
+  // ── Pool Key Struct ──────────────────────────────────────────────────────
+  "struct PoolKey { address currency0; address currency1; uint24 fee; int24 tickSpacing; address hooks; }",
+  // ── Read Functions ───────────────────────────────────────────────────────
+  "function getPool(PoolKey key) view returns (uint160 sqrtPriceX96, int24 tick, uint24 protocolFeesToken0, uint24 protocolFeesToken1, uint24 lpFeesToken0, uint24 lpFeesToken1)",
+  "function getSlot0(bytes32 poolId) view returns (uint160 sqrtPriceX96, int24 tick, uint24 protocolFeesToken0, uint24 protocolFeesToken1, uint24 lpFeesToken0, uint24 lpFeesToken1)",
+  // ── Events ───────────────────────────────────────────────────────────────
+  "event Swap(bytes32 indexed poolId, address indexed sender, int256 amount0, int256 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick)",
+  "event Initialize(bytes32 indexed poolId, address indexed currency0, address indexed currency1, int24 tickSpacing, address hooks)"
+]);
+function normalizeAddress(address) {
+  if (!address || address === ZERO_ADDRESS) return ZERO_ADDRESS;
+  return getAddress(address);
+}
+function isValidAddress(address) {
+  try {
+    return isAddress(address);
+  } catch {
+    return false;
+  }
+}
+function formatETH(value) {
+  return formatEther(value);
+}
+function formatTokenAmount(value, decimals) {
+  return formatUnits(value, decimals);
+}
+function shortenAddress(address) {
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+
+export { ADDRESSES, BPS, MAX_SNIPE_EXEMPTIONS, MIGRATION_CLAIM_WINDOW_SECS, PHASE, ROBINHOOD_CHAIN_ID, SNIPE_TAX_DECAY_NS, VESTING_DURATION_SECS, ZERO_ADDRESS, amountIn, amountOut, applyBps, ceilDiv, createPonsClient, curveAbi, escrowAbi, factoryAbi, formatETH, formatTokenAmount, graduationProgress, hookAbi, isValidAddress, marginalPrice, minOutputWithSlippage, normalizeAddress, poolManagerAbi, requirePositiveAmount, requireValidAddress, requireValidCreatorTax, requireValidExemptions, requireValidSlippage, routerAbi, shortenAddress, subtractBps, tokenAbi, vaultAbi };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map