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

package/dist/chunk-HD2S3Q7L.js

@@ -0,0 +1,746 @@
+import {
+  createDeferredV2SwapAction,
+  createV2SwapExecutor
+} from "./chunk-TSHXXRH2.js";
+import {
+  attachApprovalIntent,
+  executePlanAction,
+  executePlanTransactions,
+  executeTransactionPlan,
+  isTransactionPlan,
+  nextPlanId,
+  normalizeBaseUnitAmount,
+  normalizeRecipient,
+  normalizeTransactionValidForSeconds,
+  requireRuntime,
+  requireWalletSnapshot,
+  slippageToBips
+} from "./chunk-VFVKMC4H.js";
+
+// src/pump/execute.ts
+function createPumpExecutor(context) {
+  return createV2SwapExecutor(context);
+}
+
+// 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
+import {
+  applySlippageMax,
+  applySlippageMin,
+  createLaunchpadBuyAction,
+  getLaunchpadTokenState,
+  LaunchpadTokenState,
+  quoteLaunchpadBuyExactToken,
+  quoteLaunchpadBuyExactTrx
+} from "@sun-protocol/sun-sdk-launchpad";
+import { SDKError as SDKError2, assertTronAddress } from "@sun-protocol/sun-sdk-core";
+
+// src/pump/v2.ts
+import {
+  buildV2RouterAmountsInRead,
+  buildV2RouterAmountsOutRead,
+  normalizeV2AmountsResult
+} from "@sun-protocol/sun-sdk-sunswap-v2";
+import { SDKError } from "@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(
+    buildV2RouterAmountsOutRead({
+      network: context.network,
+      amountIn,
+      path
+    })
+  );
+  return normalizeV2AmountsResult(result);
+}
+async function readPumpV2AmountsIn(context, runtime, amountOut, path) {
+  const result = await runtime.readContract(
+    buildV2RouterAmountsInRead({
+      network: context.network,
+      amountOut,
+      path
+    })
+  );
+  return normalizeV2AmountsResult(result);
+}
+function requirePumpV2Amount(amounts, index, operation) {
+  const amount = amounts[index];
+  if (amount === void 0) {
+    throw new SDKError("SDK_NO_ROUTE", "SunSwap V2 returned no Pump route amount", {
+      operation,
+      index,
+      amounts
+    });
+  }
+  return amount;
+}
+
+// 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 SDKError2("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 SDKError2("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 = assertTronAddress(input.token, "token");
+  const mode = normalizePumpBuyMode(input);
+  const state = await getLaunchpadTokenState(runtime, token);
+  if (state !== LaunchpadTokenState.TRADING && state !== LaunchpadTokenState.LAUNCHED) {
+    throw new SDKError2("SDK_CONTRACT_ERROR", "Token is not trading on SunPump", {
+      token,
+      state
+    });
+  }
+  const slippageBips = slippageToBips(input.slippage ?? "5%");
+  if (state === LaunchpadTokenState.TRADING) {
+    let trxAmount;
+    let quotedTokenAmount;
+    let fee;
+    let operation;
+    let requestedTokenAmount;
+    if (mode.kind === "exact-trx") {
+      const quote = await quoteLaunchpadBuyExactTrx(runtime, token, mode.trxAmount);
+      trxAmount = mode.trxAmount;
+      quotedTokenAmount = quote.tokenAmount;
+      fee = quote.fee;
+      operation = "launchpad-buy-exact-trx";
+    } else {
+      const quote = await quoteLaunchpadBuyExactToken(runtime, token, mode.tokenAmount);
+      trxAmount = quote.trxAmount;
+      quotedTokenAmount = mode.tokenAmount;
+      fee = quote.fee;
+      operation = "launchpad-buy-exact-token";
+      requestedTokenAmount = mode.tokenAmount;
+    }
+    const minTokenOut = applySlippageMin(BigInt(quotedTokenAmount), slippageBips).toString();
+    const transaction2 = {
+      ...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 = 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 = 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/buy.ts
+import {
+  getLaunchpadTokenState as getLaunchpadTokenState2,
+  LaunchpadTokenState as LaunchpadTokenState2,
+  quoteLaunchpadBuyExactToken as quoteLaunchpadBuyExactToken2,
+  quoteLaunchpadBuyExactTrx as quoteLaunchpadBuyExactTrx2
+} from "@sun-protocol/sun-sdk-launchpad";
+import {
+  SDKError as SDKError4,
+  assertTronAddress as assertTronAddress2
+} from "@sun-protocol/sun-sdk-core";
+
+// src/pump/workflow.ts
+import { SDKError as SDKError3 } from "@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 SDKError3("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 = assertTronAddress2(input.token, "token");
+  const trxAmount = normalizeBaseUnitAmount(input.trxAmount, "trxAmount");
+  const state = await getLaunchpadTokenState2(runtime, token);
+  if (state === LaunchpadTokenState2.TRADING) {
+    return quoteLaunchpadBuyExactTrx2(runtime, token, trxAmount);
+  }
+  if (state === LaunchpadTokenState2.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 SDKError4("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 = assertTronAddress2(input.token, "token");
+  const tokenAmount = normalizeBaseUnitAmount(input.tokenAmount, "tokenAmount");
+  const state = await getLaunchpadTokenState2(runtime, token);
+  if (state === LaunchpadTokenState2.TRADING) {
+    return quoteLaunchpadBuyExactToken2(runtime, token, tokenAmount);
+  }
+  if (state === LaunchpadTokenState2.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 SDKError4("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 SDKError4(
+        "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
+import { createHttpRequestAction, SDKError as SDKError5 } from "@sun-protocol/sun-sdk-core";
+function planPumpAgentLaunch(context, input) {
+  const baseUrl = context.endpoints.sunPump;
+  if (!baseUrl) {
+    throw new SDKError5("SDK_UNSUPPORTED_NETWORK", "SunPump API is unavailable on this network", {
+      network: context.network
+    });
+  }
+  const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
+  const transaction = 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/plan-sell.ts
+import {
+  applySlippageMin as applySlippageMin2,
+  createLaunchpadApproveAction,
+  createLaunchpadSellAction,
+  getLaunchpadTokenState as getLaunchpadTokenState3,
+  LaunchpadTokenState as LaunchpadTokenState3,
+  quoteLaunchpadSellExactToken,
+  readLaunchpadAllowance
+} from "@sun-protocol/sun-sdk-launchpad";
+import {
+  SDKError as SDKError6,
+  assertTronAddress as assertTronAddress3,
+  createApproveAction
+} from "@sun-protocol/sun-sdk-core";
+async function planPumpSell(context, input) {
+  const runtime = requireRuntime(context, "Pump sell planning");
+  const { address: walletAddress } = await requireWalletSnapshot(context, "Pump sell planning");
+  const token = assertTronAddress3(input.token, "token");
+  const tokenAmount = normalizeBaseUnitAmount(input.tokenAmount, "tokenAmount");
+  const state = await getLaunchpadTokenState3(runtime, token);
+  if (state !== LaunchpadTokenState3.TRADING && state !== LaunchpadTokenState3.LAUNCHED) {
+    throw new SDKError6("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 ? assertTronAddress3(input.owner, "owner") : walletAddress;
+  if (owner !== walletAddress) {
+    throw new SDKError6("SDK_WALLET_ACCOUNT_MISMATCH", "Pump sell owner does not match the connected wallet", {
+      expectedAddress: owner,
+      actualAddress: walletAddress
+    });
+  }
+  let allowance;
+  const spender = state === LaunchpadTokenState3.TRADING ? context.chain.contracts.launchpad : context.chain.contracts.sunswapV2Router;
+  const scope = pumpIntentScope(
+    state === LaunchpadTokenState3.TRADING ? SUNPUMP_LAUNCHPAD_PROTOCOL_ID : SUNPUMP_V2_PROTOCOL_ID,
+    "sell-exact-token"
+  );
+  if (approvalMode !== "none") {
+    allowance = await readLaunchpadAllowance(
+      runtime,
+      token,
+      owner,
+      spender
+    );
+    if (BigInt(allowance) < BigInt(tokenAmount)) {
+      approvals.push(state === LaunchpadTokenState3.TRADING ? createLaunchpadApproveAction(token, spender) : createApproveAction({
+        id: `pump-v2-approve-${token}`,
+        target: token,
+        spender,
+        amount: tokenAmount
+      }));
+    }
+  }
+  if (state === LaunchpadTokenState3.TRADING) {
+    const quote = await quoteLaunchpadSellExactToken(runtime, token, tokenAmount);
+    const minTrxOut2 = applySlippageMin2(BigInt(quote.trxAmount), slippageBips).toString();
+    const transaction2 = {
+      ...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 = applySlippageMin2(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
+import {
+  getLaunchpadTokenState as getLaunchpadTokenState4,
+  LaunchpadTokenState as LaunchpadTokenState4,
+  quoteLaunchpadSellExactToken as quoteLaunchpadSellExactToken2
+} from "@sun-protocol/sun-sdk-launchpad";
+import {
+  SDKError as SDKError7,
+  assertTronAddress as assertTronAddress4
+} from "@sun-protocol/sun-sdk-core";
+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 = assertTronAddress4(input.token, "token");
+  const tokenAmount = normalizeBaseUnitAmount(input.tokenAmount, "tokenAmount");
+  const state = await getLaunchpadTokenState4(runtime, token);
+  if (state === LaunchpadTokenState4.TRADING) {
+    return quoteLaunchpadSellExactToken2(runtime, token, tokenAmount);
+  }
+  if (state === LaunchpadTokenState4.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 SDKError7("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
+import {
+  getLaunchpadTokenBalance,
+  getLaunchpadTokenInfo,
+  getLaunchpadTokenState as getLaunchpadTokenState5,
+  readLaunchpadAllowance as readLaunchpadAllowance2
+} from "@sun-protocol/sun-sdk-launchpad";
+import { SDKError as SDKError8, assertTronAddress as assertTronAddress5 } from "@sun-protocol/sun-sdk-core";
+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 getLaunchpadTokenState5(
+      requireRuntime(this.context, "Pump state read"),
+      assertTronAddress5(input.token, "token")
+    );
+  }
+  info(input) {
+    return getLaunchpadTokenInfo(
+      requireRuntime(this.context, "Pump token info read"),
+      assertTronAddress5(input.token, "token")
+    );
+  }
+  balance(input) {
+    return getLaunchpadTokenBalance(
+      requireRuntime(this.context, "Pump balance read"),
+      assertTronAddress5(input.token, "token"),
+      input.owner
+    );
+  }
+  allowance(input) {
+    return readLaunchpadAllowance2(
+      requireRuntime(this.context, "Pump allowance read"),
+      assertTronAddress5(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 SDKError8("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);
+}
+
+export {
+  createPumpExecutor,
+  SUNPUMP_LAUNCHPAD_PROTOCOL_ID,
+  SUNPUMP_V2_PROTOCOL_ID,
+  planPumpBuy,
+  PumpBuyClient,
+  planPumpAgentLaunch,
+  PumpLaunchClient,
+  planPumpSell,
+  PumpSellClient,
+  PumpClient,
+  createPumpClient
+};
+//# sourceMappingURL=chunk-HD2S3Q7L.js.map