@sun-protocol/sun-sdk-sunswap-v4 0.1.0-beta.0

package/dist/index.cjs

@@ -0,0 +1,1186 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  V4_ACTIONS: () => V4_ACTIONS,
+  V4_ACTION_CONSTANTS: () => V4_ACTION_CONSTANTS,
+  V4_DYNAMIC_FEE_FLAG: () => V4_DYNAMIC_FEE_FLAG,
+  V4_EMPTY_PARAMETERS: () => V4_EMPTY_PARAMETERS,
+  V4_HOOKS_REGISTRATION_OFFSET: () => V4_HOOKS_REGISTRATION_OFFSET,
+  V4_MAX_STATIC_FEE: () => V4_MAX_STATIC_FEE,
+  V4_POOL_MANAGER_READ_SELECTORS: () => V4_POOL_MANAGER_READ_SELECTORS,
+  V4_POSITION_MANAGER_READ_SELECTORS: () => V4_POSITION_MANAGER_READ_SELECTORS,
+  V4_POSITION_MANAGER_SELECTORS: () => V4_POSITION_MANAGER_SELECTORS,
+  V4_UINT24_MAX: () => V4_UINT24_MAX,
+  assertV4Fee: () => assertV4Fee,
+  assertV4HookFeeCombination: () => assertV4HookFeeCombination,
+  assertV4PoolId: () => assertV4PoolId,
+  assertV4PoolParameters: () => assertV4PoolParameters,
+  buildV4CollectAction: () => buildV4CollectAction,
+  buildV4DecreaseLiquidityAction: () => buildV4DecreaseLiquidityAction,
+  buildV4HookRegistrationBitmapRead: () => buildV4HookRegistrationBitmapRead,
+  buildV4IncreaseLiquidityAction: () => buildV4IncreaseLiquidityAction,
+  buildV4InitializePoolAction: () => buildV4InitializePoolAction,
+  buildV4MintPositionAction: () => buildV4MintPositionAction,
+  buildV4ModifyLiquiditiesAction: () => buildV4ModifyLiquiditiesAction,
+  buildV4MulticallAction: () => buildV4MulticallAction,
+  buildV4PoolAndPositionInfoRead: () => buildV4PoolAndPositionInfoRead,
+  buildV4PoolFeeGrowthGlobalsRead: () => buildV4PoolFeeGrowthGlobalsRead,
+  buildV4PoolKeyRead: () => buildV4PoolKeyRead,
+  buildV4PoolLiquidityRead: () => buildV4PoolLiquidityRead,
+  buildV4PoolSlot0Read: () => buildV4PoolSlot0Read,
+  buildV4PoolStateReads: () => buildV4PoolStateReads,
+  buildV4PositionApprovalForAllRead: () => buildV4PositionApprovalForAllRead,
+  buildV4PositionApprovedRead: () => buildV4PositionApprovedRead,
+  buildV4PositionFeesRead: () => buildV4PositionFeesRead,
+  buildV4PositionLiquidityRead: () => buildV4PositionLiquidityRead,
+  buildV4PositionOwnerRead: () => buildV4PositionOwnerRead,
+  buildV4PositionReads: () => buildV4PositionReads,
+  computeV4PoolId: () => computeV4PoolId,
+  createV4PoolKey: () => createV4PoolKey,
+  decodeV4HooksRegistration: () => decodeV4HooksRegistration,
+  decodeV4PoolParameters: () => decodeV4PoolParameters,
+  encodeV4ActionParams: () => encodeV4ActionParams,
+  encodeV4Actions: () => encodeV4Actions,
+  encodeV4ActionsPlanner: () => encodeV4ActionsPlanner,
+  encodeV4CollectPlannerPayload: () => encodeV4CollectPlannerPayload,
+  encodeV4ContractCallAction: () => encodeV4ContractCallAction,
+  encodeV4DecreaseLiquidityPlannerPayload: () => encodeV4DecreaseLiquidityPlannerPayload,
+  encodeV4HooksRegistration: () => encodeV4HooksRegistration,
+  encodeV4IncreaseLiquidityPlannerPayload: () => encodeV4IncreaseLiquidityPlannerPayload,
+  encodeV4MintPositionPlannerPayload: () => encodeV4MintPositionPlannerPayload,
+  encodeV4Permit2ForwardCall: () => encodeV4Permit2ForwardCall,
+  encodeV4PoolKey: () => encodeV4PoolKey,
+  encodeV4PoolParameters: () => encodeV4PoolParameters,
+  getV4StaticFee: () => getV4StaticFee,
+  isV4DynamicFee: () => isV4DynamicFee,
+  normalizeV4PoolKey: () => normalizeV4PoolKey,
+  toV4PoolKeyTuple: () => toV4PoolKeyTuple,
+  tronAddressToEvmHex: () => tronAddressToEvmHex
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/address.ts
+var import_sha256 = require("@noble/hashes/sha256");
+var import_sun_sdk_core = require("@sun-protocol/sun-sdk-core");
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var TRON_ADDRESS_BYTES = 21;
+var TRON_ADDRESS_PAYLOAD_BYTES = 25;
+function decodeBase58(value) {
+  let decoded = 0n;
+  for (const char of value) {
+    const index = BASE58_ALPHABET.indexOf(char);
+    (0, import_sun_sdk_core.sdkInvariant)(index >= 0, import_sun_sdk_core.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "Invalid base58 character", { value, char });
+    decoded = decoded * 58n + BigInt(index);
+  }
+  const bytes = [];
+  while (decoded > 0n) {
+    bytes.unshift(Number(decoded & 0xffn));
+    decoded >>= 8n;
+  }
+  for (const char of value) {
+    if (char !== "1") break;
+    bytes.unshift(0);
+  }
+  return Uint8Array.from(bytes);
+}
+function tronAddressToEvmHex(address) {
+  const decoded = decodeBase58(address);
+  (0, import_sun_sdk_core.sdkInvariant)(
+    decoded.length === TRON_ADDRESS_PAYLOAD_BYTES,
+    import_sun_sdk_core.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT,
+    "TRON address payload must be 25 bytes",
+    { address, length: decoded.length }
+  );
+  const body = decoded.slice(0, TRON_ADDRESS_BYTES);
+  (0, import_sun_sdk_core.sdkInvariant)(body[0] === 65, import_sun_sdk_core.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "TRON address must use 0x41 prefix", {
+    address
+  });
+  const expectedChecksum = (0, import_sha256.sha256)((0, import_sha256.sha256)(body)).slice(0, 4);
+  const actualChecksum = decoded.slice(TRON_ADDRESS_BYTES);
+  (0, import_sun_sdk_core.sdkInvariant)(
+    expectedChecksum.every((byte, index) => byte === actualChecksum[index]),
+    import_sun_sdk_core.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT,
+    "TRON address has invalid base58 checksum",
+    { address }
+  );
+  return `0x${Array.from(body.slice(1)).map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+
+// src/actions.ts
+var import_sun_sdk_chains = require("@sun-protocol/sun-sdk-chains");
+var import_keccak256 = require("@ethersproject/keccak256");
+var import_sun_sdk_core4 = require("@sun-protocol/sun-sdk-core");
+
+// src/planner.ts
+var import_sun_sdk_core3 = require("@sun-protocol/sun-sdk-core");
+
+// src/pool-key.ts
+var import_sun_sdk_core2 = require("@sun-protocol/sun-sdk-core");
+var V4_DYNAMIC_FEE_FLAG = 8388608;
+var V4_UINT24_MAX = 16777215;
+var V4_MAX_STATIC_FEE = 1e6;
+var V4_EMPTY_PARAMETERS = `0x${"0".repeat(64)}`;
+var BYTES32_PATTERN = /^0x[a-fA-F0-9]{64}$/;
+function sortCurrencies(currencyA, currencyB) {
+  (0, import_sun_sdk_core2.sdkInvariant)(
+    currencyA !== currencyB,
+    import_sun_sdk_core2.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT,
+    "V4 pool currencies must be different",
+    { currencyA, currencyB }
+  );
+  return tronAddressToEvmHex(currencyA) < tronAddressToEvmHex(currencyB) ? [currencyA, currencyB] : [currencyB, currencyA];
+}
+function isV4DynamicFee(fee) {
+  return (fee & V4_DYNAMIC_FEE_FLAG) !== 0;
+}
+function getV4StaticFee(fee) {
+  return fee & ~V4_DYNAMIC_FEE_FLAG;
+}
+function assertV4PoolParameters(value, label = "parameters") {
+  (0, import_sun_sdk_core2.sdkInvariant)(BYTES32_PATTERN.test(value), import_sun_sdk_core2.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, `${label} must be bytes32 hex`, {
+    label,
+    value
+  });
+  return value.toLowerCase();
+}
+function assertV4PoolId(value, label = "poolId") {
+  (0, import_sun_sdk_core2.sdkInvariant)(BYTES32_PATTERN.test(value), import_sun_sdk_core2.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, `${label} must be bytes32 hex`, {
+    label,
+    value
+  });
+  return value.toLowerCase();
+}
+function assertV4Fee(fee) {
+  (0, import_sun_sdk_core2.sdkInvariant)(Number.isInteger(fee), import_sun_sdk_core2.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "V4 fee must be an integer", { fee });
+  (0, import_sun_sdk_core2.sdkInvariant)(fee >= 0 && fee <= V4_UINT24_MAX, import_sun_sdk_core2.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "V4 fee must fit uint24", {
+    fee
+  });
+  const staticFee = getV4StaticFee(fee);
+  (0, import_sun_sdk_core2.sdkInvariant)(
+    isV4DynamicFee(fee) || staticFee <= V4_MAX_STATIC_FEE,
+    import_sun_sdk_core2.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT,
+    "V4 static fee cannot exceed 100%",
+    { fee, staticFee }
+  );
+  return fee;
+}
+function assertV4HookFeeCombination(hooks, fee) {
+  (0, import_sun_sdk_core2.sdkInvariant)(
+    !(hooks === import_sun_sdk_core2.TRON_ZERO_ADDRESS && isV4DynamicFee(fee)),
+    import_sun_sdk_core2.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT,
+    "V4 dynamic fee requires a non-empty hook address",
+    { hooks, fee }
+  );
+}
+function normalizeV4PoolKey(input) {
+  const currency0 = (0, import_sun_sdk_core2.assertTronAddress)(input.currency0, "currency0");
+  const currency1 = (0, import_sun_sdk_core2.assertTronAddress)(input.currency1, "currency1");
+  const hooks = (0, import_sun_sdk_core2.assertTronAddress)(input.hooks, "hooks");
+  const [sorted0, sorted1] = sortCurrencies(currency0, currency1);
+  const fee = assertV4Fee(input.fee);
+  assertV4HookFeeCombination(hooks, fee);
+  return {
+    network: input.network,
+    currency0: sorted0,
+    currency1: sorted1,
+    hooks,
+    fee,
+    parameters: assertV4PoolParameters(input.parameters)
+  };
+}
+function createV4PoolKey(input) {
+  const currencyA = (0, import_sun_sdk_core2.assertTronAddress)(input.currencyA, "currencyA");
+  const currencyB = (0, import_sun_sdk_core2.assertTronAddress)(input.currencyB, "currencyB");
+  const [currency0, currency1] = sortCurrencies(currencyA, currencyB);
+  const hooks = (0, import_sun_sdk_core2.assertTronAddress)(input.hooks ?? import_sun_sdk_core2.TRON_ZERO_ADDRESS, "hooks");
+  const fee = assertV4Fee(input.fee);
+  assertV4HookFeeCombination(hooks, fee);
+  return {
+    network: input.network,
+    currency0,
+    currency1,
+    hooks,
+    fee,
+    parameters: assertV4PoolParameters(input.parameters ?? V4_EMPTY_PARAMETERS)
+  };
+}
+function toV4PoolKeyTuple(poolKey) {
+  const normalized = normalizeV4PoolKey(poolKey);
+  return {
+    type: "tuple",
+    value: {
+      currency0: normalized.currency0,
+      currency1: normalized.currency1,
+      hooks: normalized.hooks,
+      fee: normalized.fee,
+      parameters: normalized.parameters
+    }
+  };
+}
+
+// src/planner.ts
+var V4_ACTIONS = {
+  CL_INCREASE_LIQUIDITY: 0,
+  CL_DECREASE_LIQUIDITY: 1,
+  CL_MINT_POSITION: 2,
+  SETTLE: 11,
+  SETTLE_PAIR: 13,
+  TAKE_PAIR: 17,
+  CLOSE_CURRENCY: 18,
+  SWEEP: 20
+};
+var V4_ACTION_CONSTANTS = {
+  OPEN_DELTA: 0n,
+  MSG_SENDER: "0x0000000000000000000000000000000000000001",
+  ADDRESS_THIS: "0x0000000000000000000000000000000000000002"
+};
+var WORD_BYTES = 32;
+var WORD_HEX_LENGTH = WORD_BYTES * 2;
+var HEX_BYTES_PATTERN = /^0x(?:[a-fA-F0-9]{2})*$/;
+var V4_ACTION_NAMES = {
+  [V4_ACTIONS.CL_INCREASE_LIQUIDITY]: "CL_INCREASE_LIQUIDITY",
+  [V4_ACTIONS.CL_DECREASE_LIQUIDITY]: "CL_DECREASE_LIQUIDITY",
+  [V4_ACTIONS.CL_MINT_POSITION]: "CL_MINT_POSITION",
+  [V4_ACTIONS.SETTLE]: "SETTLE",
+  [V4_ACTIONS.SETTLE_PAIR]: "SETTLE_PAIR",
+  [V4_ACTIONS.TAKE_PAIR]: "TAKE_PAIR",
+  [V4_ACTIONS.CLOSE_CURRENCY]: "CLOSE_CURRENCY",
+  [V4_ACTIONS.SWEEP]: "SWEEP"
+};
+function assertHexBytes(value, label) {
+  (0, import_sun_sdk_core3.sdkInvariant)(HEX_BYTES_PATTERN.test(value), import_sun_sdk_core3.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, `${label} must be 0x-prefixed hex bytes`, {
+    label,
+    value
+  });
+  return value.toLowerCase();
+}
+function strip0x(value) {
+  return value.startsWith("0x") ? value.slice(2) : value;
+}
+function word(value) {
+  (0, import_sun_sdk_core3.sdkInvariant)(value >= 0n, import_sun_sdk_core3.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "ABI word cannot encode a negative uint", {
+    value: value.toString()
+  });
+  return value.toString(16).padStart(WORD_HEX_LENGTH, "0");
+}
+function encodeUint(value, bits, label) {
+  const uint = BigInt(value.toString());
+  const max = 1n << BigInt(bits);
+  (0, import_sun_sdk_core3.sdkInvariant)(uint >= 0n && uint < max, import_sun_sdk_core3.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, `${label} is out of uint${bits} range`, {
+    label,
+    value: uint.toString()
+  });
+  return word(uint);
+}
+function encodeInt(value, bits, label) {
+  (0, import_sun_sdk_core3.sdkInvariant)(Number.isInteger(value), import_sun_sdk_core3.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, `${label} must be an integer`, { label, value });
+  const int = BigInt(value);
+  const min = -(1n << BigInt(bits - 1));
+  const max = 1n << BigInt(bits - 1);
+  (0, import_sun_sdk_core3.sdkInvariant)(int >= min && int < max, import_sun_sdk_core3.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, `${label} is out of int${bits} range`, {
+    label,
+    value
+  });
+  return word(int >= 0n ? int : (1n << BigInt(WORD_BYTES * 8)) + int);
+}
+function encodeBool(value) {
+  return word(value ? 1n : 0n);
+}
+function encodeAddress(value, label) {
+  const address = value.startsWith("0x") ? assertHexBytes(value, label) : tronAddressToEvmHex((0, import_sun_sdk_core3.assertTronAddress)(value, label));
+  const hex = strip0x(address);
+  (0, import_sun_sdk_core3.sdkInvariant)(hex.length === 40, import_sun_sdk_core3.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, `${label} must be a 20-byte address`, {
+    label,
+    value
+  });
+  return hex.padStart(WORD_HEX_LENGTH, "0");
+}
+function encodeBytes(value, label) {
+  const bytes = strip0x(assertHexBytes(value, label));
+  const length = bytes.length / 2;
+  const paddedLength = Math.ceil(length / WORD_BYTES) * WORD_HEX_LENGTH;
+  return `${word(BigInt(length))}${bytes.padEnd(paddedLength, "0")}`;
+}
+function concatHex(parts) {
+  return `0x${parts.join("")}`;
+}
+function encodePoolKeyFields(poolKey) {
+  const normalized = normalizeV4PoolKey(poolKey);
+  return [
+    encodeAddress(normalized.currency0, "poolKey.currency0"),
+    encodeAddress(normalized.currency1, "poolKey.currency1"),
+    encodeAddress(normalized.hooks, "poolKey.hooks"),
+    encodeUint(normalized.fee, 24, "poolKey.fee"),
+    strip0x(assertHexBytes(normalized.parameters, "poolKey.parameters"))
+  ];
+}
+function encodePositionConfig(config) {
+  return [
+    ...encodePoolKeyFields(config.poolKey),
+    encodeInt(config.tickLower, 24, "tickLower"),
+    encodeInt(config.tickUpper, 24, "tickUpper")
+  ];
+}
+function encodeWithTrailingBytes(staticParts, bytesValue) {
+  return concatHex([...staticParts, word(BigInt((staticParts.length + 1) * WORD_BYTES)), encodeBytes(bytesValue, "hookData")]);
+}
+function assertParamCount(plan, expected) {
+  (0, import_sun_sdk_core3.sdkInvariant)(
+    plan.params.length === expected,
+    import_sun_sdk_core3.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT,
+    `V4 action ${V4_ACTION_NAMES[plan.action]} expects ${expected} params`,
+    { action: plan.action, expected, actual: plan.params.length }
+  );
+}
+function paramAt(plan, index) {
+  const value = plan.params[index];
+  (0, import_sun_sdk_core3.sdkInvariant)(value !== void 0, import_sun_sdk_core3.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, `Missing V4 action param at index ${index}`, {
+    action: plan.action,
+    index
+  });
+  return value;
+}
+function asPositionConfig(value, label) {
+  (0, import_sun_sdk_core3.sdkInvariant)(typeof value === "object" && value !== null && "poolKey" in value, import_sun_sdk_core3.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, `${label} must be a V4 position config`, {
+    label
+  });
+  return value;
+}
+function encodePlanParam(plan) {
+  switch (plan.action) {
+    case V4_ACTIONS.CL_MINT_POSITION:
+      assertParamCount(plan, 6);
+      return encodeWithTrailingBytes(
+        [
+          ...encodePositionConfig(asPositionConfig(paramAt(plan, 0), "positionConfig")),
+          encodeUint(paramAt(plan, 1), 128, "liquidity"),
+          encodeUint(paramAt(plan, 2), 128, "amount0Max"),
+          encodeUint(paramAt(plan, 3), 128, "amount1Max"),
+          encodeAddress(paramAt(plan, 4), "owner")
+        ],
+        paramAt(plan, 5)
+      );
+    case V4_ACTIONS.CL_INCREASE_LIQUIDITY:
+      assertParamCount(plan, 5);
+      return encodeWithTrailingBytes(
+        [
+          encodeUint(paramAt(plan, 0), 256, "tokenId"),
+          encodeUint(paramAt(plan, 1), 128, "liquidity"),
+          encodeUint(paramAt(plan, 2), 128, "amount0Max"),
+          encodeUint(paramAt(plan, 3), 128, "amount1Max")
+        ],
+        paramAt(plan, 4)
+      );
+    case V4_ACTIONS.CL_DECREASE_LIQUIDITY:
+      assertParamCount(plan, 5);
+      return encodeWithTrailingBytes(
+        [
+          encodeUint(paramAt(plan, 0), 256, "tokenId"),
+          encodeUint(paramAt(plan, 1), 128, "liquidity"),
+          encodeUint(paramAt(plan, 2), 128, "amount0Min"),
+          encodeUint(paramAt(plan, 3), 128, "amount1Min")
+        ],
+        paramAt(plan, 4)
+      );
+    case V4_ACTIONS.SETTLE:
+      assertParamCount(plan, 3);
+      return concatHex([
+        encodeAddress(paramAt(plan, 0), "currency"),
+        encodeUint(paramAt(plan, 1), 256, "amount"),
+        encodeBool(paramAt(plan, 2))
+      ]);
+    case V4_ACTIONS.SETTLE_PAIR:
+      assertParamCount(plan, 2);
+      return concatHex([
+        encodeAddress(paramAt(plan, 0), "currency0"),
+        encodeAddress(paramAt(plan, 1), "currency1")
+      ]);
+    case V4_ACTIONS.TAKE_PAIR:
+      assertParamCount(plan, 3);
+      return concatHex([
+        encodeAddress(paramAt(plan, 0), "currency0"),
+        encodeAddress(paramAt(plan, 1), "currency1"),
+        encodeAddress(paramAt(plan, 2), "recipient")
+      ]);
+    case V4_ACTIONS.CLOSE_CURRENCY:
+      assertParamCount(plan, 1);
+      return concatHex([encodeAddress(paramAt(plan, 0), "currency")]);
+    case V4_ACTIONS.SWEEP:
+      assertParamCount(plan, 2);
+      return concatHex([
+        encodeAddress(paramAt(plan, 0), "currency"),
+        encodeAddress(paramAt(plan, 1), "recipient")
+      ]);
+    default:
+      (0, import_sun_sdk_core3.sdkInvariant)(false, import_sun_sdk_core3.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "Unsupported V4 action", { action: plan.action });
+      throw new Error("Unsupported V4 action");
+  }
+}
+function encodeDynamicBytesArray(values) {
+  const encodedValues = values.map((value, index) => encodeBytes(value, `params[${index}]`));
+  const offsets = [];
+  let tailOffset = BigInt(values.length * WORD_BYTES);
+  for (const encodedValue of encodedValues) {
+    offsets.push(word(tailOffset));
+    tailOffset += BigInt(encodedValue.length / 2);
+  }
+  return `${word(BigInt(values.length))}${offsets.join("")}${encodedValues.join("")}`;
+}
+function encodeV4Actions(plans) {
+  const actions = plans.map((plan) => {
+    (0, import_sun_sdk_core3.sdkInvariant)(V4_ACTION_NAMES[plan.action] !== void 0, import_sun_sdk_core3.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "Unsupported V4 action", {
+      action: plan.action
+    });
+    return plan.action.toString(16).padStart(2, "0");
+  });
+  return concatHex(actions);
+}
+function encodeV4ActionParams(plans) {
+  return plans.map((plan) => encodePlanParam(plan));
+}
+function encodeV4ActionsPlanner(plans) {
+  const actions = encodeV4Actions(plans);
+  const params = encodeV4ActionParams(plans);
+  const encodedActions = encodeBytes(actions, "actions");
+  const encodedParams = encodeDynamicBytesArray(params);
+  return concatHex([word(64n), word(BigInt(64 + encodedActions.length / 2)), encodedActions, encodedParams]);
+}
+function encodeV4MintPositionPlannerPayload(params) {
+  const poolKey = normalizeV4PoolKey(params.positionConfig.poolKey);
+  const owner = (0, import_sun_sdk_core3.assertTronAddress)(params.owner, "owner");
+  const sweepRecipient = params.sweepRecipient ? (0, import_sun_sdk_core3.assertTronAddress)(params.sweepRecipient, "sweepRecipient") : owner;
+  const hookData = params.hookData ?? "0x";
+  const plans = [
+    {
+      action: V4_ACTIONS.CL_MINT_POSITION,
+      params: [{ ...params.positionConfig, poolKey }, params.liquidity, params.amount0Max, params.amount1Max, owner, hookData]
+    },
+    { action: V4_ACTIONS.SETTLE, params: [poolKey.currency0, V4_ACTION_CONSTANTS.OPEN_DELTA, poolKey.currency0 !== import_sun_sdk_core3.TRON_ZERO_ADDRESS] },
+    { action: V4_ACTIONS.SETTLE, params: [poolKey.currency1, V4_ACTION_CONSTANTS.OPEN_DELTA, poolKey.currency1 !== import_sun_sdk_core3.TRON_ZERO_ADDRESS] }
+  ];
+  if (poolKey.currency0 === import_sun_sdk_core3.TRON_ZERO_ADDRESS) {
+    plans.push({ action: V4_ACTIONS.SWEEP, params: [poolKey.currency0, sweepRecipient] });
+  }
+  if (poolKey.currency1 === import_sun_sdk_core3.TRON_ZERO_ADDRESS) {
+    plans.push({ action: V4_ACTIONS.SWEEP, params: [poolKey.currency1, sweepRecipient] });
+  }
+  return encodeV4ActionsPlanner(plans);
+}
+function encodeV4IncreaseLiquidityPlannerPayload(params) {
+  const poolKey = normalizeV4PoolKey(params.poolKey);
+  const hasNativeCurrency = poolKey.currency0 === import_sun_sdk_core3.TRON_ZERO_ADDRESS || poolKey.currency1 === import_sun_sdk_core3.TRON_ZERO_ADDRESS;
+  (0, import_sun_sdk_core3.sdkInvariant)(
+    !hasNativeCurrency || params.sweepRecipient !== void 0,
+    import_sun_sdk_core3.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT,
+    "sweepRecipient is required when increasing liquidity with native currency"
+  );
+  const sweepRecipient = params.sweepRecipient !== void 0 ? (0, import_sun_sdk_core3.assertTronAddress)(params.sweepRecipient, "sweepRecipient") : void 0;
+  const plans = [
+    {
+      action: V4_ACTIONS.CL_INCREASE_LIQUIDITY,
+      params: [params.tokenId, params.liquidity, params.amount0Max, params.amount1Max, params.hookData ?? "0x"]
+    },
+    { action: V4_ACTIONS.SETTLE, params: [poolKey.currency0, V4_ACTION_CONSTANTS.OPEN_DELTA, poolKey.currency0 !== import_sun_sdk_core3.TRON_ZERO_ADDRESS] },
+    { action: V4_ACTIONS.SETTLE, params: [poolKey.currency1, V4_ACTION_CONSTANTS.OPEN_DELTA, poolKey.currency1 !== import_sun_sdk_core3.TRON_ZERO_ADDRESS] }
+  ];
+  if (sweepRecipient && poolKey.currency0 === import_sun_sdk_core3.TRON_ZERO_ADDRESS) {
+    plans.push({ action: V4_ACTIONS.SWEEP, params: [poolKey.currency0, sweepRecipient] });
+  }
+  if (sweepRecipient && poolKey.currency1 === import_sun_sdk_core3.TRON_ZERO_ADDRESS) {
+    plans.push({ action: V4_ACTIONS.SWEEP, params: [poolKey.currency1, sweepRecipient] });
+  }
+  return encodeV4ActionsPlanner(plans);
+}
+function encodeV4DecreaseLiquidityPlannerPayload(params) {
+  const poolKey = normalizeV4PoolKey(params.poolKey);
+  const recipient = (0, import_sun_sdk_core3.assertTronAddress)(params.recipient, "recipient");
+  const plans = [
+    {
+      action: V4_ACTIONS.CL_DECREASE_LIQUIDITY,
+      params: [params.tokenId, params.liquidity, params.amount0Min, params.amount1Min, params.hookData ?? "0x"]
+    }
+  ];
+  if (params.settlementMode === "close-currency") {
+    plans.push(
+      { action: V4_ACTIONS.CLOSE_CURRENCY, params: [poolKey.currency0] },
+      { action: V4_ACTIONS.CLOSE_CURRENCY, params: [poolKey.currency1] }
+    );
+  } else {
+    plans.push({ action: V4_ACTIONS.TAKE_PAIR, params: [poolKey.currency0, poolKey.currency1, recipient] });
+  }
+  return encodeV4ActionsPlanner(plans);
+}
+function encodeV4CollectPlannerPayload(params) {
+  const poolKey = normalizeV4PoolKey(params.poolKey);
+  const recipient = (0, import_sun_sdk_core3.assertTronAddress)(params.recipient, "recipient");
+  return encodeV4ActionsPlanner([{ action: V4_ACTIONS.TAKE_PAIR, params: [poolKey.currency0, poolKey.currency1, recipient] }]);
+}
+
+// src/actions.ts
+var V4_POSITION_MANAGER_SELECTORS = {
+  initializePool: "initializePool((address,address,address,uint24,bytes32),uint160)",
+  modifyLiquidities: "modifyLiquidities(bytes,uint256)",
+  multicall: "multicall(bytes[])"
+};
+var HEX_BYTES_PATTERN2 = /^0x(?:[a-fA-F0-9]{2})*$/;
+function calldataWord(value) {
+  (0, import_sun_sdk_core4.sdkInvariant)(value >= 0n && value < 1n << 256n, import_sun_sdk_core4.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "calldata word is out of range", {
+    value: value.toString()
+  });
+  return value.toString(16).padStart(64, "0");
+}
+function calldataAddress(value) {
+  const address = String(value);
+  const hex = address.startsWith("0x") ? assertHexBytes2(address, "address").slice(2) : tronAddressToEvmHex(address).slice(2);
+  (0, import_sun_sdk_core4.sdkInvariant)(hex.length === 40, import_sun_sdk_core4.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "address must be a 20-byte address", {
+    value: address
+  });
+  return hex.toLowerCase().padStart(64, "0");
+}
+function calldataBytes32(value) {
+  const normalized = assertHexBytes2(String(value), "bytes32").slice(2);
+  (0, import_sun_sdk_core4.sdkInvariant)(normalized.length === 64, import_sun_sdk_core4.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "bytes32 must contain exactly 32 bytes");
+  return normalized;
+}
+function functionSelector(signature) {
+  return (0, import_keccak256.keccak256)(new TextEncoder().encode(signature)).slice(2, 10);
+}
+function dynamicBytes(value) {
+  const bytes = assertHexBytes2(String(value), "bytes").slice(2);
+  const padding = (64 - bytes.length % 64) % 64;
+  return `${calldataWord(BigInt(bytes.length / 2))}${bytes}${"0".repeat(padding)}`;
+}
+function calldataUint(value, bits, label) {
+  const integer = BigInt(value.toString());
+  const maximum = 1n << BigInt(bits);
+  (0, import_sun_sdk_core4.sdkInvariant)(integer >= 0n && integer < maximum, import_sun_sdk_core4.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, `${label} is out of uint${bits} range`, {
+    value: integer.toString()
+  });
+  return calldataWord(integer);
+}
+function encodeV4Permit2ForwardCall(input) {
+  const signature = input.permit.signature.startsWith("0x") ? input.permit.signature : `0x${input.permit.signature}`;
+  const selector = functionSelector("permit(address,((address,uint160,uint48,uint48),address,uint256),bytes)");
+  const signatureOffset = calldataWord(256n);
+  return `0x${selector}${calldataAddress(input.owner)}${calldataAddress(input.permit.details.token)}${calldataUint(input.permit.details.amount, 160, "permit amount")}${calldataUint(input.permit.details.expiration, 48, "permit expiration")}${calldataUint(input.permit.details.nonce, 48, "permit nonce")}${calldataAddress(input.permit.spender)}${calldataUint(input.permit.sigDeadline, 256, "permit sigDeadline")}${signatureOffset}${dynamicBytes(signature)}`;
+}
+function encodeV4ContractCallAction(action) {
+  if (action.functionSelector === V4_POSITION_MANAGER_SELECTORS.initializePool) {
+    const poolKey = action.parameters?.[0]?.value;
+    const sqrtPriceX96 = action.parameters?.[1]?.value;
+    (0, import_sun_sdk_core4.sdkInvariant)(
+      typeof poolKey === "object" && poolKey !== null && sqrtPriceX96 !== void 0,
+      import_sun_sdk_core4.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT,
+      "initializePool action parameters are malformed"
+    );
+    const key = poolKey;
+    return `0x${functionSelector(action.functionSelector)}${calldataAddress(key.currency0)}${calldataAddress(key.currency1)}${calldataAddress(key.hooks)}${calldataWord(BigInt(String(key.fee)))}${calldataBytes32(key.parameters)}${calldataWord(BigInt(String(sqrtPriceX96)))}`;
+  }
+  if (action.functionSelector === V4_POSITION_MANAGER_SELECTORS.modifyLiquidities) {
+    const payload = action.parameters?.[0]?.value;
+    const deadline = action.parameters?.[1]?.value;
+    (0, import_sun_sdk_core4.sdkInvariant)(payload !== void 0 && deadline !== void 0, import_sun_sdk_core4.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "modifyLiquidities action parameters are malformed");
+    return `0x${functionSelector(action.functionSelector)}${calldataWord(64n)}${calldataWord(BigInt(String(deadline)))}${dynamicBytes(payload)}`;
+  }
+  (0, import_sun_sdk_core4.sdkInvariant)(false, import_sun_sdk_core4.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "V4 action cannot be encoded for multicall", {
+    functionSelector: action.functionSelector
+  });
+  throw new Error("Unsupported V4 multicall action");
+}
+function valueOf(value) {
+  return BigInt(value.toString()).toString();
+}
+function positionManagerTarget(params) {
+  return params.positionManager ?? (0, import_sun_sdk_chains.getContractAddress)(params.network, "sunswapV4PositionManager");
+}
+function actionId(params, suffix) {
+  return params.id ?? `sunswap-v4-${suffix}-${params.network}`;
+}
+function assertHexBytes2(value, label) {
+  (0, import_sun_sdk_core4.sdkInvariant)(HEX_BYTES_PATTERN2.test(value), import_sun_sdk_core4.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, `${label} must be 0x-prefixed hex bytes`, {
+    label,
+    value
+  });
+  return value.toLowerCase();
+}
+function nativeCallValue(poolKey, amount0, amount1) {
+  let value = 0n;
+  if (poolKey.currency0 === import_sun_sdk_core4.TRON_ZERO_ADDRESS) value += BigInt(amount0.toString());
+  if (poolKey.currency1 === import_sun_sdk_core4.TRON_ZERO_ADDRESS) value += BigInt(amount1.toString());
+  return value;
+}
+function tokenRequirements(poolKey, amount0, amount1, spender) {
+  const requirements = [];
+  const normalizedAmount0 = valueOf(amount0);
+  const normalizedAmount1 = valueOf(amount1);
+  if (poolKey.currency0 !== import_sun_sdk_core4.TRON_ZERO_ADDRESS && BigInt(normalizedAmount0) > 0n) {
+    requirements.push({
+      token: poolKey.currency0,
+      amount: normalizedAmount0,
+      spender,
+      approval: "approve-or-permit2"
+    });
+  }
+  if (poolKey.currency1 !== import_sun_sdk_core4.TRON_ZERO_ADDRESS && BigInt(normalizedAmount1) > 0n) {
+    requirements.push({
+      token: poolKey.currency1,
+      amount: normalizedAmount1,
+      spender,
+      approval: "approve-or-permit2"
+    });
+  }
+  return requirements;
+}
+function buildV4InitializePoolAction(params) {
+  const poolKey = normalizeV4PoolKey(params.poolKey);
+  return (0, import_sun_sdk_core4.createContractCallAction)({
+    id: actionId(params, "initialize-pool"),
+    target: positionManagerTarget(params),
+    functionSelector: V4_POSITION_MANAGER_SELECTORS.initializePool,
+    parameters: [toV4PoolKeyTuple(poolKey), { type: "uint160", value: valueOf(params.sqrtPriceX96) }],
+    ...params.callValue !== void 0 ? { callValue: params.callValue } : {},
+    ...params.feeLimit !== void 0 ? { feeLimit: params.feeLimit } : {},
+    ...params.metadata !== void 0 ? { metadata: params.metadata } : {}
+  });
+}
+function buildV4ModifyLiquiditiesAction(params) {
+  return (0, import_sun_sdk_core4.createContractCallAction)({
+    id: actionId(params, "modify-liquidities"),
+    target: positionManagerTarget(params),
+    functionSelector: V4_POSITION_MANAGER_SELECTORS.modifyLiquidities,
+    parameters: [
+      { type: "bytes", value: assertHexBytes2(params.payload, "payload") },
+      { type: "uint256", value: valueOf(params.deadline) }
+    ],
+    ...params.callValue !== void 0 ? { callValue: params.callValue } : {},
+    ...params.feeLimit !== void 0 ? { feeLimit: params.feeLimit } : {},
+    ...params.tokenRequirements !== void 0 ? { tokenRequirements: params.tokenRequirements } : {},
+    ...params.metadata !== void 0 ? { metadata: params.metadata } : {}
+  });
+}
+function buildV4MulticallAction(params) {
+  return (0, import_sun_sdk_core4.createContractCallAction)({
+    id: actionId(params, "multicall"),
+    target: positionManagerTarget(params),
+    functionSelector: V4_POSITION_MANAGER_SELECTORS.multicall,
+    parameters: [{ type: "bytes[]", value: params.calls.map((call, index) => assertHexBytes2(call, `calls[${index}]`)) }],
+    ...params.callValue !== void 0 ? { callValue: params.callValue } : {},
+    ...params.feeLimit !== void 0 ? { feeLimit: params.feeLimit } : {},
+    ...params.tokenRequirements !== void 0 ? { tokenRequirements: params.tokenRequirements } : {},
+    ...params.metadata !== void 0 ? { metadata: params.metadata } : {}
+  });
+}
+function buildV4MintPositionAction(params) {
+  const poolKey = normalizeV4PoolKey(params.positionConfig.poolKey);
+  const target = positionManagerTarget(params);
+  const payload = encodeV4MintPositionPlannerPayload({
+    positionConfig: { ...params.positionConfig, poolKey },
+    liquidity: params.liquidity,
+    amount0Max: params.amount0Max,
+    amount1Max: params.amount1Max,
+    owner: params.owner,
+    ...params.sweepRecipient !== void 0 ? { sweepRecipient: params.sweepRecipient } : {},
+    ...params.hookData !== void 0 ? { hookData: params.hookData } : {}
+  });
+  const computedCallValue = nativeCallValue(poolKey, params.amount0Max, params.amount1Max);
+  return buildV4ModifyLiquiditiesAction({
+    ...params,
+    id: actionId(params, "mint-position"),
+    payload,
+    deadline: params.deadline,
+    callValue: params.callValue ?? computedCallValue,
+    tokenRequirements: tokenRequirements(poolKey, params.amount0Max, params.amount1Max, target)
+  });
+}
+function buildV4IncreaseLiquidityAction(params) {
+  const poolKey = normalizeV4PoolKey(params.poolKey);
+  const target = positionManagerTarget(params);
+  const payload = encodeV4IncreaseLiquidityPlannerPayload({
+    poolKey,
+    tokenId: params.tokenId,
+    liquidity: params.liquidity,
+    amount0Max: params.amount0Max,
+    amount1Max: params.amount1Max,
+    ...params.sweepRecipient !== void 0 ? { sweepRecipient: params.sweepRecipient } : {},
+    ...params.hookData !== void 0 ? { hookData: params.hookData } : {}
+  });
+  const computedCallValue = nativeCallValue(poolKey, params.amount0Max, params.amount1Max);
+  return buildV4ModifyLiquiditiesAction({
+    ...params,
+    id: actionId(params, "increase-liquidity"),
+    payload,
+    deadline: params.deadline,
+    callValue: params.callValue ?? computedCallValue,
+    tokenRequirements: tokenRequirements(poolKey, params.amount0Max, params.amount1Max, target)
+  });
+}
+function buildV4DecreaseLiquidityAction(params) {
+  const poolKey = normalizeV4PoolKey(params.poolKey);
+  const payload = encodeV4DecreaseLiquidityPlannerPayload({
+    poolKey,
+    tokenId: params.tokenId,
+    liquidity: params.liquidity,
+    amount0Min: params.amount0Min,
+    amount1Min: params.amount1Min,
+    recipient: params.recipient,
+    ...params.settlementMode !== void 0 ? { settlementMode: params.settlementMode } : {},
+    ...params.hookData !== void 0 ? { hookData: params.hookData } : {}
+  });
+  return buildV4ModifyLiquiditiesAction({
+    ...params,
+    id: actionId(params, "decrease-liquidity"),
+    payload,
+    deadline: params.deadline,
+    callValue: params.callValue ?? 0n
+  });
+}
+function buildV4CollectAction(params) {
+  const poolKey = normalizeV4PoolKey(params.poolKey);
+  const payload = encodeV4DecreaseLiquidityPlannerPayload({
+    poolKey,
+    tokenId: params.tokenId,
+    liquidity: 0n,
+    amount0Min: 0n,
+    amount1Min: 0n,
+    recipient: params.recipient,
+    ...params.settlementMode !== void 0 ? { settlementMode: params.settlementMode } : {},
+    ...params.hookData !== void 0 ? { hookData: params.hookData } : {}
+  });
+  return buildV4ModifyLiquiditiesAction({
+    ...params,
+    id: actionId(params, "collect"),
+    payload,
+    deadline: params.deadline,
+    callValue: params.callValue ?? 0n
+  });
+}
+
+// src/parameters.ts
+var import_sun_sdk_core5 = require("@sun-protocol/sun-sdk-core");
+var V4_HOOKS_REGISTRATION_OFFSET = {
+  beforeInitialize: 0,
+  afterInitialize: 1,
+  beforeAddLiquidity: 2,
+  afterAddLiquidity: 3,
+  beforeRemoveLiquidity: 4,
+  afterRemoveLiquidity: 5,
+  beforeSwap: 6,
+  afterSwap: 7,
+  beforeDonate: 8,
+  afterDonate: 9,
+  beforeSwapReturnsDelta: 10,
+  afterSwapReturnsDelta: 11,
+  afterAddLiquidityReturnsDelta: 12,
+  afterRemoveLiquidityReturnsDelta: 13
+};
+var INT24_MIN = -8388608;
+var INT24_MAX = 8388607;
+var UINT16_MAX = 65535;
+var HOOKS_REGISTRATION_MAX = 16383;
+var BYTES32_HEX_LENGTH = 64;
+function assertInt24(value, label) {
+  (0, import_sun_sdk_core5.sdkInvariant)(Number.isInteger(value), import_sun_sdk_core5.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, `${label} must be an integer`, {
+    label,
+    value
+  });
+  (0, import_sun_sdk_core5.sdkInvariant)(value >= INT24_MIN && value <= INT24_MAX, import_sun_sdk_core5.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, `${label} must fit int24`, {
+    label,
+    value
+  });
+  return value;
+}
+function signedInt24ToHex(value) {
+  const int24 = assertInt24(value, "tickSpacing");
+  const encoded = int24 < 0 ? 16777216 + int24 : int24;
+  return encoded.toString(16).padStart(6, "0");
+}
+function hexToSignedInt24(hex) {
+  const value = Number.parseInt(hex, 16);
+  return value >= 8388608 ? value - 16777216 : value;
+}
+function encodeV4HooksRegistration(hooksRegistration = {}) {
+  let registration = 0;
+  for (const key of Object.keys(V4_HOOKS_REGISTRATION_OFFSET)) {
+    if (hooksRegistration[key]) {
+      registration |= 1 << V4_HOOKS_REGISTRATION_OFFSET[key];
+    }
+  }
+  return registration;
+}
+function decodeV4HooksRegistration(registration) {
+  (0, import_sun_sdk_core5.sdkInvariant)(
+    Number.isInteger(registration) && registration >= 0 && registration <= HOOKS_REGISTRATION_MAX,
+    import_sun_sdk_core5.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT,
+    "V4 hooks registration must fit the known 14-bit bitmap",
+    { registration }
+  );
+  const decoded = {};
+  for (const key of Object.keys(V4_HOOKS_REGISTRATION_OFFSET)) {
+    if ((registration & 1 << V4_HOOKS_REGISTRATION_OFFSET[key]) !== 0) {
+      decoded[key] = true;
+    }
+  }
+  return decoded;
+}
+function encodeV4PoolParameters(params) {
+  const tickSpacing = signedInt24ToHex(params.tickSpacing);
+  const hooksRegistration = encodeV4HooksRegistration(params.hooksRegistration);
+  (0, import_sun_sdk_core5.sdkInvariant)(
+    hooksRegistration <= UINT16_MAX,
+    import_sun_sdk_core5.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT,
+    "V4 hooks registration must fit uint16",
+    { hooksRegistration }
+  );
+  const hooksHex = hooksRegistration.toString(16).padStart(4, "0");
+  return assertV4PoolParameters(`0x${`${tickSpacing}${hooksHex}`.padStart(BYTES32_HEX_LENGTH, "0")}`);
+}
+function decodeV4PoolParameters(encoded) {
+  const parameters = assertV4PoolParameters(encoded);
+  const hex = parameters.slice(2);
+  const tickSpacingHex = hex.slice(-10, -4);
+  const hooksHex = hex.slice(-4);
+  const hooksRegistration = Number.parseInt(hooksHex, 16);
+  return {
+    tickSpacing: hexToSignedInt24(tickSpacingHex),
+    hooksRegistration: decodeV4HooksRegistration(hooksRegistration)
+  };
+}
+
+// src/pool-id.ts
+var import_sun_sdk_core6 = require("@sun-protocol/sun-sdk-core");
+var import_keccak2562 = require("@ethersproject/keccak256");
+var EVM_ADDRESS_HEX_LENGTH = 40;
+var BYTES32_HEX_LENGTH2 = 64;
+function assertHex(value, label) {
+  (0, import_sun_sdk_core6.sdkInvariant)(/^0x[a-fA-F0-9]*$/.test(value), import_sun_sdk_core6.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, `${label} must be hex`, {
+    label,
+    value
+  });
+  return value.toLowerCase();
+}
+function encodeAbiAddress(value) {
+  const address = tronAddressToEvmHex(value).slice(2);
+  (0, import_sun_sdk_core6.sdkInvariant)(
+    address.length === EVM_ADDRESS_HEX_LENGTH,
+    import_sun_sdk_core6.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT,
+    "Encoded EVM address must be 20 bytes",
+    { value }
+  );
+  return address.padStart(BYTES32_HEX_LENGTH2, "0");
+}
+function encodeAbiUint24(value) {
+  (0, import_sun_sdk_core6.sdkInvariant)(Number.isInteger(value) && value >= 0 && value <= 16777215, import_sun_sdk_core6.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "uint24 value is out of range", {
+    value
+  });
+  return value.toString(16).padStart(BYTES32_HEX_LENGTH2, "0");
+}
+function encodeAbiBytes32(value) {
+  const bytes32 = assertHex(value, "bytes32").slice(2);
+  (0, import_sun_sdk_core6.sdkInvariant)(bytes32.length === BYTES32_HEX_LENGTH2, import_sun_sdk_core6.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "bytes32 must be 32 bytes", {
+    value
+  });
+  return bytes32;
+}
+function encodeV4PoolKey(poolKey) {
+  const normalized = normalizeV4PoolKey(poolKey);
+  return `0x${[
+    encodeAbiAddress(normalized.currency0),
+    encodeAbiAddress(normalized.currency1),
+    encodeAbiAddress(normalized.hooks),
+    encodeAbiUint24(normalized.fee),
+    encodeAbiBytes32(normalized.parameters)
+  ].join("")}`;
+}
+function computeV4PoolId(poolKey) {
+  return (0, import_keccak2562.keccak256)(encodeV4PoolKey(poolKey));
+}
+
+// src/reads.ts
+var import_sun_sdk_chains2 = require("@sun-protocol/sun-sdk-chains");
+var V4_POOL_KEY_ABI_COMPONENTS = [
+  { name: "currency0", type: "address" },
+  { name: "currency1", type: "address" },
+  { name: "hooks", type: "address" },
+  { name: "fee", type: "uint24" },
+  { name: "parameters", type: "bytes32" }
+];
+function positionReadAbi(name, inputs, outputs) {
+  return { type: "function", name, stateMutability: "view", inputs, outputs };
+}
+var V4_POSITION_MANAGER_READ_SELECTORS = {
+  ownerOf: "ownerOf(uint256)",
+  getApproved: "getApproved(uint256)",
+  isApprovedForAll: "isApprovedForAll(address,address)",
+  getPoolAndPositionInfo: "getPoolAndPositionInfo(uint256)",
+  getPositionLiquidity: "getPositionLiquidity(uint256)"
+};
+var V4_POOL_MANAGER_READ_SELECTORS = {
+  getSlot0: "getSlot0(bytes32)",
+  getLiquidity: "getLiquidity(bytes32)",
+  poolIdToPoolKey: "poolIdToPoolKey(bytes32)",
+  getFeeGrowthGlobals: "getFeeGrowthGlobals(bytes32)"
+};
+function valueOf2(value) {
+  return BigInt(value.toString()).toString();
+}
+function bytes32ValueOf(value) {
+  const normalized = BigInt(value.toString());
+  if (normalized < 0n || normalized >= 1n << 256n) {
+    throw new RangeError("tokenId must fit in an unsigned 256-bit value");
+  }
+  return `0x${normalized.toString(16).padStart(64, "0")}`;
+}
+function positionManagerTarget2(params) {
+  return params.positionManager ?? (0, import_sun_sdk_chains2.getContractAddress)(params.network, "sunswapV4PositionManager");
+}
+function poolManagerTarget(params) {
+  return params.poolManager ?? (0, import_sun_sdk_chains2.getContractAddress)(params.network, "sunswapV4PoolManager");
+}
+function positionManagerRead(params, functionSelector2, parameters, action, abiFunction) {
+  return {
+    target: positionManagerTarget2(params),
+    functionSelector: functionSelector2,
+    parameters,
+    abiFunction,
+    metadata: { protocol: "sunswap-v4", contract: "position-manager", action, network: params.network }
+  };
+}
+function poolReadAbi(functionSelector2) {
+  const name = functionSelector2.slice(0, functionSelector2.indexOf("("));
+  const outputs = {
+    getSlot0: [
+      { name: "sqrtPriceX96", type: "uint160" },
+      { name: "tick", type: "int24" },
+      { name: "protocolFee", type: "uint24" },
+      { name: "lpFee", type: "uint24" }
+    ],
+    getLiquidity: [{ name: "liquidity", type: "uint128" }],
+    poolIdToPoolKey: V4_POOL_KEY_ABI_COMPONENTS,
+    getFeeGrowthGlobals: [
+      { name: "feeGrowthGlobal0X128", type: "uint256" },
+      { name: "feeGrowthGlobal1X128", type: "uint256" }
+    ]
+  };
+  return positionReadAbi(name, [{ name: "id", type: "bytes32" }], outputs[name] ?? []);
+}
+function poolManagerRead(params, functionSelector2, poolId) {
+  return {
+    target: poolManagerTarget(params),
+    functionSelector: functionSelector2,
+    parameters: [{ type: "bytes32", value: assertV4PoolId(poolId) }],
+    abiFunction: poolReadAbi(functionSelector2),
+    metadata: { protocol: "sunswap-v4", contract: "pool-manager", network: params.network }
+  };
+}
+function buildV4PoolSlot0Read(params) {
+  return poolManagerRead(params, V4_POOL_MANAGER_READ_SELECTORS.getSlot0, params.poolId);
+}
+function buildV4PoolLiquidityRead(params) {
+  return poolManagerRead(params, V4_POOL_MANAGER_READ_SELECTORS.getLiquidity, params.poolId);
+}
+function buildV4PoolKeyRead(params) {
+  return poolManagerRead(params, V4_POOL_MANAGER_READ_SELECTORS.poolIdToPoolKey, params.poolId);
+}
+function buildV4PoolFeeGrowthGlobalsRead(params) {
+  return poolManagerRead(params, V4_POOL_MANAGER_READ_SELECTORS.getFeeGrowthGlobals, params.poolId);
+}
+function buildV4HookRegistrationBitmapRead(params) {
+  return {
+    target: params.hooks,
+    functionSelector: "getHooksRegistrationBitmap()",
+    abiFunction: positionReadAbi(
+      "getHooksRegistrationBitmap",
+      [],
+      [{ name: "permissions", type: "uint16" }]
+    ),
+    metadata: {
+      protocol: "sunswap-v4",
+      contract: "hooks",
+      action: "get-registration-bitmap",
+      network: params.network
+    }
+  };
+}
+function buildV4PoolStateReads(params) {
+  return [buildV4PoolSlot0Read(params), buildV4PoolLiquidityRead(params)];
+}
+function buildV4PositionOwnerRead(params) {
+  return positionManagerRead(
+    params,
+    V4_POSITION_MANAGER_READ_SELECTORS.ownerOf,
+    [{ type: "uint256", value: valueOf2(params.tokenId) }],
+    "owner-of",
+    positionReadAbi("ownerOf", [{ name: "id", type: "uint256" }], [{ name: "owner", type: "address" }])
+  );
+}
+function buildV4PositionApprovedRead(params) {
+  return positionManagerRead(
+    params,
+    V4_POSITION_MANAGER_READ_SELECTORS.getApproved,
+    [{ type: "uint256", value: valueOf2(params.tokenId) }],
+    "get-approved",
+    positionReadAbi("getApproved", [{ name: "tokenId", type: "uint256" }], [{ name: "approved", type: "address" }])
+  );
+}
+function buildV4PoolAndPositionInfoRead(params) {
+  return positionManagerRead(
+    params,
+    V4_POSITION_MANAGER_READ_SELECTORS.getPoolAndPositionInfo,
+    [{ type: "uint256", value: valueOf2(params.tokenId) }],
+    "get-pool-and-position-info",
+    positionReadAbi(
+      "getPoolAndPositionInfo",
+      [{ name: "tokenId", type: "uint256" }],
+      [
+        { name: "poolKey", type: "tuple", components: V4_POOL_KEY_ABI_COMPONENTS },
+        { name: "info", type: "uint256" }
+      ]
+    )
+  );
+}
+function buildV4PositionLiquidityRead(params) {
+  return positionManagerRead(
+    params,
+    V4_POSITION_MANAGER_READ_SELECTORS.getPositionLiquidity,
+    [{ type: "uint256", value: valueOf2(params.tokenId) }],
+    "get-position-liquidity",
+    positionReadAbi("getPositionLiquidity", [{ name: "tokenId", type: "uint256" }], [{ name: "liquidity", type: "uint128" }])
+  );
+}
+function buildV4PositionApprovalForAllRead(params) {
+  return positionManagerRead(
+    params,
+    V4_POSITION_MANAGER_READ_SELECTORS.isApprovedForAll,
+    [
+      { type: "address", value: params.owner },
+      { type: "address", value: params.operator }
+    ],
+    "is-approved-for-all",
+    positionReadAbi(
+      "isApprovedForAll",
+      [{ name: "owner", type: "address" }, { name: "operator", type: "address" }],
+      [{ name: "approved", type: "bool" }]
+    )
+  );
+}
+function buildV4PositionFeesRead(params) {
+  return {
+    target: params.lpFeeHelper ?? (0, import_sun_sdk_chains2.getContractAddress)(params.network, "sunswapV4LpFeeHelper"),
+    functionSelector: "getLPFees(address,bytes32,address,int24,int24,bytes32)",
+    parameters: [
+      { type: "address", value: poolManagerTarget(params) },
+      { type: "bytes32", value: assertV4PoolId(params.poolId) },
+      { type: "address", value: positionManagerTarget2(params) },
+      { type: "int24", value: params.tickLower },
+      { type: "int24", value: params.tickUpper },
+      { type: "bytes32", value: bytes32ValueOf(params.tokenId) }
+    ],
+    abiFunction: positionReadAbi(
+      "getLPFees",
+      [
+        { name: "poolManager", type: "address" },
+        { name: "poolId", type: "bytes32" },
+        { name: "owner", type: "address" },
+        { name: "tickLower", type: "int24" },
+        { name: "tickUpper", type: "int24" },
+        { name: "salt", type: "bytes32" }
+      ],
+      [
+        { name: "feesOwed0", type: "uint256" },
+        { name: "feesOwed1", type: "uint256" }
+      ]
+    ),
+    metadata: {
+      protocol: "sunswap-v4",
+      contract: "lp-fee-helper",
+      action: "get-position-fees",
+      network: params.network
+    }
+  };
+}
+function buildV4PositionReads(params) {
+  return [
+    buildV4PoolAndPositionInfoRead(params),
+    buildV4PositionLiquidityRead(params),
+    buildV4PositionOwnerRead(params),
+    buildV4PositionApprovedRead(params)
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  V4_ACTIONS,
+  V4_ACTION_CONSTANTS,
+  V4_DYNAMIC_FEE_FLAG,
+  V4_EMPTY_PARAMETERS,
+  V4_HOOKS_REGISTRATION_OFFSET,
+  V4_MAX_STATIC_FEE,
+  V4_POOL_MANAGER_READ_SELECTORS,
+  V4_POSITION_MANAGER_READ_SELECTORS,
+  V4_POSITION_MANAGER_SELECTORS,
+  V4_UINT24_MAX,
+  assertV4Fee,
+  assertV4HookFeeCombination,
+  assertV4PoolId,
+  assertV4PoolParameters,
+  buildV4CollectAction,
+  buildV4DecreaseLiquidityAction,
+  buildV4HookRegistrationBitmapRead,
+  buildV4IncreaseLiquidityAction,
+  buildV4InitializePoolAction,
+  buildV4MintPositionAction,
+  buildV4ModifyLiquiditiesAction,
+  buildV4MulticallAction,
+  buildV4PoolAndPositionInfoRead,
+  buildV4PoolFeeGrowthGlobalsRead,
+  buildV4PoolKeyRead,
+  buildV4PoolLiquidityRead,
+  buildV4PoolSlot0Read,
+  buildV4PoolStateReads,
+  buildV4PositionApprovalForAllRead,
+  buildV4PositionApprovedRead,
+  buildV4PositionFeesRead,
+  buildV4PositionLiquidityRead,
+  buildV4PositionOwnerRead,
+  buildV4PositionReads,
+  computeV4PoolId,
+  createV4PoolKey,
+  decodeV4HooksRegistration,
+  decodeV4PoolParameters,
+  encodeV4ActionParams,
+  encodeV4Actions,
+  encodeV4ActionsPlanner,
+  encodeV4CollectPlannerPayload,
+  encodeV4ContractCallAction,
+  encodeV4DecreaseLiquidityPlannerPayload,
+  encodeV4HooksRegistration,
+  encodeV4IncreaseLiquidityPlannerPayload,
+  encodeV4MintPositionPlannerPayload,
+  encodeV4Permit2ForwardCall,
+  encodeV4PoolKey,
+  encodeV4PoolParameters,
+  getV4StaticFee,
+  isV4DynamicFee,
+  normalizeV4PoolKey,
+  toV4PoolKeyTuple,
+  tronAddressToEvmHex
+});
+//# sourceMappingURL=index.cjs.map