@liberfi.io/react-launchpad 0.1.1

package/dist/index.mjs

@@ -0,0 +1,779 @@
+import { createContext, createElement, useContext } from 'react';
+import BigNumber3, { BigNumber } from 'bignumber.js';
+
+// src/index.ts
+
+// src/curve/BaseCurve.ts
+function unimplemented(args) {
+  throw new Error("not implemented");
+}
+var BaseCurve = class {
+  static getPoolInitPriceByPool(args) {
+    return unimplemented();
+  }
+  static getPoolInitPriceByInit(args) {
+    return unimplemented();
+  }
+  static getPoolPrice(args) {
+    return unimplemented();
+  }
+  static getPoolEndPrice(args) {
+    return unimplemented();
+  }
+  static getPoolEndPriceReal(args) {
+    return unimplemented();
+  }
+  static getInitParam(args) {
+    return unimplemented();
+  }
+  static buyExactIn(args) {
+    return unimplemented();
+  }
+  static buyExactOut(args) {
+    return unimplemented();
+  }
+  static sellExactIn(args) {
+    return unimplemented();
+  }
+  static sellExactOut(args) {
+    return unimplemented();
+  }
+};
+var ConstantProductCurve = class extends BaseCurve {
+  static getPoolInitPriceByPool({
+    poolInfo,
+    decimalA,
+    decimalB
+  }) {
+    return new BigNumber(poolInfo.virtualB).div(poolInfo.virtualA).times(10 ** (decimalA - decimalB));
+  }
+  static getPoolInitPriceByInit({
+    a,
+    b,
+    decimalA,
+    decimalB
+  }) {
+    return new BigNumber(b).div(a).times(10 ** (decimalA - decimalB));
+  }
+  static getPoolPrice({
+    poolInfo,
+    decimalA,
+    decimalB
+  }) {
+    return new BigNumber(new BigNumber(poolInfo.virtualB).plus(poolInfo.realB)).div(new BigNumber(poolInfo.virtualA).minus(poolInfo.realA)).times(10 ** (decimalA - decimalB));
+  }
+  static getPoolEndPrice({
+    supply,
+    totalSell,
+    totalLockedAmount,
+    totalFundRaising,
+    migrateFee,
+    decimalA,
+    decimalB
+  }) {
+    return new BigNumber(new BigNumber(totalFundRaising).minus(migrateFee)).div(new BigNumber(supply).minus(totalSell).minus(totalLockedAmount)).times(10 ** (decimalA - decimalB));
+  }
+  static getPoolEndPriceReal({
+    poolInfo,
+    decimalA,
+    decimalB
+  }) {
+    const allSellToken = new BigNumber(poolInfo.totalSellA).minus(poolInfo.realA);
+    const buyAllTokenUseB = new BigNumber(poolInfo.totalFundRaisingB).minus(poolInfo.realB);
+    return new BigNumber(
+      new BigNumber(poolInfo.virtualB).plus(poolInfo.realB).plus(buyAllTokenUseB)
+    ).div(new BigNumber(poolInfo.virtualA).minus(new BigNumber(poolInfo.realA).plus(allSellToken))).times(10 ** (decimalA - decimalB));
+  }
+  static getInitParam({
+    supply,
+    totalFundRaising,
+    totalSell,
+    totalLockedAmount,
+    migrateFee
+  }) {
+    if (new BigNumber(supply).lte(totalSell)) throw Error("supply need gt total sell");
+    const supplyMinusSellLocked = new BigNumber(supply).minus(totalSell).minus(totalLockedAmount);
+    if (supplyMinusSellLocked.lte(new BigNumber(0))) throw Error("supplyMinusSellLocked <= 0");
+    const tfMinusMf = new BigNumber(totalFundRaising).minus(migrateFee);
+    if (tfMinusMf.lte(0)) throw Error("tfMinusMf <= 0");
+    const numerator = tfMinusMf.times(totalSell).times(totalSell).div(supplyMinusSellLocked);
+    const denominator = tfMinusMf.times(totalSell).div(supplyMinusSellLocked).minus(totalFundRaising);
+    if (denominator.lt(0)) throw Error("supply/totalSell/totalLockedAmount diff too high");
+    const x0 = numerator.div(denominator);
+    const y0 = new BigNumber(totalFundRaising).times(totalFundRaising).div(denominator);
+    if (x0.lt(0) || y0.lt(0)) throw Error("invalid input 0");
+    return {
+      a: x0,
+      b: y0,
+      c: totalSell
+    };
+  }
+  static buyExactIn({
+    poolInfo,
+    amount
+  }) {
+    return this.getAmountOut({
+      amountIn: amount,
+      inputReserve: new BigNumber(poolInfo.virtualB).plus(poolInfo.realB),
+      outputReserve: new BigNumber(poolInfo.virtualA).minus(poolInfo.realA)
+    });
+  }
+  static buyExactOut({
+    poolInfo,
+    amount
+  }) {
+    return this.getAmountIn({
+      amountOut: amount,
+      inputReserve: new BigNumber(poolInfo.virtualB).plus(poolInfo.realB),
+      outputReserve: new BigNumber(poolInfo.virtualA).minus(poolInfo.realA)
+    });
+  }
+  static sellExactIn({
+    poolInfo,
+    amount
+  }) {
+    return this.getAmountOut({
+      amountIn: amount,
+      inputReserve: new BigNumber(poolInfo.virtualA).minus(poolInfo.realA),
+      outputReserve: new BigNumber(poolInfo.virtualB).plus(poolInfo.realB)
+    });
+  }
+  static sellExactOut({
+    poolInfo,
+    amount
+  }) {
+    return this.getAmountIn({
+      amountOut: amount,
+      inputReserve: new BigNumber(poolInfo.virtualA).minus(poolInfo.realA),
+      outputReserve: new BigNumber(poolInfo.virtualB).plus(poolInfo.realB)
+    });
+  }
+  static getAmountOut({
+    amountIn,
+    inputReserve,
+    outputReserve
+  }) {
+    const numerator = new BigNumber(amountIn).times(outputReserve);
+    const denominator = new BigNumber(inputReserve).plus(amountIn);
+    const amountOut = numerator.div(denominator);
+    return amountOut;
+  }
+  static getAmountIn({
+    amountOut,
+    inputReserve,
+    outputReserve
+  }) {
+    const numerator = new BigNumber(inputReserve).times(amountOut);
+    const denominator = new BigNumber(outputReserve).minus(amountOut);
+    const amountIn = numerator.div(denominator);
+    return amountIn;
+  }
+};
+
+// src/types.ts
+var LaunchPadPlatform = /* @__PURE__ */ ((LaunchPadPlatform2) => {
+  LaunchPadPlatform2["PUMPFUN"] = "pumpfun";
+  LaunchPadPlatform2["RAYDIUM"] = "raydium";
+  return LaunchPadPlatform2;
+})(LaunchPadPlatform || {});
+var CurveType = /* @__PURE__ */ ((CurveType2) => {
+  CurveType2["CONSTANT_PRODUCT"] = "constant_product";
+  CurveType2["FIXED_PRICE"] = "fixed_price";
+  CurveType2["LINEAR_PRICE"] = "linear_price";
+  return CurveType2;
+})(CurveType || {});
+var FixedPriceCurve = class extends BaseCurve {
+  static getPoolInitPriceByPool({
+    poolInfo,
+    decimalA,
+    decimalB
+  }) {
+    return BigNumber3(poolInfo.virtualB).div(poolInfo.virtualA).times(10 ** (decimalA - decimalB));
+  }
+  static getPoolInitPriceByInit({
+    a,
+    b,
+    decimalA,
+    decimalB
+  }) {
+    return BigNumber3(b).div(a).times(10 ** (decimalA - decimalB));
+  }
+  static getPoolPrice({
+    poolInfo,
+    decimalA,
+    decimalB
+  }) {
+    return BigNumber3(poolInfo.virtualB).div(poolInfo.virtualA).times(10 ** (decimalA - decimalB));
+  }
+  static getPoolEndPrice({
+    supply,
+    totalSell,
+    totalLockedAmount,
+    totalFundRaising,
+    migrateFee,
+    decimalA,
+    decimalB
+  }) {
+    return BigNumber3(totalFundRaising).minus(migrateFee).div(BigNumber3(supply).minus(totalSell).minus(totalLockedAmount)).times(10 ** (decimalA - decimalB));
+  }
+  static getPoolEndPriceReal({
+    poolInfo,
+    decimalA,
+    decimalB
+  }) {
+    const allSellToken = BigNumber3(poolInfo.totalSellA).minus(poolInfo.realA);
+    const buyAllTokenUseB = BigNumber3(poolInfo.totalFundRaisingB).minus(poolInfo.realB);
+    return BigNumber3(poolInfo.virtualB).plus(poolInfo.realB).plus(buyAllTokenUseB).div(BigNumber3(poolInfo.virtualA).minus(poolInfo.realA).plus(allSellToken)).times(10 ** (decimalA - decimalB));
+  }
+  static getInitParam({
+    supply,
+    totalFundRaising,
+    totalLockedAmount,
+    migrateFee
+  }) {
+    const supplyMinusLocked = BigNumber3(supply).minus(totalLockedAmount);
+    if (supplyMinusLocked.lte(0)) throw Error("invalid input 1");
+    const denominator = BigNumber3(2).times(totalFundRaising).minus(migrateFee);
+    const numerator = BigNumber3(totalFundRaising).times(supplyMinusLocked);
+    const totalSellExpect = numerator.div(denominator);
+    return { a: totalSellExpect, b: totalFundRaising, c: totalSellExpect };
+  }
+  static buyExactIn({
+    poolInfo,
+    amount
+  }) {
+    return this.getAmountOut({
+      amountIn: amount,
+      initInput: poolInfo.virtualB,
+      initOutput: poolInfo.virtualA
+    });
+  }
+  static buyExactOut({
+    poolInfo,
+    amount
+  }) {
+    return this.getAmountIn({
+      amountOut: amount,
+      initInput: poolInfo.virtualB,
+      initOutput: poolInfo.virtualA
+    });
+  }
+  static sellExactIn({
+    poolInfo,
+    amount
+  }) {
+    return this.getAmountOut({
+      amountIn: amount,
+      initInput: poolInfo.virtualA,
+      initOutput: poolInfo.virtualB
+    });
+  }
+  static sellExactOut({
+    poolInfo,
+    amount
+  }) {
+    return this.getAmountIn({
+      amountOut: amount,
+      initInput: poolInfo.virtualA,
+      initOutput: poolInfo.virtualB
+    });
+  }
+  static getAmountOut({
+    amountIn,
+    initInput,
+    initOutput
+  }) {
+    const numerator = new BigNumber3(initOutput).times(amountIn);
+    const amountOut = numerator.div(initInput);
+    return amountOut;
+  }
+  static getAmountIn({
+    amountOut,
+    initInput,
+    initOutput
+  }) {
+    const numerator = new BigNumber3(initInput).times(amountOut);
+    const amountIn = numerator.div(initOutput);
+    return amountIn;
+  }
+};
+var LinearPriceCurve = class extends BaseCurve {
+  static getPoolInitPriceByPool(args) {
+    return 0;
+  }
+  static getPoolInitPriceByInit(args) {
+    return 0;
+  }
+  static getPoolPrice({
+    poolInfo,
+    decimalA,
+    decimalB
+  }) {
+    return new BigNumber3(poolInfo.virtualA).times(poolInfo.realA).div(new BigNumber3(1).shiftedBy(-64)).times(10 ** (decimalA - decimalB));
+  }
+  static getPoolEndPrice({
+    supply,
+    totalSell,
+    totalLockedAmount,
+    totalFundRaising,
+    migrateFee,
+    decimalA,
+    decimalB
+  }) {
+    return new BigNumber3(totalFundRaising).minus(migrateFee).div(new BigNumber3(supply).minus(totalSell).minus(totalLockedAmount)).times(10 ** (decimalA - decimalB));
+  }
+  static getPoolEndPriceReal({
+    poolInfo,
+    decimalA,
+    decimalB
+  }) {
+    const allSellToken = new BigNumber3(poolInfo.totalSellA).minus(poolInfo.realA);
+    const buyAllTokenUseB = new BigNumber3(poolInfo.totalFundRaisingB).minus(poolInfo.realB);
+    return new BigNumber3(poolInfo.virtualB).plus(poolInfo.realB).plus(buyAllTokenUseB).div(new BigNumber3(poolInfo.virtualA).minus(poolInfo.realA).minus(allSellToken)).times(10 ** (decimalA - decimalB));
+  }
+  static getInitParam({
+    supply,
+    totalFundRaising,
+    totalLockedAmount,
+    migrateFee
+  }) {
+    const supplyMinusLocked = new BigNumber3(supply).minus(totalLockedAmount);
+    if (supplyMinusLocked.lte(0)) throw Error("supplyMinusLocked need gt 0");
+    const denominator = new BigNumber3(totalFundRaising).times(3).minus(migrateFee);
+    const numerator = new BigNumber3(totalFundRaising).times(2).minus(supplyMinusLocked);
+    const totalSellExpect = numerator.div(denominator);
+    const totalSellSquared = totalSellExpect.times(totalSellExpect);
+    const a = new BigNumber3(totalFundRaising).times(2).times(new BigNumber3(1).shiftedBy(-64)).div(totalSellSquared);
+    if (!a.gt(0)) throw Error("a need gt 0");
+    const MaxU64 = new BigNumber3(1).shiftedBy(-64).minus(1);
+    if (!MaxU64.gt(a)) throw Error("a need lt u64 max");
+    return { a, b: 0, c: totalSellExpect };
+  }
+  static buyExactIn({
+    poolInfo,
+    amount
+  }) {
+    const newQuote = new BigNumber3(poolInfo.realB).plus(amount);
+    const termInsideSqrt = new BigNumber3(2).times(newQuote).times(new BigNumber3(1).shiftedBy(-64)).div(poolInfo.virtualA);
+    const sqrtTerm = new BigNumber3(new BigNumber3(termInsideSqrt).sqrt().toFixed(0));
+    const amountOut = sqrtTerm.minus(poolInfo.realA);
+    return amountOut;
+  }
+  static buyExactOut({
+    poolInfo,
+    amount
+  }) {
+    const newBase = new BigNumber3(poolInfo.realA).plus(amount);
+    const newBaseSquared = newBase.times(newBase);
+    const newQuote = new BigNumber3(poolInfo.virtualA).times(newBaseSquared).div(new BigNumber3(2).times(new BigNumber3(1).shiftedBy(-64)));
+    return newQuote.minus(poolInfo.realB);
+  }
+  static sellExactIn({
+    poolInfo,
+    amount
+  }) {
+    const newBase = new BigNumber3(poolInfo.realA).minus(amount);
+    const newBaseSquared = newBase.times(newBase);
+    const newQuote = new BigNumber3(poolInfo.virtualA).times(newBaseSquared).div(new BigNumber3(2).times(new BigNumber3(1).shiftedBy(-64)));
+    return new BigNumber3(poolInfo.realB).minus(newQuote);
+  }
+  static sellExactOut({
+    poolInfo,
+    amount
+  }) {
+    const newB = new BigNumber3(poolInfo.realB).minus(amount);
+    const termInsideSqrt = new BigNumber3(2).times(newB).times(new BigNumber3(1).shiftedBy(-64)).div(poolInfo.virtualA);
+    const sqrtTerm = new BigNumber3(new BigNumber3(termInsideSqrt).sqrt().toFixed(0));
+    const amountIn = new BigNumber3(poolInfo.realA).minus(sqrtTerm);
+    return amountIn;
+  }
+};
+
+// src/curve/Curve.ts
+var Curve = class _Curve {
+  static getCurvePreviewPoints({
+    curveType,
+    pointCount,
+    poolInfo
+  }) {
+    return this.getPoolCurvePointByInit({
+      curveType,
+      pointCount,
+      supply: poolInfo.supply,
+      totalFundRaising: poolInfo.totalFundRaisingB,
+      totalSell: poolInfo.totalSellA,
+      totalLockedAmount: poolInfo.vestingSchedule.totalLockedAmount,
+      migrateFee: poolInfo.migrateFee,
+      decimalA: poolInfo.mintDecimalsA,
+      decimalB: poolInfo.mintDecimalsB
+    });
+  }
+  static getPoolCurvePointByInit({
+    curveType,
+    pointCount,
+    supply,
+    totalFundRaising,
+    totalSell,
+    totalLockedAmount,
+    migrateFee,
+    decimalA,
+    decimalB
+  }) {
+    if (pointCount < 3) throw Error("point count < 3");
+    const curve = this.getCurve(curveType);
+    const { a, b } = curve.getInitParam({
+      supply,
+      totalFundRaising,
+      totalSell,
+      totalLockedAmount,
+      migrateFee
+    });
+    const initPrice = curve.getPoolInitPriceByInit({ a, b, decimalA, decimalB });
+    const stepBuy = new BigNumber3(totalFundRaising).div(pointCount - 1);
+    const zero = new BigNumber3(0);
+    const returnPoints = [{ price: initPrice, totalSellSupply: 0 }];
+    let realA = zero;
+    let realB = zero;
+    for (let i = 1; i < pointCount; i++) {
+      const amountB = i !== pointCount - 1 ? stepBuy : new BigNumber3(totalFundRaising).minus(realB);
+      const itemBuy = this.buyExactIn({
+        poolInfo: {
+          virtualA: a,
+          virtualB: b,
+          realA,
+          realB,
+          totalFundRaisingB: totalFundRaising,
+          totalSellA: totalSell
+        },
+        amountB,
+        protocolFeeRate: zero,
+        platformFeeRate: zero,
+        curveType,
+        shareFeeRate: zero
+      });
+      realA = realA.plus(itemBuy.amountA);
+      realB = realB.plus(itemBuy.amountB);
+      const nowPoolPrice = this.getPrice({
+        poolInfo: { virtualA: a, virtualB: b, realA, realB },
+        decimalA,
+        decimalB,
+        curveType
+      });
+      returnPoints.push({
+        price: nowPoolPrice,
+        totalSellSupply: new BigNumber3(realA).div(10 ** decimalA).toNumber()
+      });
+    }
+    return returnPoints;
+  }
+  static getPoolInitPriceByPool({
+    poolInfo,
+    decimalA,
+    decimalB,
+    curveType
+  }) {
+    const curve = this.getCurve(curveType);
+    return curve.getPoolInitPriceByPool({ poolInfo, decimalA, decimalB });
+  }
+  static getPoolInitPriceByInit({
+    a,
+    b,
+    decimalA,
+    decimalB,
+    curveType
+  }) {
+    const curve = this.getCurve(curveType);
+    return curve.getPoolInitPriceByInit({ a, b, decimalA, decimalB });
+  }
+  static getPrice({
+    poolInfo,
+    curveType,
+    decimalA,
+    decimalB
+  }) {
+    const curve = this.getCurve(curveType);
+    return curve.getPoolPrice({ poolInfo, decimalA, decimalB });
+  }
+  static getEndPrice({
+    poolInfo,
+    curveType,
+    decimalA,
+    decimalB
+  }) {
+    const curve = this.getCurve(curveType);
+    return curve.getPoolPrice({ poolInfo, decimalA, decimalB });
+  }
+  static getPoolEndPriceReal({
+    poolInfo,
+    curveType,
+    decimalA,
+    decimalB
+  }) {
+    const curve = this.getCurve(curveType);
+    return curve.getPoolEndPriceReal({ poolInfo, decimalA, decimalB });
+  }
+  static checkParam({
+    supply,
+    totalFundRaising,
+    totalSell,
+    totalLockedAmount,
+    decimalsA,
+    decimalsB,
+    config,
+    migrateType
+  }) {
+    const supplyBn = new BigNumber3(supply);
+    if (decimalsA !== config.decimals) throw Error(`decimals should be ${config.decimals}`);
+    if (supplyBn.times(config.maxLockRate).lt(totalLockedAmount))
+      throw Error("totalLockedAmount exceeds max lock amount");
+    if (new BigNumber3(config.minSupplyA).shiftedBy(decimalsA).gte(supply))
+      throw Error("supply less than min supply");
+    if (supplyBn.times(config.minSellRateA).gte(totalSell))
+      throw Error("totalSell less than min sell");
+    if (new BigNumber3(config.minFundRaisingB).shiftedBy(decimalsB).gte(totalFundRaising))
+      throw Error("totalFundRaising less than min fund raising");
+    const migrateAmountBn = supplyBn.minus(totalSell).minus(totalLockedAmount);
+    if (migrateAmountBn.lt(supplyBn.times(config.minMigrateRateA)))
+      throw Error("migrateAmount less than min migrate amount");
+    const liquidity = migrateAmountBn.times(totalFundRaising).sqrt();
+    if (migrateType === "amm") {
+      if (liquidity.shiftedBy(-decimalsA).lte(1)) throw Error("insufficient liquidity");
+    } else if (migrateType === "cpmm") {
+      if (liquidity.lte(100)) throw Error("insufficient liquidity");
+    } else {
+      throw Error("invalid migrateType");
+    }
+  }
+  static buyExactIn({
+    poolInfo,
+    amountB,
+    protocolFeeRate,
+    platformFeeRate,
+    curveType,
+    shareFeeRate
+  }) {
+    const feeRate = new BigNumber3(protocolFeeRate).plus(shareFeeRate).plus(platformFeeRate);
+    const _totalFee = this.calculateFee({ amount: amountB, feeRate });
+    const amountLessFeeB = new BigNumber3(amountB).minus(_totalFee);
+    const curve = this.getCurve(curveType);
+    const _amountA = curve.buyExactIn({ poolInfo, amount: amountLessFeeB });
+    const remainingAmountA = new BigNumber3(poolInfo.totalSellA).minus(poolInfo.realA);
+    let amountA;
+    let realAmountB;
+    let totalFee;
+    if (remainingAmountA.lte(_amountA)) {
+      amountA = remainingAmountA;
+      const amountLessFeeB2 = curve.buyExactOut({
+        poolInfo,
+        amount: amountA
+      });
+      realAmountB = this.calculatePreFee({ postFeeAmount: amountLessFeeB2, feeRate });
+      totalFee = new BigNumber3(realAmountB).minus(amountLessFeeB2);
+    } else {
+      amountA = _amountA;
+      realAmountB = amountB;
+      totalFee = _totalFee;
+    }
+    const splitFee = this.splitFee({ totalFee, protocolFeeRate, platformFeeRate, shareFeeRate });
+    return { amountA, amountB: realAmountB, splitFee };
+  }
+  static buyExactOut({
+    poolInfo,
+    amountA,
+    protocolFeeRate,
+    platformFeeRate,
+    curveType,
+    shareFeeRate
+  }) {
+    const remainingAmountA = new BigNumber3(poolInfo.totalSellA).minus(poolInfo.realA);
+    let realAmountA = amountA;
+    if (remainingAmountA.lte(amountA)) {
+      realAmountA = remainingAmountA;
+    }
+    const curve = this.getCurve(curveType);
+    const amountInLessFeeB = curve.buyExactOut({ poolInfo, amount: amountA });
+    const totalFeeRate = new BigNumber3(protocolFeeRate).plus(shareFeeRate).plus(platformFeeRate);
+    const amountB = this.calculatePreFee({
+      postFeeAmount: amountInLessFeeB,
+      feeRate: totalFeeRate
+    });
+    const totalFee = new BigNumber3(amountB).minus(amountInLessFeeB);
+    const splitFee = this.splitFee({ totalFee, protocolFeeRate, platformFeeRate, shareFeeRate });
+    return { amountA: realAmountA, amountB, splitFee };
+  }
+  static sellExactIn({
+    poolInfo,
+    amountA,
+    protocolFeeRate,
+    platformFeeRate,
+    curveType,
+    shareFeeRate
+  }) {
+    const curve = this.getCurve(curveType);
+    const amountB = curve.sellExactIn({ poolInfo, amount: amountA });
+    const totalFee = this.calculateFee({
+      amount: amountB,
+      feeRate: new BigNumber3(protocolFeeRate).plus(shareFeeRate).plus(platformFeeRate)
+    });
+    const splitFee = this.splitFee({ totalFee, protocolFeeRate, platformFeeRate, shareFeeRate });
+    return { amountA, amountB: new BigNumber3(amountB).minus(totalFee), splitFee };
+  }
+  static sellExactOut({
+    poolInfo,
+    amountB,
+    protocolFeeRate,
+    platformFeeRate,
+    curveType,
+    shareFeeRate
+  }) {
+    const totalFeeRate = new BigNumber3(protocolFeeRate).plus(shareFeeRate).plus(platformFeeRate);
+    const amountOutWithFeeB = this.calculatePreFee({
+      postFeeAmount: amountB,
+      feeRate: totalFeeRate
+    });
+    if (new BigNumber3(poolInfo.realB).lt(amountOutWithFeeB)) throw Error("Insufficient liquidity");
+    const totalFee = new BigNumber3(amountOutWithFeeB).minus(amountB);
+    const curve = _Curve.getCurve(curveType);
+    const amountA = curve.sellExactOut({ poolInfo, amount: amountOutWithFeeB });
+    if (new BigNumber3(amountA).gt(poolInfo.realA)) throw Error("Insufficient liquidity");
+    const splitFee = this.splitFee({ totalFee, protocolFeeRate, platformFeeRate, shareFeeRate });
+    return { amountA, amountB, splitFee };
+  }
+  static splitFee({
+    totalFee,
+    protocolFeeRate,
+    platformFeeRate,
+    shareFeeRate
+  }) {
+    const totalFeeBn = new BigNumber3(totalFee);
+    const totalFeeRate = new BigNumber3(protocolFeeRate).plus(platformFeeRate).plus(shareFeeRate);
+    const platformFee = totalFeeRate.isZero() ? new BigNumber3(0) : totalFeeBn.times(platformFeeRate).div(totalFeeRate);
+    const shareFee = totalFeeRate.isZero() ? new BigNumber3(0) : totalFeeBn.times(shareFeeRate).div(totalFeeRate);
+    const protocolFee = totalFeeBn.minus(platformFee).minus(shareFee);
+    return { platformFee, shareFee, protocolFee };
+  }
+  static calculateFee({
+    amount,
+    feeRate
+  }) {
+    return new BigNumber3(amount).times(feeRate);
+  }
+  static calculatePreFee({
+    postFeeAmount,
+    feeRate
+  }) {
+    if (new BigNumber3(feeRate).isZero()) return postFeeAmount;
+    return new BigNumber3(postFeeAmount).div(new BigNumber3(feeRate).plus(1));
+  }
+  static getCurve(curveType) {
+    switch (curveType) {
+      case "constant_product" /* CONSTANT_PRODUCT */:
+        return ConstantProductCurve;
+      case "fixed_price" /* FIXED_PRICE */:
+        return FixedPriceCurve;
+      case "linear_price" /* LINEAR_PRICE */:
+        return LinearPriceCurve;
+    }
+  }
+};
+
+// src/create-token-runtime.ts
+function validateCreateTokenIntent(intent) {
+  if (!intent.name.trim()) throw new Error("name required");
+  if (!intent.symbol.trim()) throw new Error("symbol required");
+  if (intent.symbol.length > 12) throw new Error("symbol too long");
+}
+function createLaunchpadCreateRuntime(options) {
+  let current = { status: "idle" };
+  const set = (next) => {
+    current = next;
+    options.onChange?.(next);
+    return next;
+  };
+  return {
+    snapshot() {
+      return current;
+    },
+    async submit(intent) {
+      set({ status: "validating", intent });
+      try {
+        validateCreateTokenIntent(intent);
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        return set({ status: "failed", intent, error: err });
+      }
+      let imageUri = intent.imageUri ?? "";
+      if (options.upload) {
+        set({ status: "uploading", intent });
+        try {
+          imageUri = await options.upload.upload(intent);
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          return set({ status: "failed", intent, error: err });
+        }
+      }
+      if (!options.signer) {
+        return set({
+          status: "rejected",
+          intent,
+          error: new Error("missing signer")
+        });
+      }
+      set({ status: "signing", intent: { ...intent, imageUri } });
+      let signed;
+      try {
+        signed = await options.signer.sign(imageUri || intent.symbol);
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        return set({ status: "rejected", intent, error: err });
+      }
+      set({ status: "submitting", intent });
+      try {
+        const result = await options.execution.submit(signed, intent);
+        return set({ status: "succeeded", intent, txHash: result.txHash });
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        return set({ status: "failed", intent, error: err });
+      }
+    }
+  };
+}
+
+// src/in-memory-launchpad-adapter.ts
+function createInMemoryLaunchpadPorts(options = {}) {
+  return {
+    upload: {
+      async upload() {
+        if (options.uploadError) throw options.uploadError;
+        return "ipfs://memory";
+      }
+    },
+    signer: {
+      async sign(payload) {
+        if (options.signError) throw options.signError;
+        return `signed:${payload}`;
+      }
+    },
+    execution: {
+      async submit() {
+        if (options.timeout) throw new Error("submit timeout");
+        if (options.submitError) throw options.submitError;
+        return { txHash: "tx-memory" };
+      }
+    }
+  };
+}
+
+// src/index.ts
+var PACKAGE_NAME = "@liberfi.io/react-launchpad";
+var ReadyContext = createContext(true);
+function LaunchpadProvider({ children }) {
+  return createElement(ReadyContext.Provider, { value: true }, children);
+}
+function useLaunchpadReady() {
+  return useContext(ReadyContext);
+}
+
+export { BaseCurve, ConstantProductCurve, Curve, CurveType, FixedPriceCurve, LaunchPadPlatform, LaunchpadProvider, LinearPriceCurve, PACKAGE_NAME, createInMemoryLaunchpadPorts, createLaunchpadCreateRuntime, useLaunchpadReady, validateCreateTokenIntent };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map