@masterpeach/launchpad-sdk 0.0.0-experimental-20260818121657

package/dist/index.cjs

@@ -0,0 +1,4420 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BPS: () => BPS,
+  DEFAULT_DEADLINE_SECONDS: () => DEFAULT_DEADLINE_SECONDS,
+  ForgedPreparedTransactionError: () => ForgedPreparedTransactionError,
+  InvalidDeadlineError: () => InvalidDeadlineError,
+  InvalidLaunchpadChainConfigError: () => InvalidLaunchpadChainConfigError,
+  InvalidLaunchpadDeploymentError: () => InvalidLaunchpadDeploymentError,
+  InvalidLaunchpadReadInputError: () => InvalidLaunchpadReadInputError,
+  InvalidLaunchpadStateError: () => InvalidLaunchpadStateError,
+  InvalidSlippageError: () => InvalidSlippageError,
+  LaunchpadApprovalRequiredError: () => LaunchpadApprovalRequiredError,
+  LaunchpadDeadlineExpiredError: () => LaunchpadDeadlineExpiredError,
+  LaunchpadDeploymentVerificationError: () => LaunchpadDeploymentVerificationError,
+  LaunchpadError: () => LaunchpadError,
+  LaunchpadInsufficientBalanceError: () => LaunchpadInsufficientBalanceError,
+  LaunchpadNothingToClaimError: () => LaunchpadNothingToClaimError,
+  LaunchpadOfficialPoolLockedError: () => LaunchpadOfficialPoolLockedError,
+  LaunchpadPhaseUnavailableError: () => LaunchpadPhaseUnavailableError,
+  LaunchpadProtectionError: () => LaunchpadProtectionError,
+  LaunchpadSlippageError: () => LaunchpadSlippageError,
+  LaunchpadTradingPausedError: () => LaunchpadTradingPausedError,
+  LaunchpadUnknownPositionError: () => LaunchpadUnknownPositionError,
+  MAX_PROTECTION_BLOCKS: () => MAX_PROTECTION_BLOCKS,
+  MAX_SLIPPAGE_BPS: () => MAX_SLIPPAGE_BPS,
+  MissingWalletClientError: () => MissingWalletClientError,
+  PRICE_WAD_SCALE: () => PRICE_WAD_SCALE,
+  PreparedAccountMismatchError: () => PreparedAccountMismatchError,
+  TRADE_FEE_BPS: () => TRADE_FEE_BPS,
+  UnpinnableBlockTagError: () => UnpinnableBlockTagError,
+  UnsupportedLaunchpadCapabilityError: () => UnsupportedLaunchpadCapabilityError,
+  WrongWalletChainError: () => WrongWalletChainError,
+  applySlippageToMinimumOut: () => applySlippageToMinimumOut,
+  arcTestnetChainId: () => arcTestnetChainId,
+  arcTestnetLaunchpadDeployment: () => arcTestnetLaunchpadDeployment,
+  assertSlippage: () => assertSlippage,
+  buyPriceImpactBps: () => buyPriceImpactBps,
+  createLaunchpadClient: () => createLaunchpadClient,
+  createLaunchpadPortalClient: () => createLaunchpadPortalClient,
+  createdTokenAddress: () => createdTokenAddress,
+  creatorFirstBuyFee: () => creatorFirstBuyFee,
+  curvePriceWadAt: () => curvePriceWadAt,
+  defineLaunchpadChain: () => defineLaunchpadChain,
+  defineLaunchpadDeployment: () => defineLaunchpadDeployment,
+  defineLaunchpadDeploymentRegistry: () => defineLaunchpadDeploymentRegistry,
+  defineLaunchpadTokenId: () => defineLaunchpadTokenId,
+  firstTradableBlock: () => firstTradableBlock,
+  getClaimableLaunchpadReward: () => getClaimableLaunchpadReward,
+  getErc20Allowance: () => getErc20Allowance,
+  getErc20Balance: () => getErc20Balance,
+  getErc20Metadata: () => getErc20Metadata,
+  getLaunchpadApprovalStatus: () => getLaunchpadApprovalStatus,
+  getLaunchpadCurveConstants: () => getLaunchpadCurveConstants,
+  getLaunchpadCurveProgress: () => getLaunchpadCurveProgress,
+  getLaunchpadPrice: () => getLaunchpadPrice,
+  getLaunchpadTokenMetadata: () => getLaunchpadTokenMetadata,
+  getLaunchpadTokenState: () => getLaunchpadTokenState,
+  getLaunchpadTradeAvailability: () => getLaunchpadTradeAvailability,
+  getLockedLaunchpadPosition: () => getLockedLaunchpadPosition,
+  graduationMarketCapQuote: () => graduationMarketCapQuote,
+  graduationProgress: () => graduationProgress,
+  initialCurveState: () => initialCurveState,
+  isLaunchBlockTradingDisabled: () => isLaunchBlockTradingDisabled,
+  launchpadDeploymentRegistry: () => launchpadDeploymentRegistry,
+  marketCapQuote: () => marketCapQuote,
+  mulDivUp: () => mulDivUp,
+  parseLaunchpadMetadata: () => parseLaunchpadMetadata,
+  parseLaunchpadReceiptEvents: () => parseLaunchpadReceiptEvents,
+  predictLaunchpadTokenAddress: () => predictLaunchpadTokenAddress,
+  prepareApproveErc20: () => prepareApproveErc20,
+  prepareClaimLaunchpadReward: () => prepareClaimLaunchpadReward,
+  prepareCollectLaunchpadFees: () => prepareCollectLaunchpadFees,
+  prepareCreateToken: () => prepareCreateToken,
+  prepareLaunchpadBuy: () => prepareLaunchpadBuy,
+  prepareLaunchpadMigration: () => prepareLaunchpadMigration,
+  prepareLaunchpadSell: () => prepareLaunchpadSell,
+  priceImpactBps: () => priceImpactBps,
+  priceWadPerWholeToken: () => priceWadPerWholeToken,
+  quoteCreatorFirstBuy: () => quoteCreatorFirstBuy,
+  quoteLaunchpadBuy: () => quoteLaunchpadBuy,
+  quoteLaunchpadSell: () => quoteLaunchpadSell,
+  resolveLaunchpadDeployment: () => resolveLaunchpadDeployment,
+  resolvePinnedBlockNumber: () => resolvePinnedBlockNumber,
+  revertErrorName: () => revertErrorName,
+  sellPriceImpactBps: () => sellPriceImpactBps,
+  sendPreparedLaunchpadTransaction: () => sendPreparedLaunchpadTransaction,
+  toCreatorFirstBuyQuote: () => toCreatorFirstBuyQuote,
+  toDeadline: () => toDeadline,
+  toLaunchpadError: () => toLaunchpadError,
+  toLaunchpadPauseMode: () => toLaunchpadPauseMode,
+  toLaunchpadPhase: () => toLaunchpadPhase,
+  toLaunchpadTokenState: () => toLaunchpadTokenState,
+  toLaunchpadTradeAvailability: () => toLaunchpadTradeAvailability,
+  tradeFee: () => tradeFee,
+  tradeFeeBpsAt: () => tradeFeeBpsAt,
+  verifyLaunchpadDeployment: () => verifyLaunchpadDeployment,
+  waitForLaunchpadTransaction: () => waitForLaunchpadTransaction
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/actions/read.ts
+var import_viem2 = require("viem");
+
+// src/abi/generated/constant-product-curve.ts
+var constantProductCurveAbi = [
+  {
+    type: "function",
+    name: "quoteBuy",
+    inputs: [
+      {
+        name: "state",
+        type: "tuple",
+        internalType: "struct ICurve.State",
+        components: [
+          {
+            name: "totalSupply",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "circulatingSupply",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "quoteReserve",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "virtualTokenReserve",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "virtualQuoteReserve",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "k",
+            type: "uint256",
+            internalType: "uint256"
+          }
+        ]
+      },
+      {
+        name: "quoteIn",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "tokenOut",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "pure"
+  },
+  {
+    type: "function",
+    name: "quoteBuyExactOut",
+    inputs: [
+      {
+        name: "state",
+        type: "tuple",
+        internalType: "struct ICurve.State",
+        components: [
+          {
+            name: "totalSupply",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "circulatingSupply",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "quoteReserve",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "virtualTokenReserve",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "virtualQuoteReserve",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "k",
+            type: "uint256",
+            internalType: "uint256"
+          }
+        ]
+      },
+      {
+        name: "tokenOut",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "quoteIn",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "pure"
+  },
+  {
+    type: "function",
+    name: "quoteSell",
+    inputs: [
+      {
+        name: "state",
+        type: "tuple",
+        internalType: "struct ICurve.State",
+        components: [
+          {
+            name: "totalSupply",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "circulatingSupply",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "quoteReserve",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "virtualTokenReserve",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "virtualQuoteReserve",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "k",
+            type: "uint256",
+            internalType: "uint256"
+          }
+        ]
+      },
+      {
+        name: "tokenIn",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "quoteOut",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "pure"
+  },
+  {
+    type: "error",
+    name: "InvalidAmount",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InvalidState",
+    inputs: []
+  }
+];
+
+// src/abi/generated/liquidity-locker.ts
+var liquidityLockerAbi = [
+  {
+    type: "constructor",
+    inputs: [
+      {
+        name: "owner_",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "positionManager_",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "platformTreasury_",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "BPS",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint16",
+        internalType: "uint16"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "MAX_PLATFORM_FEE_BPS",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint16",
+        internalType: "uint16"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "acceptOwnership",
+    inputs: [],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "claim",
+    inputs: [
+      {
+        name: "asset",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "recipient",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "collectFees",
+    inputs: [
+      {
+        name: "tokenId",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "amount0",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "amount1",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "creditMigrationDust",
+    inputs: [
+      {
+        name: "asset",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "creator",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "platformBps",
+        type: "uint16",
+        internalType: "uint16"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "migrators",
+    inputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "onERC721Received",
+    inputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "",
+        type: "bytes",
+        internalType: "bytes"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bytes4",
+        internalType: "bytes4"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "owner",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "pendingOwner",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "pendingRewards",
+    inputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "platformTreasury",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "positionManager",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "positions",
+    inputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "token0",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "token1",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "creator",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "platformFeeBps",
+        type: "uint16",
+        internalType: "uint16"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "registerPosition",
+    inputs: [
+      {
+        name: "tokenId",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "token0",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "token1",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "creator",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "platformFeeBps",
+        type: "uint16",
+        internalType: "uint16"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setMigrator",
+    inputs: [
+      {
+        name: "migrator",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "allowed",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setPlatformTreasury",
+    inputs: [
+      {
+        name: "treasury",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "transferOwnership",
+    inputs: [
+      {
+        name: "newOwner",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "FeesCollected",
+    inputs: [
+      {
+        name: "tokenId",
+        type: "uint256",
+        indexed: true,
+        internalType: "uint256"
+      },
+      {
+        name: "amount0",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "amount1",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "MigrationDustCredited",
+    inputs: [
+      {
+        name: "creator",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "asset",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "MigratorSet",
+    inputs: [
+      {
+        name: "migrator",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "allowed",
+        type: "bool",
+        indexed: false,
+        internalType: "bool"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "OwnershipTransferStarted",
+    inputs: [
+      {
+        name: "owner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "pendingOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "OwnershipTransferred",
+    inputs: [
+      {
+        name: "oldOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "newOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "PlatformTreasurySet",
+    inputs: [
+      {
+        name: "treasury",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "PositionLocked",
+    inputs: [
+      {
+        name: "tokenId",
+        type: "uint256",
+        indexed: true,
+        internalType: "uint256"
+      },
+      {
+        name: "creator",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "platformFeeBps",
+        type: "uint16",
+        indexed: false,
+        internalType: "uint16"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "RewardsClaimed",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "asset",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "recipient",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "error",
+    name: "InvalidConfig",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "NothingToClaim",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "PositionAlreadyRegistered",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "TransferFailed",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "Unauthorized",
+    inputs: []
+  }
+];
+
+// src/abi/generated/portal.ts
+var portalAbi = [
+  {
+    type: "constructor",
+    inputs: [
+      {
+        name: "owner_",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "factory_",
+        type: "address",
+        internalType: "contract TokenFactory"
+      },
+      {
+        name: "quoteToken_",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "lpRecipient_",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "BPS",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "CURVE_K",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "DEFAULT_CURVE_ID",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint16",
+        internalType: "uint16"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "DEFAULT_MIGRATOR_ID",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint16",
+        internalType: "uint16"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "DEFAULT_PROTECTION_BLOCKS",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint8",
+        internalType: "uint8"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "DEX_SUPPLY_THRESHOLD",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "MAX_PROTECTION_BLOCKS",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint8",
+        internalType: "uint8"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "PLATFORM_LP_FEE_BPS",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint16",
+        internalType: "uint16"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "TOTAL_SUPPLY",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "TRADE_FEE_BPS",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint16",
+        internalType: "uint16"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "VIRTUAL_QUOTE_RESERVE",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "VIRTUAL_TOKEN_RESERVE",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "acceptOwnership",
+    inputs: [],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "buy",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "quoteIn",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "minTokenOut",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "deadline",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "tokenOut",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "quoteSpent",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "createToken",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        internalType: "struct Portal.CreateParams",
+        components: [
+          {
+            name: "name",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "symbol",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "metadata",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "userSalt",
+            type: "bytes32",
+            internalType: "bytes32"
+          }
+        ]
+      },
+      {
+        name: "initialQuoteIn",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "minInitialTokenOut",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "deadline",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "createTokenV2",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        internalType: "struct Portal.CreateParams",
+        components: [
+          {
+            name: "name",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "symbol",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "metadata",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "userSalt",
+            type: "bytes32",
+            internalType: "bytes32"
+          }
+        ]
+      },
+      {
+        name: "initialQuoteIn",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "minInitialTokenOut",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "deadline",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "protectionBlocks",
+        type: "uint8",
+        internalType: "uint8"
+      }
+    ],
+    outputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "creatorNonces",
+    inputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "curves",
+    inputs: [
+      {
+        name: "",
+        type: "uint16",
+        internalType: "uint16"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getTokenState",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct Portal.TokenState",
+        components: [
+          {
+            name: "status",
+            type: "uint8",
+            internalType: "enum Portal.Status"
+          },
+          {
+            name: "tokenVersion",
+            type: "uint16",
+            internalType: "uint16"
+          },
+          {
+            name: "curveId",
+            type: "uint16",
+            internalType: "uint16"
+          },
+          {
+            name: "migratorId",
+            type: "uint16",
+            internalType: "uint16"
+          },
+          {
+            name: "quoteReserve",
+            type: "uint128",
+            internalType: "uint128"
+          },
+          {
+            name: "circulatingSupply",
+            type: "uint128",
+            internalType: "uint128"
+          },
+          {
+            name: "creator",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "dexPool",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "launchBlock",
+            type: "uint64",
+            internalType: "uint64"
+          },
+          {
+            name: "protectionBlocks",
+            type: "uint8",
+            internalType: "uint8"
+          },
+          {
+            name: "pauseMode",
+            type: "uint8",
+            internalType: "uint8"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "lpRecipient",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "metadata",
+    inputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "string",
+        internalType: "string"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "migrate",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "pool",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "migrators",
+    inputs: [
+      {
+        name: "",
+        type: "uint16",
+        internalType: "uint16"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "owner",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "paused",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "pendingOwner",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "priceWad",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "protocolFees",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "quoteBuy",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "quoteIn",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "tokenOut",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "quoteSpent",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "fee",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "reachesThreshold",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "quoteSell",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "tokenIn",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "quoteOut",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "fee",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "quoteToken",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "registerCurve",
+    inputs: [
+      {
+        name: "id",
+        type: "uint16",
+        internalType: "uint16"
+      },
+      {
+        name: "curve",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "registerMigrator",
+    inputs: [
+      {
+        name: "id",
+        type: "uint16",
+        internalType: "uint16"
+      },
+      {
+        name: "migrator",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "sell",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "tokenIn",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "minQuoteOut",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "deadline",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "quoteOut",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setPaused",
+    inputs: [
+      {
+        name: "paused_",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setTokenPause",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "mode",
+        type: "uint8",
+        internalType: "uint8"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "tokenFactory",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "contract TokenFactory"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "transferOwnership",
+    inputs: [
+      {
+        name: "newOwner",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "withdrawProtocolFees",
+    inputs: [
+      {
+        name: "recipient",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "CurveRegistered",
+    inputs: [
+      {
+        name: "id",
+        type: "uint16",
+        indexed: true,
+        internalType: "uint16"
+      },
+      {
+        name: "curve",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "MigrationCompleted",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "pool",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "liquidity",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "lpRecipient",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "MigrationStarted",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "tokenAmount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "quoteAmount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "MigratorRegistered",
+    inputs: [
+      {
+        name: "id",
+        type: "uint16",
+        indexed: true,
+        internalType: "uint16"
+      },
+      {
+        name: "migrator",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "OwnershipTransferStarted",
+    inputs: [
+      {
+        name: "currentOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "pendingOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "OwnershipTransferred",
+    inputs: [
+      {
+        name: "previousOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "newOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Paused",
+    inputs: [
+      {
+        name: "paused",
+        type: "bool",
+        indexed: false,
+        internalType: "bool"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "ProtocolFeesWithdrawn",
+    inputs: [
+      {
+        name: "recipient",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "TokenCreated",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "creator",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "name",
+        type: "string",
+        indexed: false,
+        internalType: "string"
+      },
+      {
+        name: "symbol",
+        type: "string",
+        indexed: false,
+        internalType: "string"
+      },
+      {
+        name: "metadata",
+        type: "string",
+        indexed: false,
+        internalType: "string"
+      },
+      {
+        name: "curveId",
+        type: "uint16",
+        indexed: false,
+        internalType: "uint16"
+      },
+      {
+        name: "migratorId",
+        type: "uint16",
+        indexed: false,
+        internalType: "uint16"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "TokenPauseSet",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "mode",
+        type: "uint8",
+        indexed: false,
+        internalType: "uint8"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Trade",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "trader",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "isBuy",
+        type: "bool",
+        indexed: true,
+        internalType: "bool"
+      },
+      {
+        name: "tokenAmount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "quoteAmount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "fee",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "error",
+    name: "AccountingOverflow",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "DeadlineExpired",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InvalidAmount",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InvalidConfig",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InvalidStatus",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "LaunchBlockTradingDisabled",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "ProtocolPaused",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "Reentrancy",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "SlippageExceeded",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "TransferFailed",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "Unauthorized",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "UnknownModule",
+    inputs: []
+  }
+];
+
+// src/abi/generated/token-factory.ts
+var tokenFactoryAbi = [
+  {
+    type: "constructor",
+    inputs: [
+      {
+        name: "owner_",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "create",
+    inputs: [
+      {
+        name: "name",
+        type: "string",
+        internalType: "string"
+      },
+      {
+        name: "symbol",
+        type: "string",
+        internalType: "string"
+      },
+      {
+        name: "supply",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "salt",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "owner",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "portal",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "predictAddress",
+    inputs: [
+      {
+        name: "name",
+        type: "string",
+        internalType: "string"
+      },
+      {
+        name: "symbol",
+        type: "string",
+        internalType: "string"
+      },
+      {
+        name: "supply",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "salt",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [
+      {
+        name: "predicted",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "setPortal",
+    inputs: [
+      {
+        name: "portal_",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "error",
+    name: "PortalAlreadySet",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "Unauthorized",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "ZeroAddress",
+    inputs: []
+  }
+];
+
+// src/abi/generated/v3-migrator.ts
+var v3MigratorAbi = [
+  {
+    type: "constructor",
+    inputs: [
+      {
+        name: "portal_",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "factory_",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "positionManager_",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "fee_",
+        type: "uint24",
+        internalType: "uint24"
+      },
+      {
+        name: "locker_",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "SQRT_RATIO_TOKEN0_LOWER_X96",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint160",
+        internalType: "uint160"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "SQRT_RATIO_TOKEN0_UPPER_X96",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint160",
+        internalType: "uint160"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "TOKEN0_TICK_LOWER",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "int24",
+        internalType: "int24"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "TOKEN0_TICK_UPPER",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "int24",
+        internalType: "int24"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "encodeSqrtRatioX96",
+    inputs: [
+      {
+        name: "amount1",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "amount0",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint160",
+        internalType: "uint160"
+      }
+    ],
+    stateMutability: "pure"
+  },
+  {
+    type: "function",
+    name: "factory",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "fee",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint24",
+        internalType: "uint24"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "locker",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "migrate",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "quoteToken",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "tokenAmount",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "quoteAmount",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "lpRecipient",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "data",
+        type: "bytes",
+        internalType: "bytes"
+      }
+    ],
+    outputs: [
+      {
+        name: "pool",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "liquidityOut",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "portal",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "positionManager",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "preparePool",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "quoteToken",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "graduationPriceWad",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "pool",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "MigrationDust",
+    inputs: [
+      {
+        name: "asset",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "recipient",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "PositionMinted",
+    inputs: [
+      {
+        name: "pool",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "tokenId",
+        type: "uint256",
+        indexed: true,
+        internalType: "uint256"
+      },
+      {
+        name: "liquidity",
+        type: "uint128",
+        indexed: false,
+        internalType: "uint128"
+      },
+      {
+        name: "amount0",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "amount1",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "error",
+    name: "InvalidAmount",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InvalidConfig",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "PoolAlreadyInitialized",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "PoolNotPrepared",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "TransferFailed",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "Unauthorized",
+    inputs: []
+  }
+];
+
+// src/converters/state.ts
+var import_viem = require("viem");
+var InvalidLaunchpadStateError = class extends Error {
+  field;
+  constructor(field, message) {
+    super(message);
+    this.name = "InvalidLaunchpadStateError";
+    this.field = field;
+  }
+};
+var phasesByStatus = ["invalid", "bonding", "migrating", "graduated"];
+var pauseModes = ["active", "buyPaused", "tradingPaused"];
+function toLaunchpadPhase(status) {
+  const phase = phasesByStatus[status];
+  if (phase === void 0) {
+    throw new InvalidLaunchpadStateError("status", `Unknown Portal token status: ${status}.`);
+  }
+  return phase;
+}
+function toLaunchpadPauseMode(pauseMode) {
+  const mode = pauseModes[pauseMode];
+  if (mode === void 0) {
+    throw new InvalidLaunchpadStateError("pauseMode", `Unknown Portal pause mode: ${pauseMode}.`);
+  }
+  return mode;
+}
+function toLaunchpadTokenState(id, raw) {
+  const phase = toLaunchpadPhase(raw.status);
+  const hasPool = phase !== "invalid" && !(0, import_viem.isAddressEqual)(raw.dexPool, import_viem.zeroAddress);
+  return Object.freeze({
+    id,
+    phase,
+    tokenVersion: raw.tokenVersion,
+    curveId: raw.curveId,
+    migratorId: raw.migratorId,
+    quoteReserve: raw.quoteReserve,
+    circulatingSupply: raw.circulatingSupply,
+    creator: (0, import_viem.getAddress)(raw.creator),
+    ...hasPool ? { dexPool: (0, import_viem.getAddress)(raw.dexPool) } : {},
+    launchBlock: raw.launchBlock,
+    protectionBlocks: raw.protectionBlocks,
+    pauseMode: toLaunchpadPauseMode(raw.pauseMode)
+  });
+}
+
+// src/math/protection.ts
+var TRADE_FEE_BPS = 100;
+var BPS = 1e4;
+var MAX_PROTECTION_BLOCKS = 6;
+var protectionFeeLadder = [BPS, 5e3, 2500, 1500, 1e3, 500];
+function tradeFeeBpsAt(launchBlock, protectionBlocks, blockNumber) {
+  if (blockNumber < launchBlock) {
+    throw new RangeError("blockNumber must not precede the token's launch block.");
+  }
+  const blockDelta = blockNumber - launchBlock;
+  if (blockDelta >= BigInt(protectionBlocks)) return TRADE_FEE_BPS;
+  return protectionFeeLadder[Number(blockDelta)] ?? TRADE_FEE_BPS;
+}
+function isLaunchBlockTradingDisabled(launchBlock, protectionBlocks, blockNumber) {
+  return tradeFeeBpsAt(launchBlock, protectionBlocks, blockNumber) === BPS;
+}
+function firstTradableBlock(launchBlock, protectionBlocks) {
+  return protectionBlocks === 0 ? launchBlock : launchBlock + 1n;
+}
+function toLaunchpadTradeAvailability(state, blockNumber, protocolPaused) {
+  const feeBps = state.phase === "bonding" ? tradeFeeBpsAt(state.launchBlock, state.protectionBlocks, blockNumber) : TRADE_FEE_BPS;
+  const launchBlocked = state.phase === "bonding" && feeBps === BPS;
+  const blockedReason = (() => {
+    if (state.phase === "invalid") return "invalidToken";
+    if (state.phase === "migrating") return "migrating";
+    if (state.phase === "graduated") return "graduated";
+    if (protocolPaused) return "protocolPaused";
+    if (state.pauseMode === "tradingPaused") return "tradingPaused";
+    if (launchBlocked) return "launchBlock";
+    if (state.pauseMode === "buyPaused") return "buyPaused";
+    return void 0;
+  })();
+  const tradable = state.phase === "bonding" && !protocolPaused && !launchBlocked;
+  return Object.freeze({
+    phase: state.phase,
+    protocolPaused,
+    pauseMode: state.pauseMode,
+    // `_buy` rejects any non-zero pauseMode; `sell` only rejects mode 2.
+    canBuy: tradable && state.pauseMode === "active",
+    canSell: tradable && state.pauseMode !== "tradingPaused",
+    feeBps,
+    blockNumber,
+    ...launchBlocked ? { nextTradableBlock: firstTradableBlock(state.launchBlock, state.protectionBlocks) } : {},
+    ...blockedReason ? { blockedReason } : {}
+  });
+}
+
+// src/actions/read.ts
+var InvalidLaunchpadReadInputError = class extends Error {
+  field;
+  constructor(field, message) {
+    super(message);
+    this.name = "InvalidLaunchpadReadInputError";
+    this.field = field;
+  }
+};
+function blockSelector(options = {}) {
+  if (options.blockNumber !== void 0) return { blockNumber: options.blockNumber };
+  if (options.blockTag !== void 0) return { blockTag: options.blockTag };
+  return {};
+}
+var UnpinnableBlockTagError = class extends Error {
+  blockTag;
+  constructor(blockTag) {
+    super(
+      `Block tag "${blockTag}" has no stable height, so a same-block read cannot be pinned to it. Pass an explicit blockNumber, or use "latest", "safe", or "finalized".`
+    );
+    this.name = "UnpinnableBlockTagError";
+    this.blockTag = blockTag;
+  }
+};
+async function resolvePinnedBlockNumber(context, options) {
+  if (options?.blockNumber !== void 0) return options.blockNumber;
+  if (options?.blockTag === void 0 || options.blockTag === "latest") {
+    return context.publicClient.getBlockNumber();
+  }
+  if (options.blockTag === "pending") throw new UnpinnableBlockTagError(options.blockTag);
+  const block = await context.publicClient.getBlock({ blockTag: options.blockTag });
+  if (block.number === null || block.number === void 0) {
+    throw new UnpinnableBlockTagError(options.blockTag);
+  }
+  return block.number;
+}
+function assertPositiveAmount(field, value) {
+  if (value <= 0n) {
+    throw new InvalidLaunchpadReadInputError(field, `${field} must be a positive bigint.`);
+  }
+}
+async function getLaunchpadTokenState(context, token, options) {
+  const raw = await context.publicClient.readContract({
+    address: context.deployment.contracts.portal,
+    abi: portalAbi,
+    functionName: "getTokenState",
+    args: [token],
+    ...blockSelector(options)
+  });
+  return toLaunchpadTokenState(
+    { chainId: context.deployment.chainId, address: (0, import_viem2.getAddress)(token) },
+    raw
+  );
+}
+function getLaunchpadTokenMetadata(context, token, options) {
+  return context.publicClient.readContract({
+    address: context.deployment.contracts.portal,
+    abi: portalAbi,
+    functionName: "metadata",
+    args: [token],
+    ...blockSelector(options)
+  });
+}
+async function getLaunchpadPrice(context, token, options) {
+  const blockNumber = await resolvePinnedBlockNumber(context, options);
+  const [valueWad, state] = await Promise.all([
+    context.publicClient.readContract({
+      address: context.deployment.contracts.portal,
+      abi: portalAbi,
+      functionName: "priceWad",
+      args: [token],
+      blockNumber
+    }),
+    getLaunchpadTokenState(context, token, { blockNumber })
+  ]);
+  return Object.freeze({ valueWad, source: "bondingCurveReference", phase: state.phase });
+}
+async function quoteLaunchpadBuy(context, token, quoteIn, options) {
+  assertPositiveAmount("quoteIn", quoteIn);
+  const [tokenOut, quoteSpent, fee, reachesThreshold] = await context.publicClient.readContract({
+    address: context.deployment.contracts.portal,
+    abi: portalAbi,
+    functionName: "quoteBuy",
+    args: [token, quoteIn],
+    ...blockSelector(options)
+  });
+  return Object.freeze({ tokenOut, quoteSpent, fee, reachesGraduation: reachesThreshold });
+}
+async function quoteLaunchpadSell(context, token, tokenIn, options) {
+  assertPositiveAmount("tokenIn", tokenIn);
+  const [quoteOut, fee] = await context.publicClient.readContract({
+    address: context.deployment.contracts.portal,
+    abi: portalAbi,
+    functionName: "quoteSell",
+    args: [token, tokenIn],
+    ...blockSelector(options)
+  });
+  return Object.freeze({ quoteOut, fee });
+}
+async function getLaunchpadTradeAvailability(context, token, options) {
+  const blockNumber = await resolvePinnedBlockNumber(context, options);
+  const [state, protocolPaused] = await Promise.all([
+    getLaunchpadTokenState(context, token, { blockNumber }),
+    context.publicClient.readContract({
+      address: context.deployment.contracts.portal,
+      abi: portalAbi,
+      functionName: "paused",
+      blockNumber
+    })
+  ]);
+  return toLaunchpadTradeAvailability(state, blockNumber, protocolPaused);
+}
+function getErc20Balance(context, asset, account, options) {
+  return context.publicClient.readContract({
+    address: asset,
+    abi: import_viem2.erc20Abi,
+    functionName: "balanceOf",
+    args: [account],
+    ...blockSelector(options)
+  });
+}
+async function getErc20Metadata(context, asset, options) {
+  const selector = blockSelector(options);
+  const [name, symbol, decimals] = await Promise.all([
+    context.publicClient.readContract({
+      address: asset,
+      abi: import_viem2.erc20Abi,
+      functionName: "name",
+      ...selector
+    }),
+    context.publicClient.readContract({
+      address: asset,
+      abi: import_viem2.erc20Abi,
+      functionName: "symbol",
+      ...selector
+    }),
+    context.publicClient.readContract({
+      address: asset,
+      abi: import_viem2.erc20Abi,
+      functionName: "decimals",
+      ...selector
+    })
+  ]);
+  return Object.freeze({ address: asset, name, symbol, decimals });
+}
+function getErc20Allowance(context, asset, owner, spender, options) {
+  return context.publicClient.readContract({
+    address: asset,
+    abi: import_viem2.erc20Abi,
+    functionName: "allowance",
+    args: [owner, spender],
+    ...blockSelector(options)
+  });
+}
+function getClaimableLaunchpadReward(context, account, asset, options) {
+  return context.publicClient.readContract({
+    address: context.deployment.contracts.liquidityLocker,
+    abi: liquidityLockerAbi,
+    functionName: "pendingRewards",
+    args: [account, asset],
+    ...blockSelector(options)
+  });
+}
+async function getLockedLaunchpadPosition(context, tokenId, options) {
+  if (tokenId < 0n) throw new RangeError("tokenId must not be negative.");
+  const [token0, token1, creator, platformFeeBps] = await context.publicClient.readContract({
+    address: context.deployment.contracts.liquidityLocker,
+    abi: liquidityLockerAbi,
+    functionName: "positions",
+    args: [tokenId],
+    ...blockSelector(options)
+  });
+  if ((0, import_viem2.isAddressEqual)(creator, import_viem2.zeroAddress)) return void 0;
+  return Object.freeze({ tokenId, token0, token1, creator, platformFeeBps });
+}
+async function predictLaunchpadTokenAddress(context, input, options) {
+  if (input.name.length === 0 || input.symbol.length === 0) {
+    throw new InvalidLaunchpadReadInputError(
+      "name",
+      "Token name and symbol must not be empty; the prediction depends on both."
+    );
+  }
+  const selector = blockSelector(options);
+  const [creatorNonce, totalSupply] = await Promise.all([
+    context.publicClient.readContract({
+      address: context.deployment.contracts.portal,
+      abi: portalAbi,
+      functionName: "creatorNonces",
+      args: [input.creator],
+      ...selector
+    }),
+    context.publicClient.readContract({
+      address: context.deployment.contracts.portal,
+      abi: portalAbi,
+      functionName: "TOTAL_SUPPLY",
+      ...selector
+    })
+  ]);
+  const salt = (0, import_viem2.keccak256)(
+    (0, import_viem2.encodeAbiParameters)(
+      [{ type: "address" }, { type: "uint256" }, { type: "bytes32" }],
+      [input.creator, creatorNonce, input.userSalt]
+    )
+  );
+  const address = await context.publicClient.readContract({
+    address: context.deployment.contracts.tokenFactory,
+    abi: tokenFactoryAbi,
+    functionName: "predictAddress",
+    args: [input.name, input.symbol, totalSupply, salt],
+    ...selector
+  });
+  return Object.freeze({
+    address,
+    creator: input.creator,
+    creatorNonce,
+    userSalt: input.userSalt,
+    salt
+  });
+}
+
+// src/actions/approval.ts
+async function getLaunchpadApprovalStatus(context, input, options) {
+  if (input.requiredAmount < 0n) {
+    throw new RangeError("requiredAmount must not be negative.");
+  }
+  const spender = input.spender ?? context.deployment.contracts.portal;
+  const allowance = await getErc20Allowance(context, input.asset, input.owner, spender, options);
+  const sufficient = allowance >= input.requiredAmount;
+  return Object.freeze({
+    asset: input.asset,
+    owner: input.owner,
+    spender,
+    allowance,
+    requiredAmount: input.requiredAmount,
+    sufficient,
+    missingAmount: sufficient ? 0n : input.requiredAmount - allowance
+  });
+}
+
+// src/math/slippage.ts
+var MAX_SLIPPAGE_BPS = 1e3;
+var DEFAULT_DEADLINE_SECONDS = 600n;
+var InvalidSlippageError = class extends Error {
+  bps;
+  constructor(bps, message) {
+    super(message);
+    this.name = "InvalidSlippageError";
+    this.bps = bps;
+  }
+};
+var InvalidDeadlineError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidDeadlineError";
+  }
+};
+function assertSlippage(slippage) {
+  const { bps } = slippage;
+  if (!Number.isSafeInteger(bps)) {
+    throw new InvalidSlippageError(bps, "Slippage bps must be an integer.");
+  }
+  if (bps < 0) {
+    throw new InvalidSlippageError(bps, "Slippage bps must not be negative.");
+  }
+  if (bps > MAX_SLIPPAGE_BPS) {
+    throw new InvalidSlippageError(
+      bps,
+      `Slippage bps must not exceed ${MAX_SLIPPAGE_BPS} (${MAX_SLIPPAGE_BPS / 100}%).`
+    );
+  }
+  return bps;
+}
+function applySlippageToMinimumOut(expectedOut, slippage) {
+  const bps = assertSlippage(slippage);
+  if (expectedOut <= 0n) {
+    throw new InvalidSlippageError(
+      bps,
+      "Cannot derive a minimum output from a zero or negative quote."
+    );
+  }
+  const minimumOut = expectedOut * BigInt(BPS - bps) / BigInt(BPS);
+  if (minimumOut <= 0n) {
+    throw new InvalidSlippageError(
+      bps,
+      "Slippage tolerance reduces the minimum output to zero; lower the tolerance or raise the amount."
+    );
+  }
+  return minimumOut;
+}
+function toDeadline(referenceTimestamp, seconds = DEFAULT_DEADLINE_SECONDS) {
+  if (referenceTimestamp <= 0n) {
+    throw new InvalidDeadlineError("Reference timestamp must be a positive bigint.");
+  }
+  if (seconds <= 0n) {
+    throw new InvalidDeadlineError("Deadline horizon must be a positive number of seconds.");
+  }
+  return referenceTimestamp + seconds;
+}
+function mulDivUp(x, y, denominator) {
+  if (denominator <= 0n) {
+    throw new RangeError("mulDivUp denominator must be positive.");
+  }
+  const product = x * y;
+  const result = product / denominator;
+  return product % denominator === 0n ? result : result + 1n;
+}
+
+// src/math/curve.ts
+function initialCurveState(constants) {
+  return Object.freeze({
+    totalSupply: constants.totalSupply,
+    circulatingSupply: 0n,
+    quoteReserve: 0n,
+    virtualTokenReserve: constants.virtualTokenReserve,
+    virtualQuoteReserve: constants.virtualQuoteReserve,
+    k: constants.curveK
+  });
+}
+function creatorFirstBuyFee(quoteIn) {
+  return quoteIn * BigInt(TRADE_FEE_BPS) / BigInt(BPS);
+}
+function toCreatorFirstBuyQuote(constants, quoteIn, tokenOutFromCurve, netRequiredForThreshold) {
+  if (quoteIn <= 0n) {
+    throw new RangeError("Creator first buy requires a positive quoteIn.");
+  }
+  const fee = creatorFirstBuyFee(quoteIn);
+  const remaining = constants.dexSupplyThreshold;
+  if (tokenOutFromCurve < remaining) {
+    return Object.freeze({
+      tokenOut: tokenOutFromCurve,
+      quoteSpent: quoteIn,
+      fee,
+      reachesGraduation: false
+    });
+  }
+  if (netRequiredForThreshold === void 0) {
+    throw new RangeError(
+      "The first buy reaches graduation; quoteBuyExactOut for the threshold is required."
+    );
+  }
+  const quoteSpent = mulDivUp(netRequiredForThreshold, BigInt(BPS), BigInt(BPS - TRADE_FEE_BPS));
+  return Object.freeze({
+    tokenOut: remaining,
+    quoteSpent,
+    fee: quoteSpent * BigInt(TRADE_FEE_BPS) / BigInt(BPS),
+    reachesGraduation: true
+  });
+}
+
+// src/math/price.ts
+var PRICE_WAD_SCALE = 10n ** 30n;
+function priceImpactBps(spotPriceWad, quoteAmount, tokenAmount) {
+  if (spotPriceWad <= 0n) throw new RangeError("spotPriceWad must be positive.");
+  if (tokenAmount <= 0n) throw new RangeError("tokenAmount must be positive.");
+  if (quoteAmount < 0n) throw new RangeError("quoteAmount must not be negative.");
+  const executionWad = quoteAmount * PRICE_WAD_SCALE / tokenAmount;
+  return Number((executionWad - spotPriceWad) * BigInt(BPS) / spotPriceWad);
+}
+function buyPriceImpactBps(spotPriceWad, quote) {
+  return priceImpactBps(spotPriceWad, quote.quoteSpent - quote.fee, quote.tokenOut);
+}
+function sellPriceImpactBps(spotPriceWad, quote, tokenIn) {
+  return priceImpactBps(spotPriceWad, quote.quoteOut + quote.fee, tokenIn);
+}
+function priceWadPerWholeToken(priceWad, quoteDecimals, tokenDecimals = 18) {
+  if (quoteDecimals < 0 || tokenDecimals < 0) {
+    throw new RangeError("Decimals must not be negative.");
+  }
+  return priceWad * 10n ** BigInt(tokenDecimals) * 10n ** 18n / (PRICE_WAD_SCALE * 10n ** BigInt(quoteDecimals));
+}
+function marketCapQuote(priceWad, totalSupply) {
+  return priceWad * totalSupply / PRICE_WAD_SCALE;
+}
+function curvePriceWadAt(circulatingSupply, constants) {
+  if (circulatingSupply < 0n || circulatingSupply > constants.totalSupply) {
+    throw new RangeError("circulatingSupply must be between zero and the total supply.");
+  }
+  const effectiveBase = constants.totalSupply - circulatingSupply + constants.virtualTokenReserve;
+  return constants.curveK * PRICE_WAD_SCALE / (effectiveBase * effectiveBase);
+}
+function graduationMarketCapQuote(constants) {
+  return marketCapQuote(
+    curvePriceWadAt(constants.dexSupplyThreshold, constants),
+    constants.totalSupply
+  );
+}
+function graduationProgress(circulatingSupply, constants) {
+  const threshold = constants.dexSupplyThreshold;
+  if (threshold <= 0n) throw new RangeError("dexSupplyThreshold must be positive.");
+  if (circulatingSupply >= threshold) {
+    return Object.freeze({ tokensRemaining: 0n, progressBps: BPS, reachedThreshold: true });
+  }
+  return Object.freeze({
+    tokensRemaining: threshold - circulatingSupply,
+    progressBps: Number(circulatingSupply * BigInt(BPS) / threshold),
+    reachedThreshold: false
+  });
+}
+function tradeFee(quoteAmount) {
+  return quoteAmount * BigInt(TRADE_FEE_BPS) / BigInt(BPS);
+}
+
+// src/actions/curve.ts
+function blockSelector2(options = {}) {
+  if (options.blockNumber !== void 0) return { blockNumber: options.blockNumber };
+  if (options.blockTag !== void 0) return { blockTag: options.blockTag };
+  return {};
+}
+async function getLaunchpadCurveConstants(context, options) {
+  const selector = blockSelector2(options);
+  const read = (functionName) => context.publicClient.readContract({
+    address: context.deployment.contracts.portal,
+    abi: portalAbi,
+    functionName,
+    ...selector
+  });
+  const [totalSupply, dexSupplyThreshold, virtualTokenReserve, virtualQuoteReserve, curveK] = await Promise.all([
+    read("TOTAL_SUPPLY"),
+    read("DEX_SUPPLY_THRESHOLD"),
+    read("VIRTUAL_TOKEN_RESERVE"),
+    read("VIRTUAL_QUOTE_RESERVE"),
+    read("CURVE_K")
+  ]);
+  return Object.freeze({
+    totalSupply,
+    dexSupplyThreshold,
+    virtualTokenReserve,
+    virtualQuoteReserve,
+    curveK
+  });
+}
+async function quoteCreatorFirstBuy(context, quoteIn, options) {
+  if (quoteIn <= 0n) {
+    throw new InvalidLaunchpadReadInputError("quoteIn", "quoteIn must be a positive bigint.");
+  }
+  const constants = options?.constants ?? await getLaunchpadCurveConstants(context, options);
+  const fee = creatorFirstBuyFee(quoteIn);
+  const netQuoteIn = quoteIn - fee;
+  if (netQuoteIn <= 0n) {
+    throw new InvalidLaunchpadReadInputError(
+      "quoteIn",
+      "quoteIn is too small to buy anything once the 1% creator fee is deducted."
+    );
+  }
+  const state = initialCurveState(constants);
+  const curve = context.deployment.contracts.curve;
+  const selector = blockSelector2(options);
+  const tokenOutFromCurve = await context.publicClient.readContract({
+    address: curve,
+    abi: constantProductCurveAbi,
+    functionName: "quoteBuy",
+    args: [state, netQuoteIn],
+    ...selector
+  });
+  if (tokenOutFromCurve < constants.dexSupplyThreshold) {
+    return toCreatorFirstBuyQuote(constants, quoteIn, tokenOutFromCurve);
+  }
+  const netRequiredForThreshold = await context.publicClient.readContract({
+    address: curve,
+    abi: constantProductCurveAbi,
+    functionName: "quoteBuyExactOut",
+    args: [state, constants.dexSupplyThreshold],
+    ...selector
+  });
+  return toCreatorFirstBuyQuote(constants, quoteIn, tokenOutFromCurve, netRequiredForThreshold);
+}
+async function getLaunchpadCurveProgress(context, token, options) {
+  const blockNumber = await resolvePinnedBlockNumber(context, options);
+  const [state, priceWad, constants] = await Promise.all([
+    getLaunchpadTokenState(context, token, { blockNumber }),
+    context.publicClient.readContract({
+      address: context.deployment.contracts.portal,
+      abi: portalAbi,
+      functionName: "priceWad",
+      args: [token],
+      blockNumber
+    }),
+    options?.constants ? Promise.resolve(options.constants) : getLaunchpadCurveConstants(context, { blockNumber })
+  ]);
+  const progress = state.phase === "graduated" || state.phase === "migrating" ? { tokensRemaining: 0n, progressBps: 1e4, reachedThreshold: true } : graduationProgress(state.circulatingSupply, constants);
+  return Object.freeze({
+    ...progress,
+    blockNumber,
+    phase: state.phase,
+    circulatingSupply: state.circulatingSupply,
+    quoteReserve: state.quoteReserve,
+    priceWad,
+    marketCapQuote: marketCapQuote(priceWad, constants.totalSupply),
+    graduationMarketCapQuote: graduationMarketCapQuote(constants)
+  });
+}
+
+// ../core/src/errors.ts
+var import_viem3 = require("viem");
+var PEACH_SDK_ERROR_BRAND = /* @__PURE__ */ Symbol.for("masterpeach.sdk-core.PeachSdkError");
+var PeachSdkError = class extends Error {
+  code;
+  metadata;
+  constructor(code, message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "PeachSdkError";
+    this.code = code;
+    this.metadata = options.metadata ?? {};
+    Object.defineProperty(this, PEACH_SDK_ERROR_BRAND, { value: true });
+  }
+};
+var UnsupportedChainError = class extends PeachSdkError {
+  constructor(chainId) {
+    super("UNSUPPORTED_CHAIN", `Unsupported chain: ${chainId}`, {
+      metadata: { chainId }
+    });
+    this.name = "UnsupportedChainError";
+  }
+};
+var MissingChainError = class extends PeachSdkError {
+  constructor() {
+    super("MISSING_CHAIN", "A chain ID is required for this operation.");
+    this.name = "MissingChainError";
+  }
+};
+var MissingAccountError = class extends PeachSdkError {
+  constructor() {
+    super("MISSING_ACCOUNT", "A wallet account is required for this operation.");
+    this.name = "MissingAccountError";
+  }
+};
+function isPeachSdkError(value, code) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (value[PEACH_SDK_ERROR_BRAND] !== true) {
+    return false;
+  }
+  return code === void 0 || value.code === code;
+}
+function toPeachSdkError(error) {
+  if (isPeachSdkError(error)) {
+    return error;
+  }
+  if (error instanceof import_viem3.UserRejectedRequestError) {
+    return new PeachSdkError("USER_REJECTED", "The wallet request was rejected.", {
+      cause: error
+    });
+  }
+  return new PeachSdkError("UNKNOWN_ERROR", "An unknown SDK error occurred.", {
+    cause: error
+  });
+}
+
+// ../core/src/chain.ts
+function resolveChainValue(registry, chainId) {
+  const value = registry[chainId];
+  if (value === void 0) {
+    throw new UnsupportedChainError(chainId);
+  }
+  return value;
+}
+function requireWalletClient(walletClient) {
+  if (!walletClient?.account) {
+    throw new MissingAccountError();
+  }
+  return walletClient;
+}
+
+// ../core/src/transaction.ts
+function transactionResultFromReceipt(receipt) {
+  return {
+    hash: receipt.transactionHash,
+    status: receipt.status === "success" ? "confirmed" : "reverted",
+    receipt
+  };
+}
+
+// src/events.ts
+var import_viem4 = require("viem");
+function decodeFrom(abi, log) {
+  try {
+    return (0, import_viem4.decodeEventLog)({ abi, data: log.data, topics: log.topics });
+  } catch {
+    return void 0;
+  }
+}
+function toTradeEvent(args) {
+  const isBuy = args.isBuy;
+  const quoteAmountRaw = args.quoteAmount;
+  const fee = args.fee;
+  return Object.freeze({
+    token: args.token,
+    trader: args.trader,
+    side: isBuy ? "buy" : "sell",
+    tokenAmount: args.tokenAmount,
+    quoteAmountRaw,
+    fee,
+    // Buy emits netQuote, so the trader actually paid net + fee.
+    // Sell emits grossQuote, so the trader actually received gross - fee.
+    traderQuoteDelta: isBuy ? -(quoteAmountRaw + fee) : quoteAmountRaw - fee,
+    reserveQuoteDelta: isBuy ? quoteAmountRaw : -quoteAmountRaw
+  });
+}
+function parseLaunchpadReceiptEvents(deployment, receipt) {
+  const tokenCreated = [];
+  const trades = [];
+  const migrationStarted = [];
+  const migrationCompleted = [];
+  const rewardsClaimed = [];
+  for (const log of receipt.logs) {
+    if ((0, import_viem4.isAddressEqual)(log.address, deployment.contracts.portal)) {
+      const decoded = decodeFrom(portalAbi, log);
+      if (!decoded) continue;
+      const args = decoded.args;
+      switch (decoded.eventName) {
+        case "TokenCreated":
+          tokenCreated.push(
+            Object.freeze({
+              token: args.token,
+              creator: args.creator,
+              name: args.name,
+              symbol: args.symbol,
+              metadata: args.metadata,
+              curveId: args.curveId,
+              migratorId: args.migratorId
+            })
+          );
+          break;
+        case "Trade":
+          trades.push(toTradeEvent(args));
+          break;
+        case "MigrationStarted":
+          migrationStarted.push(
+            Object.freeze({
+              token: args.token,
+              tokenAmount: args.tokenAmount,
+              quoteAmount: args.quoteAmount
+            })
+          );
+          break;
+        case "MigrationCompleted":
+          migrationCompleted.push(
+            Object.freeze({
+              token: args.token,
+              pool: args.pool,
+              liquidity: args.liquidity,
+              lpRecipient: args.lpRecipient
+            })
+          );
+          break;
+        default:
+          break;
+      }
+      continue;
+    }
+    if ((0, import_viem4.isAddressEqual)(log.address, deployment.contracts.liquidityLocker)) {
+      const decoded = decodeFrom(liquidityLockerAbi, log);
+      if (decoded?.eventName === "RewardsClaimed") {
+        rewardsClaimed.push(
+          Object.freeze({
+            account: decoded.args.account,
+            asset: decoded.args.asset,
+            recipient: decoded.args.recipient,
+            amount: decoded.args.amount
+          })
+        );
+      }
+    }
+  }
+  return Object.freeze({
+    tokenCreated: Object.freeze(tokenCreated),
+    trades: Object.freeze(trades),
+    migrationStarted: Object.freeze(migrationStarted),
+    migrationCompleted: Object.freeze(migrationCompleted),
+    rewardsClaimed: Object.freeze(rewardsClaimed)
+  });
+}
+function createdTokenAddress(deployment, receipt) {
+  return parseLaunchpadReceiptEvents(deployment, receipt).tokenCreated[0]?.token;
+}
+
+// src/actions/transaction.ts
+async function waitForLaunchpadTransaction(context, hash, options = {}) {
+  const receipt = await context.publicClient.waitForTransactionReceipt({
+    hash,
+    ...options.confirmations === void 0 ? {} : { confirmations: options.confirmations }
+  });
+  return Object.freeze({
+    ...transactionResultFromReceipt(receipt),
+    events: parseLaunchpadReceiptEvents(context.deployment, receipt)
+  });
+}
+
+// src/actions/write.ts
+var import_viem6 = require("viem");
+var import_accounts = require("viem/accounts");
+
+// src/errors.ts
+var import_viem5 = require("viem");
+var LaunchpadError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "LaunchpadError";
+  }
+};
+var LaunchpadPhaseUnavailableError = class extends LaunchpadError {
+  phase;
+  constructor(phase, options) {
+    super(
+      phase ? `The Launchpad token is in the ${phase} phase and cannot service this operation.` : "The Launchpad token is not in a phase that permits this operation.",
+      options
+    );
+    this.name = "LaunchpadPhaseUnavailableError";
+    this.phase = phase;
+  }
+};
+var LaunchpadTradingPausedError = class extends LaunchpadError {
+  scope;
+  mode;
+  constructor(scope, mode, options) {
+    super(`Launchpad trading is paused (${scope}).`, options);
+    this.name = "LaunchpadTradingPausedError";
+    this.scope = scope;
+    this.mode = mode;
+  }
+};
+var LaunchpadProtectionError = class extends LaunchpadError {
+  nextEligibleBlock;
+  constructor(nextEligibleBlock, options) {
+    super("Trading is disabled during the token's launch block.", options);
+    this.name = "LaunchpadProtectionError";
+    this.nextEligibleBlock = nextEligibleBlock;
+  }
+};
+var LaunchpadSlippageError = class extends LaunchpadError {
+  constructor(options) {
+    super("The trade would exceed the requested slippage tolerance; refresh the quote.", options);
+    this.name = "LaunchpadSlippageError";
+  }
+};
+var LaunchpadDeadlineExpiredError = class extends LaunchpadError {
+  constructor(options) {
+    super(
+      "The transaction deadline expired; rebuild the transaction with a new deadline.",
+      options
+    );
+    this.name = "LaunchpadDeadlineExpiredError";
+  }
+};
+var LaunchpadApprovalRequiredError = class extends LaunchpadError {
+  asset;
+  spender;
+  requiredAmount;
+  constructor(asset, spender, requiredAmount) {
+    super(`Approve at least ${requiredAmount} of ${asset} for ${spender} before continuing.`);
+    this.name = "LaunchpadApprovalRequiredError";
+    this.asset = asset;
+    this.spender = spender;
+    this.requiredAmount = requiredAmount;
+  }
+};
+var LaunchpadInsufficientBalanceError = class extends LaunchpadError {
+  asset;
+  account;
+  requiredAmount;
+  balance;
+  constructor(asset, account, requiredAmount, balance) {
+    super(
+      `Account ${account} holds ${balance} of ${asset} but needs ${requiredAmount} for this transaction.`
+    );
+    this.name = "LaunchpadInsufficientBalanceError";
+    this.asset = asset;
+    this.account = account;
+    this.requiredAmount = requiredAmount;
+    this.balance = balance;
+  }
+};
+var PreparedAccountMismatchError = class extends LaunchpadError {
+  expectedAccount;
+  actualAccount;
+  constructor(expectedAccount, actualAccount) {
+    super(
+      `This transaction was prepared for account ${expectedAccount} but the wallet is now using ${actualAccount}. Prepare it again.`
+    );
+    this.name = "PreparedAccountMismatchError";
+    this.expectedAccount = expectedAccount;
+    this.actualAccount = actualAccount;
+  }
+};
+var ForgedPreparedTransactionError = class extends LaunchpadError {
+  constructor(message) {
+    super(message);
+    this.name = "ForgedPreparedTransactionError";
+  }
+};
+var MissingWalletClientError = class extends LaunchpadError {
+  constructor() {
+    super("A Wallet Client is required for Launchpad write operations.");
+    this.name = "MissingWalletClientError";
+  }
+};
+var LaunchpadNothingToClaimError = class extends LaunchpadError {
+  asset;
+  account;
+  constructor(asset, account) {
+    super(`No claimable ${asset} rewards are available for ${account}.`);
+    this.name = "LaunchpadNothingToClaimError";
+    this.asset = asset;
+    this.account = account;
+  }
+};
+var LaunchpadUnknownPositionError = class extends LaunchpadError {
+  tokenId;
+  constructor(tokenId) {
+    super(`No locked liquidity position is registered for LP NFT id ${tokenId}.`);
+    this.name = "LaunchpadUnknownPositionError";
+    this.tokenId = tokenId;
+  }
+};
+var LaunchpadOfficialPoolLockedError = class extends LaunchpadError {
+  constructor(options = {}) {
+    super("The official V3 pool is locked until this token graduates.", options);
+    this.name = "LaunchpadOfficialPoolLockedError";
+  }
+};
+var WrongWalletChainError = class extends LaunchpadError {
+  expectedChainId;
+  actualChainId;
+  constructor(expectedChainId, actualChainId) {
+    super(
+      `The wallet is on chain ${actualChainId ?? "unknown"} but this operation requires chain ${expectedChainId}.`
+    );
+    this.name = "WrongWalletChainError";
+    this.expectedChainId = expectedChainId;
+    this.actualChainId = actualChainId;
+  }
+};
+var revertNameToError = {
+  InvalidStatus: (cause) => new LaunchpadPhaseUnavailableError(void 0, { cause }),
+  ProtocolPaused: (cause) => new LaunchpadTradingPausedError("protocol", void 0, { cause }),
+  LaunchBlockTradingDisabled: (cause) => new LaunchpadProtectionError(void 0, { cause }),
+  SlippageExceeded: (cause) => new LaunchpadSlippageError({ cause }),
+  DeadlineExpired: (cause) => new LaunchpadDeadlineExpiredError({ cause }),
+  OfficialPoolLocked: (cause) => new LaunchpadOfficialPoolLockedError({ cause })
+};
+function revertErrorName(error) {
+  if (!(error instanceof import_viem5.BaseError)) return void 0;
+  const reverted = error.walk((cause) => cause instanceof import_viem5.ContractFunctionRevertedError);
+  return reverted instanceof import_viem5.ContractFunctionRevertedError ? reverted.data?.errorName : void 0;
+}
+function toLaunchpadError(error) {
+  if (error instanceof LaunchpadError) return error;
+  const name = revertErrorName(error);
+  const mapped = name ? revertNameToError[name]?.(error) : void 0;
+  return mapped ?? toPeachSdkError(error);
+}
+
+// src/actions/write.ts
+var canonicalPreparedRequests = /* @__PURE__ */ new WeakMap();
+function immutableClone(value, seen = /* @__PURE__ */ new WeakMap()) {
+  if (value === null || typeof value !== "object") return value;
+  const source = value;
+  const existing = seen.get(source);
+  if (existing !== void 0) return existing;
+  const clone = Array.isArray(value) ? [] : Object.create(Object.getPrototypeOf(source));
+  seen.set(source, clone);
+  for (const key of Reflect.ownKeys(source)) {
+    const descriptor = Object.getOwnPropertyDescriptor(source, key);
+    if (!descriptor) continue;
+    if ("value" in descriptor) {
+      descriptor.value = immutableClone(descriptor.value, seen);
+      descriptor.writable = false;
+    }
+    descriptor.configurable = false;
+    Object.defineProperty(clone, key, descriptor);
+  }
+  return Object.freeze(clone);
+}
+function toPrepared(request, preview, context) {
+  const canonicalRequest = immutableClone(request);
+  const prepared = Object.freeze({
+    request: immutableClone(request),
+    preview,
+    context
+  });
+  canonicalPreparedRequests.set(prepared, canonicalRequest);
+  return prepared;
+}
+function preparedContext(context, account) {
+  return Object.freeze({
+    chainId: context.deployment.chainId,
+    account: account.address,
+    portal: context.deployment.contracts.portal
+  });
+}
+async function requireWriteAccount(context) {
+  const walletClient = requireWalletClient(context.walletClient);
+  const chainId = await walletClient.getChainId();
+  if (chainId !== context.deployment.chainId) {
+    throw new WrongWalletChainError(context.deployment.chainId, chainId);
+  }
+  const [liveAddress] = await walletClient.getAddresses();
+  if (!liveAddress) throw new MissingAccountError();
+  const configuredAccount = walletClient.account;
+  if (!configuredAccount) throw new MissingAccountError();
+  return (0, import_viem6.isAddressEqual)(configuredAccount.address, liveAddress) ? configuredAccount : (0, import_accounts.parseAccount)(liveAddress);
+}
+async function simulate(context, parameters) {
+  try {
+    const { request, result } = await context.publicClient.simulateContract(parameters);
+    return { request, result };
+  } catch (error) {
+    throw toLaunchpadError(error);
+  }
+}
+async function assertCanSpend(context, input) {
+  const [balance, approval] = await Promise.all([
+    getErc20Balance(context, input.asset, input.owner),
+    getLaunchpadApprovalStatus(context, {
+      asset: input.asset,
+      owner: input.owner,
+      requiredAmount: input.requiredAmount
+    })
+  ]);
+  if (balance < input.requiredAmount) {
+    throw new LaunchpadInsufficientBalanceError(
+      input.asset,
+      input.owner,
+      input.requiredAmount,
+      balance
+    );
+  }
+  if (!approval.sufficient) {
+    throw new LaunchpadApprovalRequiredError(
+      approval.asset,
+      approval.spender,
+      approval.requiredAmount
+    );
+  }
+}
+async function prepareApproveErc20(context, input) {
+  const account = await requireWriteAccount(context);
+  const spender = input.spender ?? context.deployment.contracts.portal;
+  if (input.amount < 0n) throw new RangeError("Approval amount must not be negative.");
+  const { request } = await simulate(context, {
+    account,
+    address: input.asset,
+    abi: import_viem6.erc20Abi,
+    functionName: "approve",
+    args: [spender, input.amount]
+  });
+  return toPrepared(
+    request,
+    { asset: input.asset, spender, amount: input.amount },
+    preparedContext(context, account)
+  );
+}
+async function prepareLaunchpadBuy(context, input) {
+  const account = await requireWriteAccount(context);
+  const quote = await quoteLaunchpadBuy(context, input.token, input.quoteIn);
+  const minTokenOut = applySlippageToMinimumOut(quote.tokenOut, input.slippage);
+  await assertCanSpend(context, {
+    asset: context.deployment.contracts.quoteToken,
+    owner: account.address,
+    requiredAmount: quote.quoteSpent
+  });
+  const { request } = await simulate(context, {
+    account,
+    address: context.deployment.contracts.portal,
+    abi: portalAbi,
+    functionName: "buy",
+    args: [input.token, input.quoteIn, minTokenOut, input.deadline]
+  });
+  return toPrepared(request, quote, preparedContext(context, account));
+}
+async function prepareLaunchpadSell(context, input) {
+  const account = await requireWriteAccount(context);
+  const quote = await quoteLaunchpadSell(context, input.token, input.tokenIn);
+  const minQuoteOut = applySlippageToMinimumOut(quote.quoteOut, input.slippage);
+  await assertCanSpend(context, {
+    asset: input.token,
+    owner: account.address,
+    requiredAmount: input.tokenIn
+  });
+  const { request } = await simulate(context, {
+    account,
+    address: context.deployment.contracts.portal,
+    abi: portalAbi,
+    functionName: "sell",
+    args: [input.token, input.tokenIn, minQuoteOut, input.deadline]
+  });
+  return toPrepared(request, quote, preparedContext(context, account));
+}
+async function prepareCreateToken(context, input) {
+  const account = await requireWriteAccount(context);
+  if (input.name.length === 0 || input.symbol.length === 0) {
+    throw new RangeError("Token name and symbol must not be empty.");
+  }
+  if (!Number.isSafeInteger(input.protectionBlocks) || input.protectionBlocks < 0 || input.protectionBlocks > MAX_PROTECTION_BLOCKS) {
+    throw new RangeError(
+      `protectionBlocks must be an integer between 0 and ${MAX_PROTECTION_BLOCKS}.`
+    );
+  }
+  if (input.initialQuoteIn < 0n) {
+    throw new RangeError("initialQuoteIn must not be negative.");
+  }
+  let firstBuy;
+  let minInitialTokenOut = 0n;
+  if (input.initialQuoteIn === 0n) {
+    if (input.minInitialTokenOut !== void 0 && input.minInitialTokenOut !== 0n) {
+      throw new RangeError("minInitialTokenOut must be zero when no initial buy is made.");
+    }
+    if (input.slippage !== void 0) {
+      throw new RangeError("slippage is meaningless when no initial buy is made.");
+    }
+  } else {
+    if (input.slippage === void 0 && input.minInitialTokenOut === void 0) {
+      throw new RangeError(
+        "A creator first buy requires either slippage (recommended) or an explicit minInitialTokenOut."
+      );
+    }
+    firstBuy = await quoteCreatorFirstBuy(context, input.initialQuoteIn);
+    if (input.minInitialTokenOut === void 0) {
+      minInitialTokenOut = applySlippageToMinimumOut(firstBuy.tokenOut, input.slippage);
+    } else {
+      if (input.minInitialTokenOut <= 0n) {
+        throw new RangeError(
+          "A creator first buy requires a positive minInitialTokenOut; pass slippage to derive one."
+        );
+      }
+      if (input.minInitialTokenOut > firstBuy.tokenOut) {
+        throw new RangeError(
+          `minInitialTokenOut ${input.minInitialTokenOut} exceeds the quoted first-buy output ${firstBuy.tokenOut} and would revert.`
+        );
+      }
+      minInitialTokenOut = input.minInitialTokenOut;
+    }
+    await assertCanSpend(context, {
+      asset: context.deployment.contracts.quoteToken,
+      owner: account.address,
+      requiredAmount: firstBuy.quoteSpent
+    });
+  }
+  const { request } = await simulate(context, {
+    account,
+    address: context.deployment.contracts.portal,
+    abi: portalAbi,
+    functionName: "createTokenV2",
+    args: [
+      {
+        name: input.name,
+        symbol: input.symbol,
+        metadata: input.metadata,
+        userSalt: input.userSalt
+      },
+      // Raw input, not quoteSpent: the Portal truncates a graduating buy itself.
+      input.initialQuoteIn,
+      minInitialTokenOut,
+      input.deadline,
+      input.protectionBlocks
+    ]
+  });
+  return toPrepared(
+    request,
+    {
+      ...firstBuy ? { firstBuy } : {},
+      initialQuoteIn: input.initialQuoteIn,
+      minInitialTokenOut,
+      protectionBlocks: input.protectionBlocks,
+      deadline: input.deadline
+    },
+    preparedContext(context, account)
+  );
+}
+async function prepareLaunchpadMigration(context, token) {
+  const account = await requireWriteAccount(context);
+  const state = await getLaunchpadTokenState(context, token);
+  if (state.phase !== "migrating") {
+    throw new LaunchpadPhaseUnavailableError(state.phase);
+  }
+  const { request } = await simulate(context, {
+    account,
+    address: context.deployment.contracts.portal,
+    abi: portalAbi,
+    functionName: "migrate",
+    args: [token]
+  });
+  return toPrepared(request, { token }, preparedContext(context, account));
+}
+async function prepareCollectLaunchpadFees(context, tokenId) {
+  const account = await requireWriteAccount(context);
+  const position = await getLockedLaunchpadPosition(context, tokenId);
+  if (!position) {
+    throw new LaunchpadUnknownPositionError(tokenId);
+  }
+  const { request, result } = await simulate(context, {
+    account,
+    address: context.deployment.contracts.liquidityLocker,
+    abi: liquidityLockerAbi,
+    functionName: "collectFees",
+    args: [tokenId]
+  });
+  const [amount0, amount1] = result;
+  return toPrepared(
+    request,
+    {
+      tokenId,
+      token0: position.token0,
+      token1: position.token1,
+      creator: position.creator,
+      platformFeeBps: position.platformFeeBps,
+      amount0,
+      amount1
+    },
+    preparedContext(context, account)
+  );
+}
+async function prepareClaimLaunchpadReward(context, input) {
+  const account = await requireWriteAccount(context);
+  const recipient = input.recipient ?? account.address;
+  const amount = await getClaimableLaunchpadReward(context, account.address, input.asset);
+  if (amount <= 0n) {
+    throw new LaunchpadNothingToClaimError(input.asset, account.address);
+  }
+  const { request } = await simulate(context, {
+    account,
+    address: context.deployment.contracts.liquidityLocker,
+    abi: liquidityLockerAbi,
+    functionName: "claim",
+    args: [input.asset, recipient]
+  });
+  return toPrepared(
+    request,
+    { asset: input.asset, recipient, amount },
+    preparedContext(context, account)
+  );
+}
+async function assertPreparedStillValid(context, prepared) {
+  if (prepared === null || typeof prepared !== "object" || typeof prepared.request !== "object" || prepared.request === null || typeof prepared.context !== "object" || prepared.context === null) {
+    throw new ForgedPreparedTransactionError(
+      "The prepared transaction is malformed; obtain it from a prepare* call."
+    );
+  }
+  if (!canonicalPreparedRequests.has(prepared)) {
+    throw new ForgedPreparedTransactionError(
+      "The prepared transaction did not originate from this SDK process; obtain it from a prepare* call."
+    );
+  }
+  if (prepared.context.chainId !== context.deployment.chainId) {
+    throw new ForgedPreparedTransactionError(
+      `The prepared transaction targets chain ${prepared.context.chainId} but this client is bound to chain ${context.deployment.chainId}.`
+    );
+  }
+  if (!(0, import_viem6.isAddressEqual)(prepared.context.portal, context.deployment.contracts.portal)) {
+    throw new ForgedPreparedTransactionError(
+      `The prepared transaction targets Portal ${prepared.context.portal} but this client is bound to ${context.deployment.contracts.portal}.`
+    );
+  }
+  const account = await requireWriteAccount(context);
+  if (!(0, import_viem6.isAddressEqual)(account.address, prepared.context.account)) {
+    throw new PreparedAccountMismatchError(prepared.context.account, account.address);
+  }
+}
+async function sendPreparedLaunchpadTransaction(context, prepared) {
+  await assertPreparedStillValid(context, prepared);
+  const walletClient = requireWalletClient(context.walletClient);
+  const canonicalRequest = canonicalPreparedRequests.get(prepared);
+  if (!canonicalRequest) {
+    throw new ForgedPreparedTransactionError(
+      "The prepared transaction has no canonical simulated request; prepare it again."
+    );
+  }
+  try {
+    return await walletClient.writeContract(canonicalRequest);
+  } catch (error) {
+    throw toLaunchpadError(error);
+  }
+}
+
+// src/chains.ts
+var import_viem8 = require("viem");
+
+// src/deployment.ts
+var import_viem7 = require("viem");
+var gitCommitPattern = /^[0-9a-f]{40}$/;
+var runtimeCodeHashPattern = /^0x[0-9a-f]{64}$/;
+var requiredContractFields = [
+  "portal",
+  "tokenFactory",
+  "curve",
+  "migrator",
+  "liquidityLocker",
+  "quoteToken"
+];
+var optionalContractFields = [
+  "v3Factory",
+  "positionManager",
+  "dexRouter"
+];
+var InvalidLaunchpadDeploymentError = class extends Error {
+  field;
+  constructor(field, message) {
+    super(message);
+    this.name = "InvalidLaunchpadDeploymentError";
+    this.field = field;
+  }
+};
+function invalid(field, message) {
+  throw new InvalidLaunchpadDeploymentError(field, message);
+}
+function normalizeAddress(field, address) {
+  if (typeof address !== "string" || !(0, import_viem7.isAddress)(address) || (0, import_viem7.isAddressEqual)(address, import_viem7.zeroAddress)) {
+    return invalid(field, `${field} must be a non-zero EVM address.`);
+  }
+  return (0, import_viem7.getAddress)(address);
+}
+function normalizeContracts(input) {
+  const normalized = {};
+  for (const field of requiredContractFields) {
+    normalized[field] = normalizeAddress(`contracts.${field}`, input[field]);
+  }
+  for (const field of optionalContractFields) {
+    const value = input[field];
+    if (value !== void 0) {
+      normalized[field] = normalizeAddress(`contracts.${field}`, value);
+    }
+  }
+  return Object.freeze(normalized);
+}
+function defineLaunchpadDeployment(input) {
+  if (!Number.isSafeInteger(input.chainId) || input.chainId <= 0) {
+    invalid("chainId", "chainId must be a positive safe integer.");
+  }
+  if (input.contractVersion.trim().length === 0) {
+    invalid("contractVersion", "contractVersion must not be empty.");
+  }
+  if (typeof input.deploymentBlock !== "bigint" || input.deploymentBlock <= 0n) {
+    invalid("deploymentBlock", "deploymentBlock must be a positive bigint.");
+  }
+  if (!gitCommitPattern.test(input.artifactCommit)) {
+    invalid("artifactCommit", "artifactCommit must be a lowercase 40-character Git commit.");
+  }
+  if (!gitCommitPattern.test(input.sourceCommit)) {
+    invalid("sourceCommit", "sourceCommit must be a lowercase 40-character Git commit.");
+  }
+  if (!runtimeCodeHashPattern.test(input.portalRuntimeCodeHash)) {
+    invalid(
+      "portalRuntimeCodeHash",
+      "portalRuntimeCodeHash must be a lowercase 32-byte hex hash (0x + 64 hex chars)."
+    );
+  }
+  return Object.freeze({
+    chainId: input.chainId,
+    contractVersion: input.contractVersion,
+    contracts: normalizeContracts(input.contracts),
+    deploymentBlock: input.deploymentBlock,
+    artifactCommit: input.artifactCommit,
+    sourceCommit: input.sourceCommit,
+    portalRuntimeCodeHash: input.portalRuntimeCodeHash
+  });
+}
+function defineLaunchpadDeploymentRegistry(input) {
+  const entries = Object.entries(input).map(([key, deployment]) => {
+    const defined = defineLaunchpadDeployment(deployment);
+    if (Number(key) !== defined.chainId) {
+      invalid(
+        `registry[${key}]`,
+        `Registry key ${key} does not match deployment chainId ${defined.chainId}.`
+      );
+    }
+    return [defined.chainId, defined];
+  });
+  return Object.freeze(Object.fromEntries(entries));
+}
+var launchpadDeploymentRegistry = defineLaunchpadDeploymentRegistry({});
+function resolveLaunchpadDeployment(registry, chainId) {
+  const deployment = registry[chainId];
+  if (deployment === void 0) throw new UnsupportedChainError(chainId);
+  return deployment;
+}
+
+// src/chains.ts
+var InvalidLaunchpadChainConfigError = class extends Error {
+  field;
+  constructor(field, message) {
+    super(message);
+    this.name = "InvalidLaunchpadChainConfigError";
+    this.field = field;
+  }
+};
+function invalid2(field, message) {
+  throw new InvalidLaunchpadChainConfigError(field, message);
+}
+function normalizeAddress2(field, address) {
+  if (!(0, import_viem8.isAddress)(address) || (0, import_viem8.isAddressEqual)(address, import_viem8.zeroAddress)) {
+    return invalid2(field, `${field} must be a non-zero EVM address.`);
+  }
+  return (0, import_viem8.getAddress)(address);
+}
+function normalizeUrl(field, value) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "https:" && url.protocol !== "wss:") {
+      return invalid2(field, `${field} must use HTTPS or WSS.`);
+    }
+    return url.toString().replace(/\/$/, "");
+  } catch {
+    return invalid2(field, `${field} must be an absolute URL.`);
+  }
+}
+function normalizeQuoteToken(input, index) {
+  const field = `quoteTokens[${index}]`;
+  if (!Number.isSafeInteger(input.decimals) || input.decimals < 0 || input.decimals > 255) {
+    invalid2(`${field}.decimals`, "Quote token decimals must be an integer between 0 and 255.");
+  }
+  if (input.symbol.trim().length === 0) {
+    invalid2(`${field}.symbol`, "Quote token symbol must not be empty.");
+  }
+  return Object.freeze({ ...input, address: normalizeAddress2(`${field}.address`, input.address) });
+}
+var capabilities = [
+  "create",
+  "bondingTrade",
+  "graduatedTrade",
+  "antiFarmer",
+  "earlySellTax",
+  "rewards",
+  "referral"
+];
+function defineLaunchpadChain(input) {
+  if (!Number.isSafeInteger(input.chainId) || input.chainId <= 0) {
+    invalid2("chainId", "chainId must be a positive safe integer.");
+  }
+  if (!/^[a-z0-9-]+$/.test(input.slug)) {
+    invalid2("slug", "slug must be lowercase and contain only letters, numbers, and hyphens.");
+  }
+  if (input.deployment.chainId !== input.chainId) {
+    invalid2(
+      "deployment.chainId",
+      `deployment.chainId (${input.deployment.chainId}) must match the chain's chainId (${input.chainId}).`
+    );
+  }
+  if (!Number.isSafeInteger(input.nativeCurrency.decimals) || input.nativeCurrency.decimals < 0) {
+    invalid2("nativeCurrency.decimals", "Native currency decimals must be a non-negative integer.");
+  }
+  if (input.nativeCurrency.symbol.trim().length === 0) {
+    invalid2("nativeCurrency.symbol", "Native currency symbol must not be empty.");
+  }
+  if (input.rpcUrls.length === 0) {
+    invalid2("rpcUrls", "At least one RPC URL is required.");
+  }
+  if (!Number.isSafeInteger(input.confirmations) || input.confirmations < 0) {
+    invalid2("confirmations", "confirmations must be a non-negative safe integer.");
+  }
+  const quoteTokens = input.quoteTokens.map(normalizeQuoteToken);
+  const quoteAddresses = new Set(quoteTokens.map((token) => token.address.toLowerCase()));
+  if (quoteAddresses.size !== quoteTokens.length) {
+    invalid2("quoteTokens", "Quote token addresses must be unique for a chain.");
+  }
+  for (const capability of capabilities) {
+    if (typeof input.capabilities[capability] !== "boolean") {
+      invalid2(
+        `capabilities.${capability}`,
+        "Every Launchpad capability must be declared as a boolean."
+      );
+    }
+  }
+  return Object.freeze({
+    ...input,
+    apiBaseUrl: normalizeUrl("apiBaseUrl", input.apiBaseUrl),
+    capabilities: Object.freeze({ ...input.capabilities }),
+    // Validation and freezing are delegated to the deployment's own definer rather than
+    // duplicated here, so a chain config can never carry an under-validated deployment.
+    deployment: defineLaunchpadDeployment(input.deployment),
+    explorerUrl: normalizeUrl("explorerUrl", input.explorerUrl),
+    nativeCurrency: Object.freeze({ ...input.nativeCurrency }),
+    quoteTokens: Object.freeze(quoteTokens),
+    realtimeUrl: normalizeUrl("realtimeUrl", input.realtimeUrl),
+    rpcUrls: Object.freeze(
+      input.rpcUrls.map((url, index) => normalizeUrl(`rpcUrls[${index}]`, url))
+    )
+  });
+}
+function defineLaunchpadTokenId(input) {
+  if (!Number.isSafeInteger(input.chainId) || input.chainId <= 0) {
+    invalid2("chainId", "chainId must be a positive safe integer.");
+  }
+  return Object.freeze({
+    chainId: input.chainId,
+    address: normalizeAddress2("address", input.address)
+  });
+}
+
+// src/client.ts
+function createLaunchpadClient(config) {
+  const chains = Object.freeze(
+    Object.fromEntries(
+      Object.entries(config.chains).map(([chainId, chain]) => [
+        chainId,
+        defineLaunchpadChain(chain)
+      ])
+    )
+  );
+  const resolveChain = (chainId) => {
+    const resolvedChainId = chainId ?? config.publicClient.chain?.id;
+    if (resolvedChainId === void 0) throw new MissingChainError();
+    const chain = resolveChainValue(chains, resolvedChainId);
+    if (chain.chainId !== resolvedChainId) {
+      throw new TypeError(
+        `Launchpad chain ${chain.chainId} does not match registry chain ${resolvedChainId}.`
+      );
+    }
+    return chain;
+  };
+  const resolveAdapter = (chainId) => {
+    const chain = resolveChain(chainId);
+    return resolveChainValue(config.adapters ?? {}, chain.chainId);
+  };
+  return Object.freeze({
+    publicClient: config.publicClient,
+    walletClient: config.walletClient,
+    getChain: resolveChain,
+    getAdapter: resolveAdapter,
+    read: (request, chainId) => {
+      const chain = resolveChain(chainId);
+      return resolveAdapter(chain.chainId).read(
+        { chain, publicClient: config.publicClient },
+        request
+      );
+    },
+    write: (request, chainId) => {
+      const chain = resolveChain(chainId);
+      if (!chain.capabilities[request.requiredCapability]) {
+        throw new UnsupportedLaunchpadCapabilityError(chain.chainId, request.requiredCapability);
+      }
+      return resolveAdapter(chain.chainId).write(
+        {
+          chain,
+          publicClient: config.publicClient,
+          walletClient: requireWalletClient(config.walletClient)
+        },
+        request
+      );
+    }
+  });
+}
+var UnsupportedLaunchpadCapabilityError = class extends Error {
+  chainId;
+  capability;
+  constructor(chainId, capability) {
+    super(`Launchpad capability ${capability} is not supported on chain ${chainId}.`);
+    this.name = "UnsupportedLaunchpadCapabilityError";
+    this.chainId = chainId;
+    this.capability = capability;
+  }
+};
+
+// src/deployments/arc-testnet.ts
+var arcTestnetChainId = 5042002;
+var arcTestnetLaunchpadDeployment = defineLaunchpadDeployment({
+  chainId: arcTestnetChainId,
+  contractVersion: "v2",
+  contracts: {
+    portal: "0x068E0fD38cb2D91264A8590a922A7f30F32A52FC",
+    tokenFactory: "0x86C0617e718082949C613AB3a31B5d89c7632C38",
+    curve: "0xC56485723B3015c9020De94A3D81C5071c791132",
+    migrator: "0x27079FB023F051AB18AD5D441D0AFd5bE0F83E95",
+    liquidityLocker: "0xfC285E5FD969381798C9Eb1b6bFF8ddaBB7ee243",
+    quoteToken: "0xa93A87359D6c824b2Dad1184d523Da8DCcaaBcD7",
+    v3Factory: "0xf2134DBAF02aB5Da16bfF6BddE87d79ad6A41753",
+    positionManager: "0xb09CD98B83cC46e5da2CB9CEF7988DBA8238c803"
+    // dexRouter is intentionally unset: no audited graduated-execution router adapter exists.
+  },
+  deploymentBlock: 56732456n,
+  artifactCommit: "33dd9f1cd51304ebe84375774dcbee3b1181f3bb",
+  sourceCommit: "33dd9f1cd51304ebe84375774dcbee3b1181f3bb",
+  portalRuntimeCodeHash: "0x4a9960f8e62928be2a163cc78ec14f1609ad72bb910c997c0135e14812cfc50d"
+});
+
+// src/metadata.ts
+var knownStringFields = ["description", "image", "website"];
+function readStringField(source, key) {
+  const value = source[key];
+  return typeof value === "string" ? value : void 0;
+}
+function parseLaunchpadMetadata(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return Object.freeze({ raw, valid: false, extra: Object.freeze({}) });
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return Object.freeze({ raw, valid: false, extra: Object.freeze({}) });
+  }
+  const source = parsed;
+  const extra = Object.fromEntries(
+    Object.entries(source).filter(
+      ([key]) => !knownStringFields.includes(key)
+    )
+  );
+  const fields = Object.fromEntries(
+    knownStringFields.map((key) => [key, readStringField(source, key)]).filter(([, value]) => value !== void 0)
+  );
+  return Object.freeze({
+    raw,
+    valid: true,
+    ...fields,
+    extra: Object.freeze(extra)
+  });
+}
+
+// src/portal-client.ts
+function createLaunchpadPortalClient(config) {
+  const chain = defineLaunchpadChain(config.chain);
+  const deployment = chain.deployment;
+  const readContext = {
+    publicClient: config.publicClient,
+    deployment
+  };
+  const minted = /* @__PURE__ */ new WeakSet();
+  const mint = (prepared) => {
+    minted.add(prepared);
+    return prepared;
+  };
+  const writeContext = () => {
+    if (!config.walletClient) throw new MissingWalletClientError();
+    return { ...readContext, walletClient: config.walletClient };
+  };
+  const requireCapability = (capability) => {
+    if (!chain.capabilities[capability]) {
+      throw new UnsupportedLaunchpadCapabilityError(chain.chainId, capability);
+    }
+  };
+  const client = {
+    chain,
+    deployment,
+    publicClient: config.publicClient,
+    walletClient: config.walletClient,
+    getTokenState: (token, options) => getLaunchpadTokenState(readContext, token, options),
+    getTokenMetadata: (token, options) => getLaunchpadTokenMetadata(readContext, token, options),
+    getPrice: (token, options) => getLaunchpadPrice(readContext, token, options),
+    quoteBuy: (token, quoteIn, options) => quoteLaunchpadBuy(readContext, token, quoteIn, options),
+    quoteSell: (token, tokenIn, options) => quoteLaunchpadSell(readContext, token, tokenIn, options),
+    getCurveConstants: (options) => getLaunchpadCurveConstants(readContext, options),
+    getErc20Metadata: (asset, options) => getErc20Metadata(readContext, asset, options),
+    getLockedPosition: (tokenId, options) => getLockedLaunchpadPosition(readContext, tokenId, options),
+    getCurveProgress: (token, options) => getLaunchpadCurveProgress(readContext, token, options),
+    predictTokenAddress: (input, options) => predictLaunchpadTokenAddress(readContext, input, options),
+    quoteCreatorFirstBuy: (quoteIn, options) => quoteCreatorFirstBuy(readContext, quoteIn, options),
+    getTradeAvailability: (token, options) => getLaunchpadTradeAvailability(readContext, token, options),
+    getBalance: (asset, account, options) => getErc20Balance(readContext, asset, account, options),
+    getAllowance: (asset, owner, spender, options) => getErc20Allowance(readContext, asset, owner, spender, options),
+    getApprovalStatus: (input, options) => getLaunchpadApprovalStatus(readContext, input, options),
+    getClaimableReward: (account, asset, options) => getClaimableLaunchpadReward(readContext, account, asset, options),
+    // `async` so a missing Wallet Client or a disabled capability surfaces as a rejected promise
+    // rather than a synchronous throw, keeping every write path uniformly awaitable.
+    prepareApprove: async (input) => mint(await prepareApproveErc20(writeContext(), input)),
+    prepareCreateToken: async (input) => {
+      requireCapability("create");
+      return mint(await prepareCreateToken(writeContext(), input));
+    },
+    prepareBuy: async (input) => {
+      requireCapability("bondingTrade");
+      return mint(await prepareLaunchpadBuy(writeContext(), input));
+    },
+    prepareSell: async (input) => {
+      requireCapability("bondingTrade");
+      return mint(await prepareLaunchpadSell(writeContext(), input));
+    },
+    prepareMigration: async (token) => mint(await prepareLaunchpadMigration(writeContext(), token)),
+    prepareCollectFees: async (tokenId) => mint(await prepareCollectLaunchpadFees(writeContext(), tokenId)),
+    prepareClaimReward: async (input) => {
+      requireCapability("rewards");
+      return mint(await prepareClaimLaunchpadReward(writeContext(), input));
+    },
+    send: async (prepared) => {
+      if (!minted.has(prepared)) {
+        throw new ForgedPreparedTransactionError(
+          "This prepared transaction was not created by this client. Prepare it again through the client you are sending from."
+        );
+      }
+      return sendPreparedLaunchpadTransaction(writeContext(), prepared);
+    },
+    wait: (hash, options) => waitForLaunchpadTransaction(readContext, hash, options)
+  };
+  return Object.freeze(client);
+}
+
+// src/verify.ts
+var import_viem9 = require("viem");
+var DEFAULT_CURVE_ID = 1;
+var DEFAULT_MIGRATOR_ID = 1;
+var LaunchpadDeploymentVerificationError = class extends Error {
+  field;
+  expected;
+  actual;
+  constructor(field, expected, actual) {
+    super(
+      `Launchpad deployment verification failed for ${field}: expected ${expected}, got ${actual}.`
+    );
+    this.name = "LaunchpadDeploymentVerificationError";
+    this.field = field;
+    this.expected = expected;
+    this.actual = actual;
+  }
+};
+function assertAddress(field, expected, actual) {
+  if (!(0, import_viem9.isAddressEqual)(expected, actual)) {
+    throw new LaunchpadDeploymentVerificationError(field, expected, actual);
+  }
+}
+async function verifyLaunchpadDeployment(publicClient, deployment) {
+  const contracts = deployment.contracts;
+  const chainId = await publicClient.getChainId();
+  if (chainId !== deployment.chainId) {
+    throw new LaunchpadDeploymentVerificationError(
+      "chainId",
+      String(deployment.chainId),
+      String(chainId)
+    );
+  }
+  const code = await publicClient.getCode({ address: contracts.portal });
+  if (!code || code === "0x") {
+    throw new LaunchpadDeploymentVerificationError(
+      "portalRuntimeCode",
+      deployment.portalRuntimeCodeHash,
+      "0x"
+    );
+  }
+  const runtimeCodeHash = (0, import_viem9.keccak256)(code).toLowerCase();
+  if (runtimeCodeHash !== deployment.portalRuntimeCodeHash.toLowerCase()) {
+    throw new LaunchpadDeploymentVerificationError(
+      "portalRuntimeCodeHash",
+      deployment.portalRuntimeCodeHash,
+      runtimeCodeHash
+    );
+  }
+  const readPortal = (functionName) => publicClient.readContract({
+    address: contracts.portal,
+    abi: portalAbi,
+    functionName
+  });
+  const [portalFactory, portalQuoteToken, portalLpRecipient, portalCurve, portalMigrator] = await Promise.all([
+    readPortal("tokenFactory"),
+    readPortal("quoteToken"),
+    readPortal("lpRecipient"),
+    publicClient.readContract({
+      address: contracts.portal,
+      abi: portalAbi,
+      functionName: "curves",
+      args: [DEFAULT_CURVE_ID]
+    }),
+    publicClient.readContract({
+      address: contracts.portal,
+      abi: portalAbi,
+      functionName: "migrators",
+      args: [DEFAULT_MIGRATOR_ID]
+    })
+  ]);
+  assertAddress("portal.tokenFactory", contracts.tokenFactory, portalFactory);
+  assertAddress("portal.quoteToken", contracts.quoteToken, portalQuoteToken);
+  assertAddress("portal.lpRecipient", contracts.liquidityLocker, portalLpRecipient);
+  assertAddress("portal.curves(1)", contracts.curve, portalCurve);
+  assertAddress("portal.migrators(1)", contracts.migrator, portalMigrator);
+  const readMigrator = (functionName) => publicClient.readContract({
+    address: contracts.migrator,
+    abi: v3MigratorAbi,
+    functionName
+  });
+  const [migratorPortal, migratorLocker] = await Promise.all([
+    readMigrator("portal"),
+    readMigrator("locker")
+  ]);
+  assertAddress("migrator.portal", contracts.portal, migratorPortal);
+  assertAddress("migrator.locker", contracts.liquidityLocker, migratorLocker);
+  if (contracts.v3Factory !== void 0) {
+    assertAddress("migrator.factory", contracts.v3Factory, await readMigrator("factory"));
+  }
+  if (contracts.positionManager !== void 0) {
+    const [migratorPositionManager, lockerPositionManager] = await Promise.all([
+      readMigrator("positionManager"),
+      publicClient.readContract({
+        address: contracts.liquidityLocker,
+        abi: liquidityLockerAbi,
+        functionName: "positionManager"
+      })
+    ]);
+    assertAddress("migrator.positionManager", contracts.positionManager, migratorPositionManager);
+    assertAddress("locker.positionManager", contracts.positionManager, lockerPositionManager);
+  }
+  const lockerAllowsMigrator = await publicClient.readContract({
+    address: contracts.liquidityLocker,
+    abi: liquidityLockerAbi,
+    functionName: "migrators",
+    args: [contracts.migrator]
+  });
+  if (lockerAllowsMigrator !== true) {
+    throw new LaunchpadDeploymentVerificationError(
+      "locker.migrators(migrator)",
+      "true",
+      String(lockerAllowsMigrator)
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BPS,
+  DEFAULT_DEADLINE_SECONDS,
+  ForgedPreparedTransactionError,
+  InvalidDeadlineError,
+  InvalidLaunchpadChainConfigError,
+  InvalidLaunchpadDeploymentError,
+  InvalidLaunchpadReadInputError,
+  InvalidLaunchpadStateError,
+  InvalidSlippageError,
+  LaunchpadApprovalRequiredError,
+  LaunchpadDeadlineExpiredError,
+  LaunchpadDeploymentVerificationError,
+  LaunchpadError,
+  LaunchpadInsufficientBalanceError,
+  LaunchpadNothingToClaimError,
+  LaunchpadOfficialPoolLockedError,
+  LaunchpadPhaseUnavailableError,
+  LaunchpadProtectionError,
+  LaunchpadSlippageError,
+  LaunchpadTradingPausedError,
+  LaunchpadUnknownPositionError,
+  MAX_PROTECTION_BLOCKS,
+  MAX_SLIPPAGE_BPS,
+  MissingWalletClientError,
+  PRICE_WAD_SCALE,
+  PreparedAccountMismatchError,
+  TRADE_FEE_BPS,
+  UnpinnableBlockTagError,
+  UnsupportedLaunchpadCapabilityError,
+  WrongWalletChainError,
+  applySlippageToMinimumOut,
+  arcTestnetChainId,
+  arcTestnetLaunchpadDeployment,
+  assertSlippage,
+  buyPriceImpactBps,
+  createLaunchpadClient,
+  createLaunchpadPortalClient,
+  createdTokenAddress,
+  creatorFirstBuyFee,
+  curvePriceWadAt,
+  defineLaunchpadChain,
+  defineLaunchpadDeployment,
+  defineLaunchpadDeploymentRegistry,
+  defineLaunchpadTokenId,
+  firstTradableBlock,
+  getClaimableLaunchpadReward,
+  getErc20Allowance,
+  getErc20Balance,
+  getErc20Metadata,
+  getLaunchpadApprovalStatus,
+  getLaunchpadCurveConstants,
+  getLaunchpadCurveProgress,
+  getLaunchpadPrice,
+  getLaunchpadTokenMetadata,
+  getLaunchpadTokenState,
+  getLaunchpadTradeAvailability,
+  getLockedLaunchpadPosition,
+  graduationMarketCapQuote,
+  graduationProgress,
+  initialCurveState,
+  isLaunchBlockTradingDisabled,
+  launchpadDeploymentRegistry,
+  marketCapQuote,
+  mulDivUp,
+  parseLaunchpadMetadata,
+  parseLaunchpadReceiptEvents,
+  predictLaunchpadTokenAddress,
+  prepareApproveErc20,
+  prepareClaimLaunchpadReward,
+  prepareCollectLaunchpadFees,
+  prepareCreateToken,
+  prepareLaunchpadBuy,
+  prepareLaunchpadMigration,
+  prepareLaunchpadSell,
+  priceImpactBps,
+  priceWadPerWholeToken,
+  quoteCreatorFirstBuy,
+  quoteLaunchpadBuy,
+  quoteLaunchpadSell,
+  resolveLaunchpadDeployment,
+  resolvePinnedBlockNumber,
+  revertErrorName,
+  sellPriceImpactBps,
+  sendPreparedLaunchpadTransaction,
+  toCreatorFirstBuyQuote,
+  toDeadline,
+  toLaunchpadError,
+  toLaunchpadPauseMode,
+  toLaunchpadPhase,
+  toLaunchpadTokenState,
+  toLaunchpadTradeAvailability,
+  tradeFee,
+  tradeFeeBpsAt,
+  verifyLaunchpadDeployment,
+  waitForLaunchpadTransaction
+});
+//# sourceMappingURL=index.cjs.map