@sun-protocol/sun-sdk-protocols 0.1.0-beta.0

package/dist/pump/index.cjs

@@ -0,0 +1,1178 @@
+"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/pump/index.ts
+var pump_exports = {};
+__export(pump_exports, {
+  PumpBuyClient: () => PumpBuyClient,
+  PumpClient: () => PumpClient,
+  PumpLaunchClient: () => PumpLaunchClient,
+  PumpSellClient: () => PumpSellClient,
+  SUNPUMP_LAUNCHPAD_PROTOCOL_ID: () => SUNPUMP_LAUNCHPAD_PROTOCOL_ID,
+  SUNPUMP_V2_PROTOCOL_ID: () => SUNPUMP_V2_PROTOCOL_ID,
+  createPumpClient: () => createPumpClient,
+  createPumpExecutor: () => createPumpExecutor,
+  planPumpAgentLaunch: () => planPumpAgentLaunch,
+  planPumpBuy: () => planPumpBuy,
+  planPumpSell: () => planPumpSell
+});
+module.exports = __toCommonJS(pump_exports);
+
+// src/pump/client.ts
+var import_sun_sdk_launchpad5 = require("@sun-protocol/sun-sdk-launchpad");
+var import_sun_sdk_core14 = require("@sun-protocol/sun-sdk-core");
+
+// src/context.ts
+var import_sun_sdk_api2 = require("@sun-protocol/sun-sdk-api");
+var import_sun_sdk_chains = require("@sun-protocol/sun-sdk-chains");
+var import_sun_sdk_core2 = require("@sun-protocol/sun-sdk-core");
+var import_sun_sdk_runtime = require("@sun-protocol/sun-sdk-runtime");
+
+// src/execute-http-action.ts
+var import_sun_sdk_api = require("@sun-protocol/sun-sdk-api");
+var import_sun_sdk_core = require("@sun-protocol/sun-sdk-core");
+async function executeHttpAction(action, fetchImpl, jsonParser = import_sun_sdk_api.defaultJsonParser) {
+  if (action.type !== "http-request" || action.execute !== "api") {
+    throw new import_sun_sdk_core.SDKError("SDK_INVALID_ARGUMENT", `Action ${action.id} is not an HTTP action`, {
+      actionId: action.id,
+      actionType: action.type
+    });
+  }
+  const request = action.request;
+  const headers = {
+    Accept: "application/json",
+    ...request.headers
+  };
+  let body;
+  if (request.body !== void 0) {
+    if (typeof request.body === "string") {
+      body = request.body;
+    } else {
+      body = JSON.stringify(request.body);
+      if (!headers["Content-Type"]) headers["Content-Type"] = "application/json";
+    }
+  }
+  return (0, import_sun_sdk_api.requestJson)(request.url, {
+    service: "Protocols HTTP action",
+    fetchImpl,
+    jsonParser,
+    init: {
+      method: request.method,
+      headers,
+      ...body !== void 0 ? { body } : {}
+    }
+  });
+}
+
+// src/context.ts
+function requireRuntime(context, operation) {
+  if (!context.runtime) {
+    throw new import_sun_sdk_core2.SDKError("SDK_RUNTIME_ERROR", `${operation} requires a runtime`, {
+      operation,
+      network: context.network
+    });
+  }
+  return context.runtime;
+}
+async function requireWalletAddress(context, operation) {
+  return (await requireWalletSnapshot(context, operation)).address;
+}
+async function requireWalletSnapshot(context, operation) {
+  const runtime = requireRuntime(context, operation);
+  const wallet = await runtime.requireWallet(operation);
+  return {
+    wallet,
+    address: (0, import_sun_sdk_core2.assertTronAddress)(await wallet.getAddress(), "wallet address")
+  };
+}
+function createContextExecutor(context) {
+  const runtime = context.runtime;
+  let walletPromise;
+  const requireExecutionWallet = () => {
+    walletPromise ??= runtime?.requireWallet("transaction plan execution");
+    if (!walletPromise) {
+      return Promise.reject(new import_sun_sdk_core2.SDKError("SDK_RUNTIME_ERROR", "Transaction plan execution requires a runtime"));
+    }
+    return walletPromise;
+  };
+  return {
+    network: context.network,
+    ...runtime ? {
+      getAddress: async () => {
+        const wallet = await requireExecutionWallet();
+        return (0, import_sun_sdk_core2.assertTronAddress)(await wallet.getAddress(), "wallet address");
+      },
+      sendAction: async (action) => {
+        const wallet = await requireExecutionWallet();
+        return runtime.sendAction(action, { wallet });
+      },
+      ...runtime.waitForTransactionReceipt ? { waitForTransactionReceipt: runtime.waitForTransactionReceipt.bind(runtime) } : {},
+      signTypedData: async (payload) => {
+        const wallet = await requireExecutionWallet();
+        return runtime.signTypedData(payload, { wallet });
+      }
+    } : {},
+    executeHttpAction: (action) => executeHttpAction(action, context.fetchImpl, context.jsonParser)
+  };
+}
+
+// src/pump/buy.ts
+var import_sun_sdk_launchpad2 = require("@sun-protocol/sun-sdk-launchpad");
+var import_sun_sdk_core10 = require("@sun-protocol/sun-sdk-core");
+
+// src/common.ts
+var import_sun_sdk_core3 = require("@sun-protocol/sun-sdk-core");
+var PERCENT_PATTERN = /^(\d+)(?:\.(\d+))?%$/;
+var BASE_UNIT_PATTERN = /^\d+$/;
+function parseSlippage(value) {
+  if (value instanceof import_sun_sdk_core3.Percent) {
+    validateSlippage(value);
+    return value;
+  }
+  const match = PERCENT_PATTERN.exec(value);
+  if (!match) {
+    throw new import_sun_sdk_core3.SDKError("SDK_INVALID_ARGUMENT", "Slippage must be a percentage string", {
+      slippage: value
+    });
+  }
+  const whole = match[1] ?? "0";
+  const fraction = match[2] ?? "";
+  const scale = 10n ** BigInt(fraction.length);
+  const percentageUnits = BigInt(whole) * scale + BigInt(fraction || "0");
+  const percent = new import_sun_sdk_core3.Percent(percentageUnits.toString(), (100n * scale).toString());
+  validateSlippage(percent);
+  return percent;
+}
+function validateSlippage(value) {
+  if (value.lessThan(0) || value.greaterThan(1)) {
+    throw new import_sun_sdk_core3.SDKError("SDK_INVALID_ARGUMENT", "Slippage must be between 0% and 100%", {
+      slippage: value.toSignificant()
+    });
+  }
+}
+function slippageToBips(value) {
+  const percent = parseSlippage(value);
+  const numerator = BigInt(percent.numerator.toString()) * 10000n;
+  const denominator = BigInt(percent.denominator.toString());
+  if (numerator % denominator !== 0n) {
+    throw new import_sun_sdk_core3.SDKError("SDK_INVALID_ARGUMENT", "Slippage must resolve to a whole basis point", {
+      slippage: typeof value === "string" ? value : value.toSignificant()
+    });
+  }
+  return Number(numerator / denominator);
+}
+function normalizeBaseUnitAmount(value, label = "amount", options = {}) {
+  if (typeof value === "number" && !Number.isSafeInteger(value)) {
+    throw new import_sun_sdk_core3.SDKError("SDK_INVALID_ARGUMENT", `${label} must be a safe integer`, {
+      label,
+      value
+    });
+  }
+  const text = value.toString();
+  if (!BASE_UNIT_PATTERN.test(text)) {
+    throw new import_sun_sdk_core3.SDKError("SDK_INVALID_ARGUMENT", `${label} must be an unsigned base-unit integer`, {
+      label,
+      value: text
+    });
+  }
+  const amount = BigInt(text);
+  if (options.allowZero ? amount < 0n : amount <= 0n) {
+    throw new import_sun_sdk_core3.SDKError("SDK_INVALID_ARGUMENT", `${label} must be ${options.allowZero ? "non-negative" : "positive"}`, {
+      label,
+      value: text
+    });
+  }
+  return amount.toString();
+}
+function normalizeTransactionValidForSeconds(value) {
+  const transactionValidForSeconds = value ?? 1200;
+  if (!Number.isSafeInteger(transactionValidForSeconds) || transactionValidForSeconds <= 0) {
+    throw new import_sun_sdk_core3.SDKError(
+      "SDK_INVALID_ARGUMENT",
+      "transactionValidForSeconds must be a positive safe integer",
+      { transactionValidForSeconds }
+    );
+  }
+  return transactionValidForSeconds;
+}
+async function resolveTransactionDeadline(context, transactionValidForSeconds) {
+  const nowSeconds = BigInt(Math.ceil(await context.getTransactionTime() / 1e3));
+  return (nowSeconds + BigInt(transactionValidForSeconds)).toString();
+}
+async function normalizeRecipient(context, recipient, operation, walletAddress) {
+  if (recipient !== void 0) return (0, import_sun_sdk_core3.assertTronAddress)(recipient, "recipient");
+  if (walletAddress !== void 0) return walletAddress;
+  return requireWalletAddress(context, operation);
+}
+function nextPlanId(context, prefix) {
+  return `${prefix}-${context.idFactory()}`;
+}
+
+// src/execute-plan.ts
+var import_sun_sdk_core5 = require("@sun-protocol/sun-sdk-core");
+
+// src/errors.ts
+var import_sun_sdk_core4 = require("@sun-protocol/sun-sdk-core");
+function isWalletRejection(error) {
+  if (!error || typeof error !== "object") return false;
+  const candidate = error;
+  return candidate.code === 4001 || typeof candidate.message === "string" && /reject|denied|cancel/i.test(candidate.message);
+}
+function normalizeProtocolError(error, fallbackCode, message, context = {}) {
+  if (error instanceof import_sun_sdk_core4.SDKError) return error;
+  const code = isWalletRejection(error) ? "SDK_WALLET_REJECTED" : fallbackCode;
+  return new import_sun_sdk_core4.SDKError(code, message, { ...context, cause: error });
+}
+function withExecutionContext(error, context) {
+  return new import_sun_sdk_core4.SDKError(error.code, error.message, {
+    ...error.context,
+    actionId: context.actionId,
+    completedActionIds: context.completedActionIds,
+    cause: error
+  });
+}
+
+// src/execute-plan.ts
+async function executePlanAction(action, executor, completedActions = []) {
+  try {
+    if (action.waitForReceipt && !executor.waitForTransactionReceipt) {
+      throw new import_sun_sdk_core5.SDKError(
+        "SDK_RUNTIME_ERROR",
+        `Action ${action.id} requires transaction receipt waiting capability`,
+        { actionId: action.id, finality: action.waitForReceipt }
+      );
+    }
+    if (action.execute === "runtime") {
+      let actionToSend;
+      let materializedAction;
+      if (action.type === "deferred-contract-call") {
+        if (!executor.materializeAction) {
+          throw new import_sun_sdk_core5.SDKError("SDK_RUNTIME_ERROR", `Action ${action.id} requires a deferred action materializer`);
+        }
+        const resolvedAction = await executor.materializeAction(action, completedActions);
+        materializedAction = {
+          ...resolvedAction,
+          id: action.id,
+          ...action.intent === void 0 ? {} : { intent: action.intent }
+        };
+        actionToSend = materializedAction;
+      } else if (action.type === "contract-call" || action.type === "approve") {
+        actionToSend = action;
+      } else {
+        throw new import_sun_sdk_core5.SDKError(
+          "SDK_RUNTIME_ERROR",
+          `Runtime action ${action.id} materialized to unsupported type: ${action.type}`
+        );
+      }
+      if (!executor.sendAction) {
+        throw new import_sun_sdk_core5.SDKError("SDK_RUNTIME_ERROR", `Action ${action.id} requires a runtime executor`);
+      }
+      const result = await executor.sendAction(actionToSend);
+      const receipt = action.waitForReceipt && executor.waitForTransactionReceipt ? await executor.waitForTransactionReceipt(result.txid, { finality: action.waitForReceipt }) : void 0;
+      if (receipt && !receipt.success) {
+        throw new import_sun_sdk_core5.SDKError("SDK_CONTRACT_ERROR", `Transaction ${result.txid} failed`, {
+          actionId: action.id,
+          txid: result.txid,
+          receipt
+        });
+      }
+      return {
+        action,
+        result,
+        txid: result.txid,
+        ...receipt ? { receipt } : {},
+        ...materializedAction ? { materializedAction } : {}
+      };
+    }
+    if (action.execute === "wallet-signature") {
+      if (!action.typedData) {
+        throw new import_sun_sdk_core5.SDKError("SDK_INVALID_ARGUMENT", `Action ${action.id} is missing typedData`);
+      }
+      if (!executor.signTypedData) {
+        throw new import_sun_sdk_core5.SDKError("SDK_WALLET_CAPABILITY_ERROR", `Action ${action.id} requires typed-data signing`);
+      }
+      const signature = await executor.signTypedData(action.typedData);
+      return { action, result: signature };
+    }
+    if (action.execute === "api") {
+      if (!executor.executeHttpAction) {
+        throw new import_sun_sdk_core5.SDKError("SDK_RUNTIME_ERROR", `Action ${action.id} requires an API executor`);
+      }
+      return { action, result: await executor.executeHttpAction(action) };
+    }
+    throw new import_sun_sdk_core5.SDKError("SDK_RUNTIME_ERROR", "Unsupported action executor");
+  } catch (error) {
+    const normalized = normalizeProtocolError(
+      error,
+      action.execute === "api" ? "SDK_API_ERROR" : "SDK_RUNTIME_ERROR",
+      `Failed to execute action ${action.id}`
+    );
+    throw withExecutionContext(normalized, {
+      actionId: action.id,
+      completedActionIds: completedActions.map((result) => result.action.id)
+    });
+  }
+}
+async function executeTransactionPlan(plan, executor) {
+  if (executor.network && executor.network !== plan.network) {
+    throw new import_sun_sdk_core5.SDKError("SDK_INVALID_ARGUMENT", "Plan and executor network mismatch", {
+      planNetwork: plan.network,
+      executorNetwork: executor.network
+    });
+  }
+  if (plan.owner) {
+    if (!executor.getAddress) {
+      throw new import_sun_sdk_core5.SDKError("SDK_RUNTIME_ERROR", `Plan ${plan.id} requires a wallet address`, {
+        planId: plan.id,
+        owner: plan.owner
+      });
+    }
+    const actualAddress = await executor.getAddress();
+    if (actualAddress !== plan.owner) {
+      throw new import_sun_sdk_core5.SDKError(
+        "SDK_WALLET_ACCOUNT_MISMATCH",
+        "Transaction plan was created for a different wallet",
+        {
+          planId: plan.id,
+          expectedAddress: plan.owner,
+          actualAddress
+        }
+      );
+    }
+  }
+  const orderedActions = [...plan.approvals, ...plan.transactions];
+  const receiptAction = orderedActions.find((action) => action.waitForReceipt !== void 0);
+  if (receiptAction && !executor.waitForTransactionReceipt) {
+    throw new import_sun_sdk_core5.SDKError(
+      "SDK_RUNTIME_ERROR",
+      `Action ${receiptAction.id} requires transaction receipt waiting capability`,
+      { planId: plan.id, actionId: receiptAction.id, finality: receiptAction.waitForReceipt }
+    );
+  }
+  const actionResults = [];
+  const txids = [];
+  let finalResult;
+  for (const action of orderedActions) {
+    const actionResult = await executePlanAction(action, executor, actionResults);
+    actionResults.push(actionResult);
+    if (action.execute === "runtime") {
+      if (!actionResult.txid) {
+        throw new import_sun_sdk_core5.SDKError("SDK_RUNTIME_ERROR", `Runtime action ${action.id} did not return a transaction id`);
+      }
+      txids.push(actionResult.txid);
+      const raw = typeof actionResult.result === "object" && actionResult.result !== null ? actionResult.result.raw : void 0;
+      finalResult = { type: "transaction", txid: actionResult.txid, raw };
+      continue;
+    }
+    if (action.execute === "wallet-signature") {
+      finalResult = { type: "signature", signature: actionResult.result };
+      continue;
+    }
+    finalResult = { type: "api", data: actionResult.result };
+  }
+  return {
+    plan,
+    actions: actionResults,
+    txids,
+    finalResult
+  };
+}
+function isTransactionPlan(input) {
+  if (typeof input !== "object" || input === null) return false;
+  const candidate = input;
+  return Array.isArray(candidate.approvals) && Array.isArray(candidate.transactions);
+}
+async function executePlanTransactions(plan, executor) {
+  const result = await executeTransactionPlan(
+    { ...plan, approvals: [] },
+    executor
+  );
+  return { ...result, plan };
+}
+
+// src/internal/v2-swap-action.ts
+var import_sun_sdk_sunswap_v2 = require("@sun-protocol/sun-sdk-sunswap-v2");
+var import_sun_sdk_core6 = require("@sun-protocol/sun-sdk-core");
+var V2_SWAP_MATERIALIZATION_KIND = "sunswap-v2-swap";
+function requireAmount(data, key) {
+  const value = data[key];
+  if (value === void 0) {
+    throw new import_sun_sdk_core6.SDKError("SDK_RUNTIME_ERROR", `Deferred V2 swap is missing ${key}`, {
+      operation: data.operation,
+      key
+    });
+  }
+  return value;
+}
+function createDeferredV2SwapAction(input) {
+  return (0, import_sun_sdk_core6.createDeferredContractCallAction)({
+    id: `sunswap-v2-${input.data.operation}`,
+    materialization: {
+      kind: V2_SWAP_MATERIALIZATION_KIND,
+      data: input.data
+    }
+  });
+}
+async function materializeV2SwapAction(context, action) {
+  if (action.materialization.kind !== V2_SWAP_MATERIALIZATION_KIND) {
+    throw new import_sun_sdk_core6.SDKError("SDK_RUNTIME_ERROR", `Unsupported deferred action kind: ${action.materialization.kind}`);
+  }
+  const data = action.materialization.data;
+  const options = {
+    network: context.network,
+    id: action.id,
+    path: data.path,
+    recipient: data.recipient,
+    deadline: await resolveTransactionDeadline(context, data.transactionValidForSeconds)
+  };
+  switch (data.operation) {
+    case "swap-exact-eth-for-tokens":
+      return (0, import_sun_sdk_sunswap_v2.buildV2SwapExactEthForTokensAction)({
+        ...options,
+        amountIn: requireAmount(data, "amountIn"),
+        amountOutMin: requireAmount(data, "amountOutMin")
+      });
+    case "swap-eth-for-exact-tokens":
+      return (0, import_sun_sdk_sunswap_v2.buildV2SwapEthForExactTokensAction)({
+        ...options,
+        amountOut: requireAmount(data, "amountOut"),
+        amountInMax: requireAmount(data, "amountInMax")
+      });
+    case "swap-exact-tokens-for-eth":
+      return (0, import_sun_sdk_sunswap_v2.buildV2SwapExactTokensForEthAction)({
+        ...options,
+        amountIn: requireAmount(data, "amountIn"),
+        amountOutMin: requireAmount(data, "amountOutMin")
+      });
+    case "swap-exact-tokens-for-tokens":
+      return (0, import_sun_sdk_sunswap_v2.buildV2SwapExactTokensForTokensAction)({
+        ...options,
+        amountIn: requireAmount(data, "amountIn"),
+        amountOutMin: requireAmount(data, "amountOutMin")
+      });
+    case "swap-tokens-for-exact-eth":
+      return (0, import_sun_sdk_sunswap_v2.buildV2SwapTokensForExactEthAction)({
+        ...options,
+        amountOut: requireAmount(data, "amountOut"),
+        amountInMax: requireAmount(data, "amountInMax")
+      });
+    case "swap-tokens-for-exact-tokens":
+      return (0, import_sun_sdk_sunswap_v2.buildV2SwapTokensForExactTokensAction)({
+        ...options,
+        amountOut: requireAmount(data, "amountOut"),
+        amountInMax: requireAmount(data, "amountInMax")
+      });
+  }
+}
+
+// src/swap/v2-execute.ts
+function createV2SwapExecutor(context) {
+  return {
+    ...createContextExecutor(context),
+    materializeAction: (action) => materializeV2SwapAction(context, action)
+  };
+}
+
+// src/pump/execute.ts
+function createPumpExecutor(context) {
+  return createV2SwapExecutor(context);
+}
+
+// src/pump/plan-buy.ts
+var import_sun_sdk_launchpad = require("@sun-protocol/sun-sdk-launchpad");
+var import_sun_sdk_core8 = require("@sun-protocol/sun-sdk-core");
+
+// src/pump/v2.ts
+var import_sun_sdk_sunswap_v22 = require("@sun-protocol/sun-sdk-sunswap-v2");
+var import_sun_sdk_core7 = require("@sun-protocol/sun-sdk-core");
+function pumpV2BuyPath(context, token) {
+  return [context.chain.contracts.wtrx, token];
+}
+function pumpV2SellPath(context, token) {
+  return [token, context.chain.contracts.wtrx];
+}
+async function readPumpV2AmountsOut(context, runtime, amountIn, path) {
+  const result = await runtime.readContract(
+    (0, import_sun_sdk_sunswap_v22.buildV2RouterAmountsOutRead)({
+      network: context.network,
+      amountIn,
+      path
+    })
+  );
+  return (0, import_sun_sdk_sunswap_v22.normalizeV2AmountsResult)(result);
+}
+async function readPumpV2AmountsIn(context, runtime, amountOut, path) {
+  const result = await runtime.readContract(
+    (0, import_sun_sdk_sunswap_v22.buildV2RouterAmountsInRead)({
+      network: context.network,
+      amountOut,
+      path
+    })
+  );
+  return (0, import_sun_sdk_sunswap_v22.normalizeV2AmountsResult)(result);
+}
+function requirePumpV2Amount(amounts, index, operation) {
+  const amount = amounts[index];
+  if (amount === void 0) {
+    throw new import_sun_sdk_core7.SDKError("SDK_NO_ROUTE", "SunSwap V2 returned no Pump route amount", {
+      operation,
+      index,
+      amounts
+    });
+  }
+  return amount;
+}
+
+// src/pump/intents.ts
+var SUNPUMP_LAUNCHPAD_PROTOCOL_ID = "sunpump-launchpad";
+var SUNPUMP_V2_PROTOCOL_ID = "sunpump-v2";
+function pumpIntentScope(protocol, operation) {
+  return { domain: "pump", protocol, operation };
+}
+
+// src/pump/plan-buy.ts
+function normalizePumpBuyMode(input) {
+  const trxAmount = input.trxAmount;
+  const tokenAmount = input.tokenAmount;
+  if (trxAmount === void 0 === (tokenAmount === void 0)) {
+    throw new import_sun_sdk_core8.SDKError("SDK_INVALID_ARGUMENT", "Pump buy requires exactly one of trxAmount or tokenAmount", {
+      trxAmount,
+      tokenAmount
+    });
+  }
+  if (trxAmount !== void 0) {
+    return {
+      kind: "exact-trx",
+      trxAmount: normalizeBaseUnitAmount(trxAmount, "trxAmount")
+    };
+  }
+  if (tokenAmount === void 0) {
+    throw new import_sun_sdk_core8.SDKError("SDK_INVALID_ARGUMENT", "Pump buy requires tokenAmount", {
+      trxAmount,
+      tokenAmount
+    });
+  }
+  return {
+    kind: "exact-token",
+    tokenAmount: normalizeBaseUnitAmount(tokenAmount, "tokenAmount")
+  };
+}
+async function planPumpBuy(context, input) {
+  const runtime = requireRuntime(context, "Pump buy planning");
+  const { address: owner } = await requireWalletSnapshot(context, "Pump buy planning");
+  const token = (0, import_sun_sdk_core8.assertTronAddress)(input.token, "token");
+  const mode = normalizePumpBuyMode(input);
+  const state = await (0, import_sun_sdk_launchpad.getLaunchpadTokenState)(runtime, token);
+  if (state !== import_sun_sdk_launchpad.LaunchpadTokenState.TRADING && state !== import_sun_sdk_launchpad.LaunchpadTokenState.LAUNCHED) {
+    throw new import_sun_sdk_core8.SDKError("SDK_CONTRACT_ERROR", "Token is not trading on SunPump", {
+      token,
+      state
+    });
+  }
+  const slippageBips = slippageToBips(input.slippage ?? "5%");
+  if (state === import_sun_sdk_launchpad.LaunchpadTokenState.TRADING) {
+    let trxAmount;
+    let quotedTokenAmount;
+    let fee;
+    let operation;
+    let requestedTokenAmount;
+    if (mode.kind === "exact-trx") {
+      const quote = await (0, import_sun_sdk_launchpad.quoteLaunchpadBuyExactTrx)(runtime, token, mode.trxAmount);
+      trxAmount = mode.trxAmount;
+      quotedTokenAmount = quote.tokenAmount;
+      fee = quote.fee;
+      operation = "launchpad-buy-exact-trx";
+    } else {
+      const quote = await (0, import_sun_sdk_launchpad.quoteLaunchpadBuyExactToken)(runtime, token, mode.tokenAmount);
+      trxAmount = quote.trxAmount;
+      quotedTokenAmount = mode.tokenAmount;
+      fee = quote.fee;
+      operation = "launchpad-buy-exact-token";
+      requestedTokenAmount = mode.tokenAmount;
+    }
+    const minTokenOut = (0, import_sun_sdk_launchpad.applySlippageMin)(BigInt(quotedTokenAmount), slippageBips).toString();
+    const transaction2 = {
+      ...(0, import_sun_sdk_launchpad.createLaunchpadBuyAction)({
+        launchpad: context.chain.contracts.launchpad,
+        token,
+        trxAmount,
+        minTokenOut
+      }),
+      intent: {
+        kind: "pump-buy",
+        scope: pumpIntentScope(SUNPUMP_LAUNCHPAD_PROTOCOL_ID, operation),
+        token
+      }
+    };
+    return {
+      id: nextPlanId(context, "pump-buy"),
+      kind: "pump",
+      network: context.network,
+      owner,
+      summary: {
+        title: "Buy SunPump token",
+        lines: [`Spend ${trxAmount} sun`, `Receive at least ${minTokenOut} token units`]
+      },
+      approvals: [],
+      transactions: [transaction2],
+      metadata: {
+        operation,
+        token,
+        trxAmount,
+        ...requestedTokenAmount ? { tokenAmount: requestedTokenAmount } : {},
+        quotedTokenAmount,
+        quotedTrxAmount: trxAmount,
+        fee,
+        minTokenOut,
+        slippageBips
+      }
+    };
+  }
+  const path = pumpV2BuyPath(context, token);
+  const recipient = await normalizeRecipient(context, input.recipient, "Pump V2 buy recipient", owner);
+  const transactionValidForSeconds = normalizeTransactionValidForSeconds(input.transactionValidForSeconds);
+  if (mode.kind === "exact-trx") {
+    const amounts2 = await readPumpV2AmountsOut(context, runtime, mode.trxAmount, path);
+    const quotedTokenAmount = requirePumpV2Amount(amounts2, amounts2.length - 1, "pump-v2-buy-exact-trx");
+    const minTokenOut = (0, import_sun_sdk_launchpad.applySlippageMin)(BigInt(quotedTokenAmount), slippageBips).toString();
+    const transaction2 = {
+      ...createDeferredV2SwapAction({
+        data: {
+          operation: "swap-exact-eth-for-tokens",
+          amountIn: mode.trxAmount,
+          amountOutMin: minTokenOut,
+          path,
+          recipient,
+          transactionValidForSeconds
+        }
+      }),
+      intent: {
+        kind: "pump-buy",
+        scope: pumpIntentScope(SUNPUMP_V2_PROTOCOL_ID, "buy-exact-trx"),
+        token
+      }
+    };
+    return {
+      id: nextPlanId(context, "pump-buy"),
+      kind: "pump",
+      network: context.network,
+      owner,
+      summary: {
+        title: "Buy launched Pump token",
+        lines: [`Spend ${mode.trxAmount} sun`, `Receive at least ${minTokenOut} token units`]
+      },
+      approvals: [],
+      transactions: [transaction2],
+      metadata: {
+        operation: "pump-v2-buy-exact-trx",
+        token,
+        trxAmount: mode.trxAmount,
+        quotedTokenAmount,
+        minTokenOut,
+        slippageBips,
+        path,
+        recipient,
+        transactionValidForSeconds
+      }
+    };
+  }
+  const amounts = await readPumpV2AmountsIn(context, runtime, mode.tokenAmount, path);
+  const quotedTrxAmount = requirePumpV2Amount(amounts, 0, "pump-v2-buy-exact-token");
+  const maxTrxIn = (0, import_sun_sdk_launchpad.applySlippageMax)(BigInt(quotedTrxAmount), slippageBips).toString();
+  const transaction = {
+    ...createDeferredV2SwapAction({
+      data: {
+        operation: "swap-eth-for-exact-tokens",
+        amountOut: mode.tokenAmount,
+        amountInMax: maxTrxIn,
+        path,
+        recipient,
+        transactionValidForSeconds
+      }
+    }),
+    intent: {
+      kind: "pump-buy",
+      scope: pumpIntentScope(SUNPUMP_V2_PROTOCOL_ID, "buy-exact-token"),
+      token
+    }
+  };
+  return {
+    id: nextPlanId(context, "pump-buy"),
+    kind: "pump",
+    network: context.network,
+    owner,
+    summary: {
+      title: "Buy launched Pump token",
+      lines: [`Spend at most ${maxTrxIn} sun`, `Receive ${mode.tokenAmount} token units`]
+    },
+    approvals: [],
+    transactions: [transaction],
+    metadata: {
+      operation: "pump-v2-buy-exact-token",
+      token,
+      tokenAmount: mode.tokenAmount,
+      quotedTrxAmount,
+      maxTrxIn,
+      slippageBips,
+      path,
+      recipient,
+      transactionValidForSeconds
+    }
+  };
+}
+
+// src/pump/workflow.ts
+var import_sun_sdk_core9 = require("@sun-protocol/sun-sdk-core");
+function assertPumpPlan(plan, operations, clientName) {
+  const operation = plan.metadata.operation;
+  if (plan.kind !== "pump" || typeof operation !== "string" || !operations.includes(operation) || plan.transactions.length === 0) {
+    throw new import_sun_sdk_core9.SDKError("SDK_INVALID_ARGUMENT", `Expected a ${clientName} plan`, {
+      planId: plan.id,
+      kind: plan.kind,
+      operation,
+      transactionCount: plan.transactions.length
+    });
+  }
+}
+
+// src/pump/buy.ts
+var PUMP_BUY_OPERATIONS = [
+  "launchpad-buy-exact-trx",
+  "launchpad-buy-exact-token",
+  "pump-v2-buy-exact-trx",
+  "pump-v2-buy-exact-token"
+];
+async function quotePumpBuyByTrx(context, input) {
+  const runtime = requireRuntime(context, "Pump buy quote");
+  const token = (0, import_sun_sdk_core10.assertTronAddress)(input.token, "token");
+  const trxAmount = normalizeBaseUnitAmount(input.trxAmount, "trxAmount");
+  const state = await (0, import_sun_sdk_launchpad2.getLaunchpadTokenState)(runtime, token);
+  if (state === import_sun_sdk_launchpad2.LaunchpadTokenState.TRADING) {
+    return (0, import_sun_sdk_launchpad2.quoteLaunchpadBuyExactTrx)(runtime, token, trxAmount);
+  }
+  if (state === import_sun_sdk_launchpad2.LaunchpadTokenState.LAUNCHED) {
+    const path = pumpV2BuyPath(context, token);
+    const amounts = await readPumpV2AmountsOut(context, runtime, trxAmount, path);
+    return {
+      tokenAmount: requirePumpV2Amount(amounts, amounts.length - 1, "pump-v2-buy-quote"),
+      fee: "0"
+    };
+  }
+  throw new import_sun_sdk_core10.SDKError("SDK_CONTRACT_ERROR", "Token is not trading on SunPump", { token, state });
+}
+async function quotePumpBuyByToken(context, input) {
+  const runtime = requireRuntime(context, "Pump exact-token buy quote");
+  const token = (0, import_sun_sdk_core10.assertTronAddress)(input.token, "token");
+  const tokenAmount = normalizeBaseUnitAmount(input.tokenAmount, "tokenAmount");
+  const state = await (0, import_sun_sdk_launchpad2.getLaunchpadTokenState)(runtime, token);
+  if (state === import_sun_sdk_launchpad2.LaunchpadTokenState.TRADING) {
+    return (0, import_sun_sdk_launchpad2.quoteLaunchpadBuyExactToken)(runtime, token, tokenAmount);
+  }
+  if (state === import_sun_sdk_launchpad2.LaunchpadTokenState.LAUNCHED) {
+    const path = pumpV2BuyPath(context, token);
+    const amounts = await readPumpV2AmountsIn(context, runtime, tokenAmount, path);
+    return {
+      trxAmount: requirePumpV2Amount(amounts, 0, "pump-v2-buy-exact-token-quote"),
+      fee: "0"
+    };
+  }
+  throw new import_sun_sdk_core10.SDKError("SDK_CONTRACT_ERROR", "Token is not trading on SunPump", { token, state });
+}
+var PumpBuyClient = class {
+  constructor(context) {
+    this.context = context;
+  }
+  context;
+  quote(input) {
+    const candidate = input;
+    const hasTrxAmount = candidate.trxAmount !== void 0;
+    const hasTokenAmount = candidate.tokenAmount !== void 0;
+    if (hasTrxAmount === hasTokenAmount) {
+      throw new import_sun_sdk_core10.SDKError(
+        "SDK_INVALID_ARGUMENT",
+        "Pump buy quote requires exactly one of trxAmount or tokenAmount"
+      );
+    }
+    return hasTrxAmount ? quotePumpBuyByTrx(this.context, input) : quotePumpBuyByToken(this.context, input);
+  }
+  plan(input) {
+    return planPumpBuy(this.context, input);
+  }
+  executeAction(action) {
+    return executePlanAction(action, createPumpExecutor(this.context));
+  }
+  submit(plan) {
+    assertPumpPlan(plan, PUMP_BUY_OPERATIONS, "Pump buy");
+    return executePlanTransactions(plan, createPumpExecutor(this.context));
+  }
+  async execute(input) {
+    const plan = isTransactionPlan(input) ? input : await planPumpBuy(this.context, input);
+    assertPumpPlan(plan, PUMP_BUY_OPERATIONS, "Pump buy");
+    return executeTransactionPlan(plan, createPumpExecutor(this.context));
+  }
+};
+
+// src/pump/launch.ts
+var import_sun_sdk_core11 = require("@sun-protocol/sun-sdk-core");
+function planPumpAgentLaunch(context, input) {
+  const baseUrl = context.endpoints.sunPump;
+  if (!baseUrl) {
+    throw new import_sun_sdk_core11.SDKError("SDK_UNSUPPORTED_NETWORK", "SunPump API is unavailable on this network", {
+      network: context.network
+    });
+  }
+  const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
+  const transaction = (0, import_sun_sdk_core11.createHttpRequestAction)({
+    id: `pump-agent-launch-${input.symbol}`,
+    request: {
+      method: "POST",
+      url: `${normalizedBaseUrl}/ai/agentTokenLaunch`,
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json"
+      },
+      body: input
+    }
+  });
+  return {
+    id: nextPlanId(context, "pump-launch"),
+    kind: "pump",
+    network: context.network,
+    summary: {
+      title: "Launch SunPump token",
+      lines: [`Launch ${input.name} (${input.symbol})`]
+    },
+    approvals: [],
+    transactions: [transaction],
+    metadata: {
+      operation: "pump-agent-launch",
+      symbol: input.symbol
+    }
+  };
+}
+
+// src/pump/launch-client.ts
+var PUMP_LAUNCH_OPERATIONS = ["pump-agent-launch"];
+var PumpLaunchClient = class {
+  constructor(context) {
+    this.context = context;
+  }
+  context;
+  plan(input) {
+    return Promise.resolve(planPumpAgentLaunch(this.context, input));
+  }
+  executeAction(action) {
+    return executePlanAction(action, createPumpExecutor(this.context));
+  }
+  submit(plan) {
+    assertPumpPlan(plan, PUMP_LAUNCH_OPERATIONS, "Pump launch");
+    return executePlanTransactions(plan, createPumpExecutor(this.context));
+  }
+  async execute(input) {
+    const plan = isTransactionPlan(input) ? input : planPumpAgentLaunch(this.context, input);
+    assertPumpPlan(plan, PUMP_LAUNCH_OPERATIONS, "Pump launch");
+    return executeTransactionPlan(plan, createPumpExecutor(this.context));
+  }
+};
+
+// src/pump/sell.ts
+var import_sun_sdk_launchpad4 = require("@sun-protocol/sun-sdk-launchpad");
+var import_sun_sdk_core13 = require("@sun-protocol/sun-sdk-core");
+
+// src/pump/plan-sell.ts
+var import_sun_sdk_launchpad3 = require("@sun-protocol/sun-sdk-launchpad");
+var import_sun_sdk_core12 = require("@sun-protocol/sun-sdk-core");
+
+// src/internal/intents.ts
+function attachApprovalIntent(actions, scope, tokenSymbol) {
+  const intent = { kind: "approve", scope, tokenSymbol };
+  return actions.map((action) => action.execute === "runtime" ? { ...action, intent } : action);
+}
+
+// src/pump/plan-sell.ts
+async function planPumpSell(context, input) {
+  const runtime = requireRuntime(context, "Pump sell planning");
+  const { address: walletAddress } = await requireWalletSnapshot(context, "Pump sell planning");
+  const token = (0, import_sun_sdk_core12.assertTronAddress)(input.token, "token");
+  const tokenAmount = normalizeBaseUnitAmount(input.tokenAmount, "tokenAmount");
+  const state = await (0, import_sun_sdk_launchpad3.getLaunchpadTokenState)(runtime, token);
+  if (state !== import_sun_sdk_launchpad3.LaunchpadTokenState.TRADING && state !== import_sun_sdk_launchpad3.LaunchpadTokenState.LAUNCHED) {
+    throw new import_sun_sdk_core12.SDKError("SDK_CONTRACT_ERROR", "Token is not trading on SunPump", {
+      token,
+      state
+    });
+  }
+  const slippageBips = slippageToBips(input.slippage ?? "5%");
+  const approvalMode = input.approval ?? "auto";
+  const approvals = [];
+  const owner = input.owner !== void 0 ? (0, import_sun_sdk_core12.assertTronAddress)(input.owner, "owner") : walletAddress;
+  if (owner !== walletAddress) {
+    throw new import_sun_sdk_core12.SDKError("SDK_WALLET_ACCOUNT_MISMATCH", "Pump sell owner does not match the connected wallet", {
+      expectedAddress: owner,
+      actualAddress: walletAddress
+    });
+  }
+  let allowance;
+  const spender = state === import_sun_sdk_launchpad3.LaunchpadTokenState.TRADING ? context.chain.contracts.launchpad : context.chain.contracts.sunswapV2Router;
+  const scope = pumpIntentScope(
+    state === import_sun_sdk_launchpad3.LaunchpadTokenState.TRADING ? SUNPUMP_LAUNCHPAD_PROTOCOL_ID : SUNPUMP_V2_PROTOCOL_ID,
+    "sell-exact-token"
+  );
+  if (approvalMode !== "none") {
+    allowance = await (0, import_sun_sdk_launchpad3.readLaunchpadAllowance)(
+      runtime,
+      token,
+      owner,
+      spender
+    );
+    if (BigInt(allowance) < BigInt(tokenAmount)) {
+      approvals.push(state === import_sun_sdk_launchpad3.LaunchpadTokenState.TRADING ? (0, import_sun_sdk_launchpad3.createLaunchpadApproveAction)(token, spender) : (0, import_sun_sdk_core12.createApproveAction)({
+        id: `pump-v2-approve-${token}`,
+        target: token,
+        spender,
+        amount: tokenAmount
+      }));
+    }
+  }
+  if (state === import_sun_sdk_launchpad3.LaunchpadTokenState.TRADING) {
+    const quote = await (0, import_sun_sdk_launchpad3.quoteLaunchpadSellExactToken)(runtime, token, tokenAmount);
+    const minTrxOut2 = (0, import_sun_sdk_launchpad3.applySlippageMin)(BigInt(quote.trxAmount), slippageBips).toString();
+    const transaction2 = {
+      ...(0, import_sun_sdk_launchpad3.createLaunchpadSellAction)({
+        launchpad: context.chain.contracts.launchpad,
+        token,
+        tokenAmount,
+        minTrxOut: minTrxOut2
+      }),
+      intent: {
+        kind: "pump-sell",
+        scope,
+        token
+      }
+    };
+    return {
+      id: nextPlanId(context, "pump-sell"),
+      kind: "pump",
+      network: context.network,
+      owner,
+      summary: {
+        title: "Sell SunPump token",
+        lines: [`Sell ${tokenAmount} token units`, `Receive at least ${minTrxOut2} sun`]
+      },
+      approvals: attachApprovalIntent(approvals, scope, token),
+      transactions: [transaction2],
+      metadata: {
+        operation: "launchpad-sell-exact-token",
+        token,
+        tokenAmount,
+        quotedTrxAmount: quote.trxAmount,
+        fee: quote.fee,
+        minTrxOut: minTrxOut2,
+        slippageBips,
+        approvalMode,
+        spender,
+        ...owner ? { owner } : {},
+        ...allowance ? { allowance } : {}
+      }
+    };
+  }
+  const path = pumpV2SellPath(context, token);
+  const amounts = await readPumpV2AmountsOut(context, runtime, tokenAmount, path);
+  const quotedTrxAmount = requirePumpV2Amount(amounts, amounts.length - 1, "pump-v2-sell-exact-token");
+  const minTrxOut = (0, import_sun_sdk_launchpad3.applySlippageMin)(BigInt(quotedTrxAmount), slippageBips).toString();
+  const recipient = await normalizeRecipient(context, input.recipient, "Pump V2 sell recipient", owner);
+  const transactionValidForSeconds = normalizeTransactionValidForSeconds(input.transactionValidForSeconds);
+  const transaction = {
+    ...createDeferredV2SwapAction({
+      data: {
+        operation: "swap-exact-tokens-for-eth",
+        amountIn: tokenAmount,
+        amountOutMin: minTrxOut,
+        path,
+        recipient,
+        transactionValidForSeconds
+      }
+    }),
+    intent: {
+      kind: "pump-sell",
+      scope,
+      token
+    }
+  };
+  return {
+    id: nextPlanId(context, "pump-sell"),
+    kind: "pump",
+    network: context.network,
+    owner,
+    summary: {
+      title: "Sell launched Pump token",
+      lines: [`Sell ${tokenAmount} token units`, `Receive at least ${minTrxOut} sun`]
+    },
+    approvals: attachApprovalIntent(approvals, scope, token),
+    transactions: [transaction],
+    metadata: {
+      operation: "pump-v2-sell-exact-token",
+      token,
+      tokenAmount,
+      quotedTrxAmount,
+      minTrxOut,
+      slippageBips,
+      approvalMode,
+      spender,
+      path,
+      recipient,
+      transactionValidForSeconds,
+      ...owner ? { owner } : {},
+      ...allowance ? { allowance } : {}
+    }
+  };
+}
+
+// src/pump/sell.ts
+var PUMP_SELL_OPERATIONS = [
+  "launchpad-sell-exact-token",
+  "pump-v2-sell-exact-token"
+];
+async function quotePumpSell(context, input) {
+  const runtime = requireRuntime(context, "Pump sell quote");
+  const token = (0, import_sun_sdk_core13.assertTronAddress)(input.token, "token");
+  const tokenAmount = normalizeBaseUnitAmount(input.tokenAmount, "tokenAmount");
+  const state = await (0, import_sun_sdk_launchpad4.getLaunchpadTokenState)(runtime, token);
+  if (state === import_sun_sdk_launchpad4.LaunchpadTokenState.TRADING) {
+    return (0, import_sun_sdk_launchpad4.quoteLaunchpadSellExactToken)(runtime, token, tokenAmount);
+  }
+  if (state === import_sun_sdk_launchpad4.LaunchpadTokenState.LAUNCHED) {
+    const path = pumpV2SellPath(context, token);
+    const amounts = await readPumpV2AmountsOut(context, runtime, tokenAmount, path);
+    return {
+      trxAmount: requirePumpV2Amount(amounts, amounts.length - 1, "pump-v2-sell-quote"),
+      fee: "0"
+    };
+  }
+  throw new import_sun_sdk_core13.SDKError("SDK_CONTRACT_ERROR", "Token is not trading on SunPump", { token, state });
+}
+var PumpSellClient = class {
+  constructor(context) {
+    this.context = context;
+  }
+  context;
+  quote(input) {
+    return quotePumpSell(this.context, input);
+  }
+  plan(input) {
+    return planPumpSell(this.context, input);
+  }
+  executeAction(action) {
+    return executePlanAction(action, createPumpExecutor(this.context));
+  }
+  submit(plan) {
+    assertPumpPlan(plan, PUMP_SELL_OPERATIONS, "Pump sell");
+    return executePlanTransactions(plan, createPumpExecutor(this.context));
+  }
+  async execute(input) {
+    const plan = isTransactionPlan(input) ? input : await planPumpSell(this.context, input);
+    assertPumpPlan(plan, PUMP_SELL_OPERATIONS, "Pump sell");
+    return executeTransactionPlan(plan, createPumpExecutor(this.context));
+  }
+};
+
+// src/pump/client.ts
+var PumpClient = class {
+  constructor(context) {
+    this.context = context;
+    this.buy = new PumpBuyClient(context);
+    this.sell = new PumpSellClient(context);
+    this.launch = new PumpLaunchClient(context);
+  }
+  context;
+  buy;
+  sell;
+  launch;
+  tokens = {
+    list: async (query = {}) => this.requireApi().listTokens(query),
+    get: async (token) => this.requireApi().getToken(token),
+    search: async (query = {}) => this.requireApi().searchTokens(query),
+    searchV2: async (query = {}) => this.requireApi().searchTokensV2(query),
+    byOwner: async (query) => this.requireApi().tokensByOwner(query),
+    holders: async (query) => this.requireApi().tokenHolders(query),
+    holdersV2: async (query) => this.requireApi().tokenHoldersV2(query),
+    favors: async (query) => this.requireApi().userFavors(query),
+    ranking: async (query) => this.requireApi().ranking(query),
+    kingOfHill: async () => this.requireApi().kingOfHill(),
+    pumpList: async () => this.requireApi().pumpTokenList(),
+    transactions: async (token, query = {}) => this.requireApi().tokenTransactions(token, query),
+    ownerTransactions: async (owner, query = {}) => this.requireApi().userTransactions(owner, query)
+  };
+  state(input) {
+    return (0, import_sun_sdk_launchpad5.getLaunchpadTokenState)(
+      requireRuntime(this.context, "Pump state read"),
+      (0, import_sun_sdk_core14.assertTronAddress)(input.token, "token")
+    );
+  }
+  info(input) {
+    return (0, import_sun_sdk_launchpad5.getLaunchpadTokenInfo)(
+      requireRuntime(this.context, "Pump token info read"),
+      (0, import_sun_sdk_core14.assertTronAddress)(input.token, "token")
+    );
+  }
+  balance(input) {
+    return (0, import_sun_sdk_launchpad5.getLaunchpadTokenBalance)(
+      requireRuntime(this.context, "Pump balance read"),
+      (0, import_sun_sdk_core14.assertTronAddress)(input.token, "token"),
+      input.owner
+    );
+  }
+  allowance(input) {
+    return (0, import_sun_sdk_launchpad5.readLaunchpadAllowance)(
+      requireRuntime(this.context, "Pump allowance read"),
+      (0, import_sun_sdk_core14.assertTronAddress)(input.token, "token"),
+      input.owner,
+      input.spender ?? this.context.chain.contracts.launchpad
+    );
+  }
+  async portfolio(owner, query = {}) {
+    return this.requireApi().portfolio(owner, query);
+  }
+  requireApi() {
+    if (!this.context.sunPumpApi) {
+      throw new import_sun_sdk_core14.SDKError("SDK_UNSUPPORTED_NETWORK", "SunPump API is unavailable on this network", {
+        network: this.context.network
+      });
+    }
+    return this.context.sunPumpApi;
+  }
+};
+function createPumpClient(context) {
+  return new PumpClient(context);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PumpBuyClient,
+  PumpClient,
+  PumpLaunchClient,
+  PumpSellClient,
+  SUNPUMP_LAUNCHPAD_PROTOCOL_ID,
+  SUNPUMP_V2_PROTOCOL_ID,
+  createPumpClient,
+  createPumpExecutor,
+  planPumpAgentLaunch,
+  planPumpBuy,
+  planPumpSell
+});
+//# sourceMappingURL=index.cjs.map