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

package/dist/chunk-PEGREDLT.js

@@ -0,0 +1,935 @@
+import {
+  methodParametersToAction,
+  resolveV3PoolState
+} from "./chunk-L5TZCDPH.js";
+import {
+  assertUsdtTransfer
+} from "./chunk-5XDX5563.js";
+import {
+  evmHexToTronAddress,
+  normalizeLiquidityPercentage,
+  readMulticallRequired,
+  readRequiredContract,
+  tronAddressToEvmAddress
+} from "./chunk-C2YCVBPI.js";
+import {
+  applySlippageMin,
+  createContextExecutor,
+  executeTransactionPlan,
+  nextPlanId,
+  normalizeBaseUnitAmount,
+  normalizeDeadline,
+  normalizeRecipient,
+  parseSlippage,
+  requireWalletAddress,
+  resolveProtocolContract,
+  slippageToBips
+} from "./chunk-VFVKMC4H.js";
+
+// src/positions/execute.ts
+import { SDKError } from "@sun-protocol/sun-sdk-core";
+async function assertV3PositionUsdtTransfer(context, action) {
+  await assertUsdtTransfer(context, action);
+}
+function createV3PositionsExecutor(context) {
+  const executor = createContextExecutor(context);
+  return {
+    ...executor,
+    sendAction: async (action) => {
+      await assertV3PositionUsdtTransfer(context, action);
+      if (!executor.sendAction) throw new SDKError("SDK_RUNTIME_ERROR", "V3 position execution requires a runtime");
+      return executor.sendAction(action);
+    }
+  };
+}
+
+// src/positions/intents.ts
+var SUNSWAP_V3_POSITION_PROTOCOL_ID = "sunswap-v3";
+var SUNSWAP_V4_POSITION_PROTOCOL_ID = "sunswap-v4";
+function positionIntentScope(protocol, operation) {
+  return { domain: "position", protocol, operation };
+}
+
+// src/positions/v3.ts
+import {
+  CurrencyAmount,
+  Percent,
+  SDKError as SDKError3,
+  Token,
+  assertTronAddress as assertTronAddress2
+} from "@sun-protocol/sun-sdk-core";
+import {
+  buildV3PositionApprovalForAllRead,
+  buildV3PositionReads,
+  computeV3PoolAddress,
+  NonfungiblePositionManager,
+  Pool,
+  Position
+} from "@sun-protocol/sun-sdk-sunswap-v3";
+
+// src/internal/positions.ts
+import {
+  SDKError as SDKError2,
+  assertTronAddress
+} from "@sun-protocol/sun-sdk-core";
+function assertPositionAuthorized(input) {
+  const wallet = assertTronAddress(input.wallet, "wallet");
+  const owner = assertTronAddress(input.owner, "owner");
+  const approved = input.approved ? assertTronAddress(input.approved, "approved") : void 0;
+  if (wallet === owner || wallet === approved || input.operatorApproved === true) return;
+  throw new SDKError2("SDK_WALLET_CAPABILITY_ERROR", "Wallet is not authorized for this position", {
+    tokenId: input.tokenId,
+    owner,
+    wallet,
+    operator: wallet
+  });
+}
+
+// src/positions/v3.ts
+function integerString(value, label) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "bigint") {
+    return BigInt(value.toString()).toString();
+  }
+  throw new SDKError3("SDK_CONTRACT_ERROR", `${label} must be an integer-like contract result`, { value });
+}
+function integerNumber(value, label) {
+  const parsed = Number(integerString(value, label));
+  if (!Number.isSafeInteger(parsed)) {
+    throw new SDKError3("SDK_CONTRACT_ERROR", `${label} must be a safe integer`, { value });
+  }
+  return parsed;
+}
+function unwrapSingle(value) {
+  return Array.isArray(value) && value.length === 1 ? value[0] : value;
+}
+function parsePositionAddress(value, label) {
+  const raw = String(unwrapSingle(value));
+  try {
+    return assertTronAddress2(raw, label);
+  } catch {
+    const evmHex = /^41[0-9a-fA-F]{40}$/.test(raw) ? `0x${raw.slice(2)}` : raw;
+    return evmHexToTronAddress(evmHex, label);
+  }
+}
+function normalizePositionToken(context, value, label) {
+  if (typeof value !== "string") {
+    throw new SDKError3("SDK_CONTRACT_ERROR", `${label} must be an address string`, { value });
+  }
+  const publicAddress = parsePositionAddress(value, label);
+  const evmAddress = tronAddressToEvmAddress(publicAddress, label);
+  return {
+    publicAddress,
+    token: new Token(context.chain.uniswapChainId, evmAddress, 6, void 0, void 0, true)
+  };
+}
+function parsePositionResult(context, tokenId, result, owner, approved, operatorApproved) {
+  let token0;
+  let token1;
+  let fee;
+  let tickLower;
+  let tickUpper;
+  let liquidity;
+  let tokensOwed0;
+  let tokensOwed1;
+  if (Array.isArray(result)) {
+    token0 = result[2];
+    token1 = result[3];
+    fee = result[4];
+    tickLower = result[5];
+    tickUpper = result[6];
+    liquidity = result[7];
+    tokensOwed0 = result[10];
+    tokensOwed1 = result[11];
+  } else if (typeof result === "object" && result !== null) {
+    const position = result;
+    token0 = position.token0;
+    token1 = position.token1;
+    fee = position.fee;
+    tickLower = position.tickLower;
+    tickUpper = position.tickUpper;
+    liquidity = position.liquidity;
+    tokensOwed0 = position.tokensOwed0;
+    tokensOwed1 = position.tokensOwed1;
+  } else {
+    throw new SDKError3("SDK_CONTRACT_ERROR", "V3 position result is malformed", { result });
+  }
+  const token0Info = normalizePositionToken(context, token0, "token0");
+  const token1Info = normalizePositionToken(context, token1, "token1");
+  return {
+    protocol: "sunswap-v3",
+    tokenId,
+    owner,
+    ...approved !== void 0 ? { approved } : {},
+    ...operatorApproved !== void 0 ? { operatorApproved } : {},
+    token0: token0Info.publicAddress,
+    token1: token1Info.publicAddress,
+    fee: integerNumber(fee, "fee"),
+    tickLower: integerNumber(tickLower, "tickLower"),
+    tickUpper: integerNumber(tickUpper, "tickUpper"),
+    liquidity: integerString(liquidity, "liquidity"),
+    tokensOwed0: integerString(tokensOwed0, "tokensOwed0"),
+    tokensOwed1: integerString(tokensOwed1, "tokensOwed1"),
+    token0Entity: token0Info.token,
+    token1Entity: token1Info.token
+  };
+}
+function removePercentage(input, snapshot) {
+  if (input.percentage !== void 0) return normalizeLiquidityPercentage(input.percentage, "percentage");
+  const liquidity = BigInt(normalizeBaseUnitAmount(input.liquidity, "liquidity"));
+  const total = BigInt(snapshot.liquidity);
+  if (liquidity > total) {
+    throw new SDKError3("SDK_INVALID_ARGUMENT", "liquidity cannot exceed position liquidity", {
+      liquidity: liquidity.toString(),
+      totalLiquidity: total.toString()
+    });
+  }
+  return new Percent(liquidity.toString(), total.toString());
+}
+function currencyForCollect(context, token, publicAddress, receiveNative) {
+  return receiveNative && publicAddress === context.chain.contracts.wtrx ? context.chain.nativeCurrency : token;
+}
+var V3PositionsClient = class {
+  constructor(context) {
+    this.context = context;
+  }
+  context;
+  async read(input) {
+    const tokenId = normalizeBaseUnitAmount(input.tokenId, "tokenId");
+    const [positionResult, ownerResult, approvedResult] = await readMulticallRequired(
+      this.context,
+      buildV3PositionReads({
+        network: this.context.network,
+        tokenId,
+        positionManager: resolveProtocolContract(this.context, input.contracts, "sunswapV3PositionManager")
+      }),
+      "V3 position read"
+    );
+    const owner = parsePositionAddress(ownerResult, "owner");
+    const approved = approvedResult ? parsePositionAddress(approvedResult, "approved") : void 0;
+    const operator = input.operator ? assertTronAddress2(input.operator, "operator") : void 0;
+    const operatorApproved = operator ? Boolean(await readRequiredContract(
+      this.context,
+      buildV3PositionApprovalForAllRead({
+        network: this.context.network,
+        owner,
+        operator,
+        positionManager: resolveProtocolContract(this.context, input.contracts, "sunswapV3PositionManager")
+      }),
+      "V3 position operator approval read"
+    )) : void 0;
+    const snapshot = parsePositionResult(
+      this.context,
+      tokenId,
+      positionResult,
+      owner,
+      approved,
+      operatorApproved
+    );
+    return {
+      protocol: snapshot.protocol,
+      tokenId: snapshot.tokenId,
+      owner: snapshot.owner,
+      ...snapshot.approved !== void 0 ? { approved: snapshot.approved } : {},
+      ...snapshot.operatorApproved !== void 0 ? { operatorApproved: snapshot.operatorApproved } : {},
+      token0: snapshot.token0,
+      token1: snapshot.token1,
+      fee: snapshot.fee,
+      tickLower: snapshot.tickLower,
+      tickUpper: snapshot.tickUpper,
+      liquidity: snapshot.liquidity,
+      tokensOwed0: snapshot.tokensOwed0,
+      tokensOwed1: snapshot.tokensOwed1
+    };
+  }
+  remove = {
+    plan: async (input) => this.planRemove(input),
+    execute: async (input) => executeTransactionPlan(await this.planRemove(input), createV3PositionsExecutor(this.context))
+  };
+  collect = {
+    plan: async (input) => this.planCollect(input),
+    execute: async (input) => executeTransactionPlan(await this.planCollect(input), createV3PositionsExecutor(this.context))
+  };
+  usdtTransferContext(snapshot, positionManager, input) {
+    const { network, chain } = this.context;
+    const usdtAddress = chain.contracts.usdt;
+    const transfersUsdt = snapshot.token0 === usdtAddress || snapshot.token1 === usdtAddress;
+    const sources = [];
+    const factory = resolveProtocolContract(this.context, input.contracts, "sunswapV3Factory");
+    if (transfersUsdt && positionManager === chain.contracts.sunswapV3PositionManager && factory === chain.contracts.sunswapV3Factory) {
+      sources.push({
+        address: computeV3PoolAddress({ network, tokenA: snapshot.token0, tokenB: snapshot.token1, fee: snapshot.fee, factory }),
+        role: "v3-pool"
+      });
+      sources.push({ address: positionManager, role: "position-manager" });
+    }
+    return { network, transfersUsdt, sources };
+  }
+  async readAuthorizedPosition(tokenId, operation, positionManager, validationMode) {
+    const wallet = await requireWalletAddress(this.context, operation);
+    const [positionResult, ownerResult, approvedResult] = await readMulticallRequired(
+      this.context,
+      buildV3PositionReads({ network: this.context.network, tokenId, positionManager }),
+      operation
+    );
+    const owner = parsePositionAddress(ownerResult, "owner");
+    const approved = approvedResult ? parsePositionAddress(approvedResult, "approved") : void 0;
+    const operatorApproved = validationMode === "legacy" ? void 0 : Boolean(await readRequiredContract(
+      this.context,
+      buildV3PositionApprovalForAllRead({ network: this.context.network, owner, operator: wallet, positionManager }),
+      `${operation} operator approval read`
+    ));
+    if (validationMode !== "legacy") {
+      assertPositionAuthorized({
+        tokenId,
+        wallet,
+        owner,
+        ...approved !== void 0 ? { approved } : {},
+        ...operatorApproved !== void 0 ? { operatorApproved } : {}
+      });
+    }
+    return {
+      wallet,
+      snapshot: parsePositionResult(this.context, tokenId, positionResult, owner, approved, operatorApproved)
+    };
+  }
+  async planRemove(input) {
+    const positionManager = resolveProtocolContract(this.context, input.contracts, "sunswapV3PositionManager");
+    const planId = nextPlanId(this.context, "position-v3-remove");
+    const tokenId = normalizeBaseUnitAmount(input.tokenId, "tokenId");
+    const { wallet, snapshot } = await this.readAuthorizedPosition(
+      tokenId,
+      "V3 remove position",
+      positionManager,
+      input.validationMode
+    );
+    const recipient = await normalizeRecipient(this.context, input.recipient, "V3 remove position", wallet);
+    const deadline = normalizeDeadline(this.context, input);
+    const slippage = parseSlippage(input.slippage ?? "0.5%");
+    const poolDerived = input.pool === void 0;
+    const poolState = input.pool ?? await resolveV3PoolState(this.context, {
+      tokenA: snapshot.token0,
+      tokenB: snapshot.token1,
+      fee: snapshot.fee,
+      contracts: input.contracts
+    });
+    const pool = new Pool({
+      tokenA: snapshot.token0Entity,
+      tokenB: snapshot.token1Entity,
+      fee: snapshot.fee,
+      sqrtRatioX96: normalizeBaseUnitAmount(poolState.sqrtRatioX96, "sqrtRatioX96"),
+      liquidity: normalizeBaseUnitAmount(poolState.liquidity, "pool liquidity", { allowZero: true }),
+      tickCurrent: poolState.tickCurrent,
+      ...poolState.tickSpacing !== void 0 ? { tickSpacing: poolState.tickSpacing } : {}
+    });
+    const position = new Position({
+      pool,
+      tickLower: snapshot.tickLower,
+      tickUpper: snapshot.tickUpper,
+      liquidity: snapshot.liquidity
+    });
+    const token0 = assertTronAddress2(snapshot.token0, "token0");
+    const token1 = assertTronAddress2(snapshot.token1, "token1");
+    const expectedCurrencyOwed0 = CurrencyAmount.fromRawAmount(
+      currencyForCollect(this.context, snapshot.token0Entity, token0, input.receiveNative),
+      input.expectedCurrencyOwed0 !== void 0 ? normalizeBaseUnitAmount(input.expectedCurrencyOwed0, "expectedCurrencyOwed0", { allowZero: true }) : snapshot.tokensOwed0
+    );
+    const expectedCurrencyOwed1 = CurrencyAmount.fromRawAmount(
+      currencyForCollect(this.context, snapshot.token1Entity, token1, input.receiveNative),
+      input.expectedCurrencyOwed1 !== void 0 ? normalizeBaseUnitAmount(input.expectedCurrencyOwed1, "expectedCurrencyOwed1", { allowZero: true }) : snapshot.tokensOwed1
+    );
+    const methodParameters = NonfungiblePositionManager.removeCallParameters(position, {
+      tokenId,
+      liquidityPercentage: removePercentage(input, snapshot),
+      slippageTolerance: slippage,
+      deadline,
+      ...input.burnToken !== void 0 ? { burnToken: input.burnToken } : {},
+      collectOptions: {
+        recipient: tronAddressToEvmAddress(recipient, "recipient"),
+        expectedCurrencyOwed0,
+        expectedCurrencyOwed1
+      }
+    });
+    const action = methodParametersToAction({
+      id: `${planId}-tx`,
+      target: positionManager,
+      methodParameters,
+      metadata: { usdtTransfer: this.usdtTransferContext(snapshot, positionManager, input) },
+      ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {},
+      intent: {
+        kind: "remove-liquidity",
+        scope: positionIntentScope(SUNSWAP_V3_POSITION_PROTOCOL_ID, "remove-position"),
+        positionId: tokenId
+      }
+    });
+    return {
+      id: planId,
+      kind: "position",
+      network: this.context.network,
+      owner: wallet,
+      summary: { title: "Remove SunSwap V3 position liquidity", lines: [`Position ${tokenId}`, `Recipient ${recipient}`] },
+      approvals: [],
+      transactions: [action],
+      metadata: {
+        protocol: "sunswap-v3",
+        operation: "remove-position",
+        tokenId,
+        owner: snapshot.owner,
+        recipient,
+        deadline,
+        slippageBips: slippageToBips(input.slippage ?? "0.5%"),
+        positionDerived: true,
+        poolDerived
+      }
+    };
+  }
+  async planCollect(input) {
+    const positionManager = resolveProtocolContract(this.context, input.contracts, "sunswapV3PositionManager");
+    const planId = nextPlanId(this.context, "position-v3-collect");
+    const tokenId = normalizeBaseUnitAmount(input.tokenId, "tokenId");
+    const { wallet, snapshot } = await this.readAuthorizedPosition(
+      tokenId,
+      "V3 collect position",
+      positionManager,
+      input.validationMode
+    );
+    const recipient = await normalizeRecipient(this.context, input.recipient, "V3 collect position", wallet);
+    const token0 = assertTronAddress2(snapshot.token0, "token0");
+    const token1 = assertTronAddress2(snapshot.token1, "token1");
+    const methodParameters = NonfungiblePositionManager.collectCallParameters({
+      tokenId,
+      recipient: tronAddressToEvmAddress(recipient, "recipient"),
+      expectedCurrencyOwed0: CurrencyAmount.fromRawAmount(
+        currencyForCollect(this.context, snapshot.token0Entity, token0, input.receiveNative),
+        input.expectedCurrencyOwed0 !== void 0 ? normalizeBaseUnitAmount(input.expectedCurrencyOwed0, "expectedCurrencyOwed0", { allowZero: true }) : snapshot.tokensOwed0
+      ),
+      expectedCurrencyOwed1: CurrencyAmount.fromRawAmount(
+        currencyForCollect(this.context, snapshot.token1Entity, token1, input.receiveNative),
+        input.expectedCurrencyOwed1 !== void 0 ? normalizeBaseUnitAmount(input.expectedCurrencyOwed1, "expectedCurrencyOwed1", { allowZero: true }) : snapshot.tokensOwed1
+      )
+    });
+    const action = methodParametersToAction({
+      id: `${planId}-tx`,
+      target: positionManager,
+      methodParameters,
+      metadata: { usdtTransfer: this.usdtTransferContext(snapshot, positionManager, input) },
+      ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {},
+      intent: {
+        kind: "collect-fees",
+        scope: positionIntentScope(SUNSWAP_V3_POSITION_PROTOCOL_ID, "collect-position"),
+        positionId: tokenId
+      }
+    });
+    return {
+      id: planId,
+      kind: "position",
+      network: this.context.network,
+      owner: wallet,
+      summary: { title: "Collect SunSwap V3 position fees", lines: [`Position ${tokenId}`, `Recipient ${recipient}`] },
+      approvals: [],
+      transactions: [action],
+      metadata: {
+        protocol: "sunswap-v3",
+        operation: "collect-position",
+        tokenId,
+        owner: snapshot.owner,
+        recipient
+      }
+    };
+  }
+};
+
+// src/positions/v4.ts
+import {
+  SDKError as SDKError4,
+  assertTronAddress as assertTronAddress3
+} from "@sun-protocol/sun-sdk-core";
+import { TickMath } from "@sun-protocol/sun-sdk-sunswap-v3";
+import {
+  buildV4CollectAction,
+  buildV4DecreaseLiquidityAction,
+  buildV4MulticallAction,
+  buildV4PositionApprovalForAllRead,
+  buildV4PositionFeesRead,
+  buildV4PositionReads,
+  buildV4PoolSlot0Read,
+  computeV4PoolId,
+  createV4PoolKey,
+  encodeV4ContractCallAction
+} from "@sun-protocol/sun-sdk-sunswap-v4";
+var Q96 = 1n << 96n;
+function parseString(value, label) {
+  if (typeof value === "bigint" || typeof value === "number" || typeof value === "string") {
+    return BigInt(value.toString()).toString();
+  }
+  throw new SDKError4("SDK_CONTRACT_ERROR", `${label} must be an integer-like contract result`, { value });
+}
+function parseNumber(value, label) {
+  const parsed = Number(parseString(value, label));
+  if (!Number.isSafeInteger(parsed)) {
+    throw new SDKError4("SDK_CONTRACT_ERROR", `${label} must be a safe integer`, { value });
+  }
+  return parsed;
+}
+function unwrapSingle2(value) {
+  return Array.isArray(value) && value.length === 1 ? value[0] : value;
+}
+function parseAddress(value, label) {
+  const raw = String(unwrapSingle2(value));
+  try {
+    return assertTronAddress3(raw, label);
+  } catch {
+    const evmHex = /^41[0-9a-fA-F]{40}$/.test(raw) ? `0x${raw.slice(2)}` : raw;
+    return evmHexToTronAddress(evmHex, label);
+  }
+}
+function parsePoolKey(value, network) {
+  if (Array.isArray(value) && value.length >= 5) {
+    return createV4PoolKey({
+      network,
+      currencyA: parseAddress(value[0], "poolKey.currency0"),
+      currencyB: parseAddress(value[1], "poolKey.currency1"),
+      hooks: parseAddress(value[2], "poolKey.hooks"),
+      fee: parseNumber(value[3], "poolKey.fee"),
+      parameters: String(value[4])
+    });
+  }
+  if (typeof value === "object" && value !== null) {
+    const key = value;
+    if (key.currency0 !== void 0 && key.currency1 !== void 0 && key.hooks !== void 0 && key.fee !== void 0 && key.parameters !== void 0) {
+      return createV4PoolKey({
+        network,
+        currencyA: parseAddress(key.currency0, "poolKey.currency0"),
+        currencyB: parseAddress(key.currency1, "poolKey.currency1"),
+        hooks: parseAddress(key.hooks, "poolKey.hooks"),
+        fee: parseNumber(key.fee, "poolKey.fee"),
+        parameters: String(key.parameters)
+      });
+    }
+  }
+  return void 0;
+}
+function signed24(value) {
+  const masked = value & 0xffffffn;
+  return Number((masked & 0x800000n) === 0n ? masked : masked - 0x1000000n);
+}
+function parsePackedPositionInfo(value) {
+  const info = BigInt(String(unwrapSingle2(value)));
+  return {
+    tickLower: signed24(info >> 8n),
+    tickUpper: signed24(info >> 32n)
+  };
+}
+function parseOptionalPoolInfo(result, network) {
+  if (Array.isArray(result)) {
+    const poolKey = parsePoolKey(result[0], network);
+    const ticks = result[2] !== void 0 ? {
+      tickLower: parseNumber(result[1], "tickLower"),
+      tickUpper: parseNumber(result[2], "tickUpper")
+    } : result[1] !== void 0 ? parsePackedPositionInfo(result[1]) : {};
+    return {
+      ...poolKey !== void 0 ? { poolKey } : {},
+      ...ticks
+    };
+  }
+  if (typeof result === "object" && result !== null) {
+    const info = result;
+    const poolKey = parsePoolKey(info.poolKey, network);
+    return {
+      ...poolKey !== void 0 ? { poolKey } : {},
+      ...info.tickLower !== void 0 ? { tickLower: parseNumber(info.tickLower, "tickLower") } : {},
+      ...info.tickUpper !== void 0 ? { tickUpper: parseNumber(info.tickUpper, "tickUpper") } : {}
+    };
+  }
+  return {};
+}
+function parseFeesResult(result) {
+  const value = unwrapSingle2(result);
+  if (Array.isArray(value) && value.length >= 2) {
+    return {
+      feesOwed0: parseString(value[0], "feesOwed0"),
+      feesOwed1: parseString(value[1], "feesOwed1")
+    };
+  }
+  if (typeof value === "object" && value !== null) {
+    const fees = value;
+    if (fees.feesOwed0 !== void 0 && fees.feesOwed1 !== void 0) {
+      return {
+        feesOwed0: parseString(fees.feesOwed0, "feesOwed0"),
+        feesOwed1: parseString(fees.feesOwed1, "feesOwed1")
+      };
+    }
+  }
+  throw new SDKError4("SDK_CONTRACT_ERROR", "V4 position fee result is malformed", { result });
+}
+function liquidityFromPercentage(totalLiquidity, percentage) {
+  const total = BigInt(normalizeBaseUnitAmount(totalLiquidity, "currentLiquidity"));
+  const numerator = BigInt(percentage.numerator.toString());
+  const denominator = BigInt(percentage.denominator.toString());
+  const liquidity = total * numerator / denominator;
+  if (liquidity <= 0n) {
+    throw new SDKError4("SDK_INVALID_ARGUMENT", "percentage resolves to zero liquidity", {
+      totalLiquidity: total.toString(),
+      percentage: percentage.toSignificant()
+    });
+  }
+  return liquidity.toString();
+}
+function resolveRemoveLiquidity(input, snapshotLiquidity) {
+  const normalizedSnapshotLiquidity = normalizeBaseUnitAmount(snapshotLiquidity, "position liquidity");
+  if (input.currentLiquidity !== void 0 && input.validationMode !== "legacy") {
+    const expectedLiquidity = normalizeBaseUnitAmount(input.currentLiquidity, "currentLiquidity");
+    if (expectedLiquidity !== normalizedSnapshotLiquidity) {
+      throw new SDKError4("SDK_INVALID_ARGUMENT", "currentLiquidity is stale and does not match the on-chain position", {
+        currentLiquidity: expectedLiquidity,
+        positionLiquidity: normalizedSnapshotLiquidity
+      });
+    }
+  }
+  const liquidity = input.liquidity !== void 0 ? normalizeBaseUnitAmount(input.liquidity, "liquidity") : liquidityFromPercentage(normalizedSnapshotLiquidity, normalizeLiquidityPercentage(input.percentage, "percentage"));
+  if (BigInt(liquidity) > BigInt(normalizedSnapshotLiquidity) && input.validationMode === "legacy") {
+    return normalizedSnapshotLiquidity;
+  }
+  if (BigInt(liquidity) > BigInt(normalizedSnapshotLiquidity)) {
+    throw new SDKError4("SDK_INVALID_ARGUMENT", "liquidity cannot exceed on-chain position liquidity", {
+      liquidity,
+      positionLiquidity: normalizedSnapshotLiquidity
+    });
+  }
+  return liquidity;
+}
+function parseSqrtPriceX96(result) {
+  const value = Array.isArray(result) ? result[0] : typeof result === "object" && result !== null ? result.sqrtPriceX96 : void 0;
+  try {
+    const parsed = BigInt(String(value));
+    if (parsed <= 0n) throw new Error("non-positive");
+    return parsed;
+  } catch {
+    throw new SDKError4("SDK_CONTRACT_ERROR", "V4 slot0 result has an invalid sqrtPriceX96", { result });
+  }
+}
+function removalAmounts(snapshot, liquidity, sqrtPriceX96) {
+  if (snapshot.tickLower === void 0 || snapshot.tickUpper === void 0) {
+    throw new SDKError4("SDK_CONTRACT_ERROR", "V4 position is missing ticks required to derive removal minimums", {
+      tokenId: snapshot.tokenId
+    });
+  }
+  const sqrtA = BigInt(TickMath.getSqrtRatioAtTick(snapshot.tickLower).toString());
+  const sqrtB = BigInt(TickMath.getSqrtRatioAtTick(snapshot.tickUpper).toString());
+  const positionLiquidity = BigInt(liquidity);
+  if (sqrtPriceX96 <= sqrtA) {
+    return [positionLiquidity * (sqrtB - sqrtA) * Q96 / (sqrtA * sqrtB), 0n];
+  }
+  if (sqrtPriceX96 < sqrtB) {
+    return [
+      positionLiquidity * (sqrtB - sqrtPriceX96) * Q96 / (sqrtPriceX96 * sqrtB),
+      positionLiquidity * (sqrtPriceX96 - sqrtA) / Q96
+    ];
+  }
+  return [0n, positionLiquidity * (sqrtB - sqrtA) / Q96];
+}
+function resolvePositionPoolKey(tokenId, supplied, snapshot) {
+  if (snapshot.poolKey === void 0) {
+    throw new SDKError4("SDK_CONTRACT_ERROR", "V4 position does not include a poolKey", { tokenId });
+  }
+  if (supplied !== void 0) {
+    const suppliedPoolId = computeV4PoolId(supplied);
+    const positionPoolId = computeV4PoolId(snapshot.poolKey);
+    if (suppliedPoolId !== positionPoolId) {
+      throw new SDKError4("SDK_INVALID_ARGUMENT", "V4 poolKey does not match the tokenId position", {
+        tokenId,
+        suppliedPoolId,
+        positionPoolId
+      });
+    }
+    return { poolKey: supplied, derived: false };
+  }
+  return { poolKey: snapshot.poolKey, derived: true };
+}
+function assertTriggerRecipient(wallet, recipient, operation) {
+  if (wallet !== recipient) {
+    throw new SDKError4("SDK_INVALID_ARGUMENT", `${operation} recipient must match the triggering wallet`, {
+      wallet,
+      recipient
+    });
+  }
+}
+function metadata(input) {
+  return {
+    protocol: "sunswap-v4",
+    operation: input.operation,
+    tokenId: input.tokenId,
+    ...input.owner !== void 0 ? { owner: input.owner } : {},
+    ...input.recipient !== void 0 ? { recipient: input.recipient } : {},
+    ...input.deadline !== void 0 ? { deadline: input.deadline } : {},
+    ...input.slippageBips !== void 0 ? { slippageBips: input.slippageBips } : {},
+    ...input.poolKeyDerived !== void 0 ? { poolKeyDerived: input.poolKeyDerived } : {}
+  };
+}
+var V4PositionsClient = class {
+  constructor(context) {
+    this.context = context;
+  }
+  context;
+  async read(input) {
+    const tokenId = normalizeBaseUnitAmount(input.tokenId, "tokenId");
+    const positionManager = resolveProtocolContract(this.context, input.contracts, "sunswapV4PositionManager");
+    const reads = buildV4PositionReads({ network: this.context.network, tokenId, positionManager });
+    const [poolInfoResult, liquidityResult, ownerResult, approvedResult] = await readMulticallRequired(
+      this.context,
+      reads,
+      "V4 position read"
+    );
+    const owner = parseAddress(ownerResult, "owner");
+    const approved = approvedResult ? parseAddress(approvedResult, "approved") : void 0;
+    const operator = input.operator ? assertTronAddress3(input.operator, "operator") : void 0;
+    const operatorApproved = operator ? Boolean(await readRequiredContract(
+      this.context,
+      buildV4PositionApprovalForAllRead({ network: this.context.network, owner, operator, positionManager }),
+      "V4 position operator approval read"
+    ).then(unwrapSingle2)) : void 0;
+    return {
+      protocol: "sunswap-v4",
+      tokenId,
+      owner,
+      ...approved !== void 0 ? { approved } : {},
+      ...operatorApproved !== void 0 ? { operatorApproved } : {},
+      ...parseOptionalPoolInfo(poolInfoResult, this.context.network),
+      liquidity: parseString(unwrapSingle2(liquidityResult), "liquidity")
+    };
+  }
+  async fees(input) {
+    const tokenId = normalizeBaseUnitAmount(input.tokenId, "tokenId");
+    const snapshot = await this.read(input);
+    if (snapshot.poolKey === void 0 || snapshot.tickLower === void 0 || snapshot.tickUpper === void 0) {
+      throw new SDKError4("SDK_CONTRACT_ERROR", "V4 position does not include the context required to read fees", {
+        tokenId
+      });
+    }
+    const result = await readRequiredContract(
+      this.context,
+      buildV4PositionFeesRead({
+        network: this.context.network,
+        tokenId,
+        poolId: computeV4PoolId(snapshot.poolKey),
+        tickLower: snapshot.tickLower,
+        tickUpper: snapshot.tickUpper,
+        poolManager: resolveProtocolContract(this.context, input.contracts, "sunswapV4PoolManager"),
+        positionManager: resolveProtocolContract(this.context, input.contracts, "sunswapV4PositionManager"),
+        lpFeeHelper: resolveProtocolContract(this.context, input.contracts, "sunswapV4LpFeeHelper")
+      }),
+      "V4 position fee read"
+    );
+    return {
+      protocol: "sunswap-v4",
+      tokenId,
+      ...parseFeesResult(result)
+    };
+  }
+  remove = {
+    plan: async (input) => this.planRemove(input),
+    execute: async (input) => executeTransactionPlan(await this.planRemove(input), createContextExecutor(this.context))
+  };
+  collect = {
+    plan: async (input) => this.planCollect(input),
+    execute: async (input) => executeTransactionPlan(await this.planCollect(input), createContextExecutor(this.context))
+  };
+  async readAuthorizedPosition(tokenId, operation, contracts, validationMode) {
+    const wallet = await requireWalletAddress(this.context, operation);
+    const snapshot = await this.read({
+      tokenId,
+      ...validationMode === "legacy" ? {} : { operator: wallet },
+      ...contracts !== void 0 ? { contracts } : {}
+    });
+    if (validationMode !== "legacy") {
+      assertPositionAuthorized({
+        tokenId,
+        wallet,
+        owner: snapshot.owner,
+        ...snapshot.approved !== void 0 ? { approved: snapshot.approved } : {},
+        ...snapshot.operatorApproved !== void 0 ? { operatorApproved: snapshot.operatorApproved } : {}
+      });
+    }
+    return { wallet, snapshot };
+  }
+  async planRemove(input) {
+    const positionManager = resolveProtocolContract(this.context, input.contracts, "sunswapV4PositionManager");
+    const planId = nextPlanId(this.context, "position-v4-remove");
+    const tokenId = normalizeBaseUnitAmount(input.tokenId, "tokenId");
+    const { wallet, snapshot } = await this.readAuthorizedPosition(
+      tokenId,
+      "V4 remove position",
+      input.contracts,
+      input.validationMode
+    );
+    const poolKey = resolvePositionPoolKey(tokenId, input.poolKey, snapshot);
+    const recipient = await normalizeRecipient(this.context, input.recipient, "V4 remove position", wallet);
+    assertTriggerRecipient(wallet, recipient, "V4 remove position");
+    const deadline = normalizeDeadline(this.context, input);
+    const slippageBips = slippageToBips(input.slippage ?? "0.5%");
+    const liquidity = resolveRemoveLiquidity(input, snapshot.liquidity);
+    const derivedAmounts = input.amount0Min === void 0 || input.amount1Min === void 0 ? removalAmounts(
+      snapshot,
+      liquidity,
+      parseSqrtPriceX96(await readRequiredContract(
+        this.context,
+        buildV4PoolSlot0Read({
+          network: this.context.network,
+          poolId: computeV4PoolId(poolKey.poolKey),
+          poolManager: resolveProtocolContract(this.context, input.contracts, "sunswapV4PoolManager")
+        }),
+        "V4 removal minimum quote"
+      ))
+    ) : void 0;
+    const amount0Min = input.amount0Min !== void 0 ? normalizeBaseUnitAmount(input.amount0Min, "amount0Min", { allowZero: true }) : input.roundingMode === "half-up" ? (((derivedAmounts?.[0] ?? 0n) * BigInt(1e4 - slippageBips) + 5000n) / 10000n).toString() : applySlippageMin(derivedAmounts?.[0] ?? 0n, slippageBips).toString();
+    const amount1Min = input.amount1Min !== void 0 ? normalizeBaseUnitAmount(input.amount1Min, "amount1Min", { allowZero: true }) : input.roundingMode === "half-up" ? (((derivedAmounts?.[1] ?? 0n) * BigInt(1e4 - slippageBips) + 5000n) / 10000n).toString() : applySlippageMin(derivedAmounts?.[1] ?? 0n, slippageBips).toString();
+    const decreaseAction = buildV4DecreaseLiquidityAction({
+      network: this.context.network,
+      positionManager,
+      poolKey: poolKey.poolKey,
+      tokenId,
+      liquidity,
+      amount0Min,
+      amount1Min,
+      recipient,
+      deadline,
+      ...input.settlementMode !== void 0 ? { settlementMode: input.settlementMode } : {},
+      ...input.hookData !== void 0 ? { hookData: input.hookData } : {},
+      ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {},
+      id: `${planId}-tx`
+    });
+    const transactionAction = input.transactionMode === "multicall" ? buildV4MulticallAction({
+      network: this.context.network,
+      positionManager,
+      calls: [encodeV4ContractCallAction(decreaseAction)],
+      ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {},
+      id: `${planId}-tx`
+    }) : decreaseAction;
+    const action = {
+      ...transactionAction,
+      intent: {
+        kind: "remove-liquidity",
+        scope: positionIntentScope(SUNSWAP_V4_POSITION_PROTOCOL_ID, "remove-position"),
+        positionId: tokenId
+      }
+    };
+    return {
+      id: planId,
+      kind: "position",
+      network: this.context.network,
+      owner: wallet,
+      summary: {
+        title: "Remove SunSwap V4 position liquidity",
+        lines: [`Position ${tokenId}`, `Recipient ${recipient}`]
+      },
+      approvals: [],
+      transactions: [action],
+      metadata: metadata({
+        operation: "remove-position",
+        tokenId,
+        owner: snapshot.owner,
+        recipient,
+        deadline,
+        slippageBips,
+        poolKeyDerived: poolKey.derived
+      })
+    };
+  }
+  async planCollect(input) {
+    const positionManager = resolveProtocolContract(this.context, input.contracts, "sunswapV4PositionManager");
+    const planId = nextPlanId(this.context, "position-v4-collect");
+    const tokenId = normalizeBaseUnitAmount(input.tokenId, "tokenId");
+    const { wallet, snapshot } = await this.readAuthorizedPosition(
+      tokenId,
+      "V4 collect position",
+      input.contracts,
+      input.validationMode
+    );
+    const poolKey = resolvePositionPoolKey(tokenId, input.poolKey, snapshot);
+    const recipient = await normalizeRecipient(this.context, input.recipient, "V4 collect position", wallet);
+    assertTriggerRecipient(wallet, recipient, "V4 collect position");
+    const deadline = normalizeDeadline(this.context, input);
+    const action = buildV4CollectAction({
+      network: this.context.network,
+      positionManager,
+      poolKey: poolKey.poolKey,
+      tokenId,
+      recipient,
+      deadline,
+      ...input.settlementMode !== void 0 ? { settlementMode: input.settlementMode } : {},
+      ...input.hookData !== void 0 ? { hookData: input.hookData } : {},
+      ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {},
+      id: `${planId}-tx`
+    });
+    const transactionAction = input.transactionMode === "multicall" ? buildV4MulticallAction({
+      network: this.context.network,
+      positionManager,
+      calls: [encodeV4ContractCallAction(action)],
+      ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {},
+      id: `${planId}-tx`
+    }) : action;
+    const transaction = {
+      ...transactionAction,
+      intent: {
+        kind: "collect-fees",
+        scope: positionIntentScope(SUNSWAP_V4_POSITION_PROTOCOL_ID, "collect-position"),
+        positionId: tokenId
+      }
+    };
+    return {
+      id: planId,
+      kind: "position",
+      network: this.context.network,
+      owner: wallet,
+      summary: {
+        title: "Collect SunSwap V4 position fees",
+        lines: [`Position ${tokenId}`, `Recipient ${recipient}`]
+      },
+      approvals: [],
+      transactions: [transaction],
+      metadata: metadata({
+        operation: "collect-position",
+        tokenId,
+        owner: snapshot.owner,
+        recipient,
+        deadline,
+        poolKeyDerived: poolKey.derived
+      })
+    };
+  }
+};
+
+// src/positions/client.ts
+var PositionsClient = class {
+  v3;
+  v4;
+  constructor(context) {
+    const v3Client = new V3PositionsClient(context);
+    const v4Client = new V4PositionsClient(context);
+    this.v3 = {
+      read: (input) => v3Client.read(input),
+      remove: v3Client.remove,
+      collect: v3Client.collect
+    };
+    this.v4 = {
+      read: (input) => v4Client.read(input),
+      fees: (input) => v4Client.fees(input),
+      remove: v4Client.remove,
+      collect: v4Client.collect
+    };
+  }
+};
+function createPositionsClient(context) {
+  return new PositionsClient(context);
+}
+
+export {
+  assertV3PositionUsdtTransfer,
+  createV3PositionsExecutor,
+  SUNSWAP_V3_POSITION_PROTOCOL_ID,
+  SUNSWAP_V4_POSITION_PROTOCOL_ID,
+  V3PositionsClient,
+  V4PositionsClient,
+  PositionsClient,
+  createPositionsClient
+};
+//# sourceMappingURL=chunk-PEGREDLT.js.map