@continuumdao/ctm-mpc-defi 0.2.22 → 0.2.25

package/dist/protocols/evm/hyperliquid/index.cjs

@@ -348,6 +348,12 @@ async function hyperliquidFetchOpenOrders(args) {
   const orders = await hyperliquidInfoPost(args.chainId, req);
   return { orders: orders ?? [] };
 }
+async function hyperliquidFetchFrontendOpenOrders(args) {
+  const req = { type: "frontendOpenOrders", user: args.user };
+  if (args.dex?.trim()) req.dex = args.dex.trim();
+  const orders = await hyperliquidInfoPost(args.chainId, req);
+  return { orders: orders ?? [] };
+}
 async function hyperliquidFetchUserVaultEquities(args) {
   const rows = await hyperliquidInfoPost(args.chainId, {
     type: "userVaultEquities",
@@ -1159,8 +1165,404 @@ async function buildEvmMultisignBatch(args) {
   }
   return result;
 }
+var EIP712_SIGN_REQUEST_KIND = "eip712";
+function msgHashNo0x(digest) {
+  return digest.startsWith("0x") ? digest.slice(2) : digest;
+}
+function eip712SignatureText(domain, primaryType) {
+  return JSON.stringify({
+    kind: "EIP-712",
+    ...typeof domain.name === "string" ? { name: domain.name } : {},
+    primaryType
+  });
+}
+function jsonStringifyForAudit(value) {
+  return JSON.stringify(value, (_, v) => typeof v === "bigint" ? v.toString() : v);
+}
+function eip712MsgRawHex(typedData, delivery) {
+  const envelope = {
+    version: 1,
+    ...typedData,
+    delivery
+  };
+  return viem.stringToHex(jsonStringifyForAudit(envelope));
+}
+function buildEip712MultisignBody(args) {
+  const { typedData, delivery } = args;
+  const digest = viem.hashTypedData({
+    domain: typedData.domain,
+    types: typedData.types,
+    primaryType: typedData.primaryType,
+    message: typedData.message
+  });
+  const extraJSON = {
+    signRequestKind: EIP712_SIGN_REQUEST_KIND,
+    eip712: {
+      version: 1,
+      digest,
+      domain: typedData.domain,
+      types: typedData.types,
+      primaryType: typedData.primaryType,
+      message: typedData.message
+    },
+    delivery
+  };
+  return finalizeMultisign({
+    keyGen: args.keyGen,
+    purposeText: args.purposeText,
+    purposeSuffix: args.purposeSuffix,
+    destinationChainID: args.destinationChainID,
+    destinationAddress: args.destinationAddress,
+    extraJSON,
+    expiryDate: args.expiryDate,
+    legs: [
+      {
+        msgHash: msgHashNo0x(digest),
+        msgRaw: eip712MsgRawHex(typedData, delivery),
+        destinationAddress: args.destinationAddress,
+        signatureText: eip712SignatureText(typedData.domain, typedData.primaryType),
+        audit: {
+          kind: "EIP712",
+          primaryType: typedData.primaryType,
+          deliveryKind: delivery.kind,
+          ...args.audit ?? {}
+        },
+        feeSnapshot: {}
+      }
+    ]
+  });
+}
+var EXCHANGE_DOMAIN = {
+  name: "Exchange",
+  version: "1",
+  chainId: 1337,
+  verifyingContract: "0x0000000000000000000000000000000000000000"
+};
+var AGENT_TYPES = {
+  Agent: [
+    { name: "source", type: "string" },
+    { name: "connectionId", type: "bytes32" }
+  ]
+};
+function adjustMsgpackValue(value) {
+  if (Array.isArray(value)) return value.map(adjustMsgpackValue);
+  if (typeof value === "object" && value !== null) {
+    const result = {};
+    for (const key of Object.keys(value)) {
+      const entry = value[key];
+      if (entry !== void 0) result[key] = adjustMsgpackValue(entry);
+    }
+    return result;
+  }
+  if (typeof value === "number" && Number.isInteger(value) && (value >= 4294967296 || value < -2147483648)) {
+    return BigInt(value);
+  }
+  return value;
+}
+function toUint64Bytes(n) {
+  const bytes = new Uint8Array(8);
+  new DataView(bytes.buffer).setBigUint64(0, BigInt(n));
+  return bytes;
+}
+function concatBytes(...parts) {
+  const total = parts.reduce((sum, p) => sum + p.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const p of parts) {
+    out.set(p, offset);
+    offset += p.length;
+  }
+  return out;
+}
+function hexToBytes(hex) {
+  const h = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(h.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(h.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function createHyperliquidL1ActionHash(args) {
+  const { action, nonce, vaultAddress, expiresAfter } = args;
+  const actionBytes = msgpack.encode(adjustMsgpackValue(action));
+  const nonceBytes = toUint64Bytes(nonce);
+  const vaultMarker = vaultAddress ? new Uint8Array([1]) : new Uint8Array([0]);
+  const vaultBytes = vaultAddress ? hexToBytes(vaultAddress) : new Uint8Array();
+  const expiresMarker = expiresAfter !== void 0 ? new Uint8Array([0]) : new Uint8Array();
+  const expiresBytes = expiresAfter !== void 0 ? toUint64Bytes(expiresAfter) : new Uint8Array();
+  const bytes = concatBytes(actionBytes, nonceBytes, vaultMarker, vaultBytes, expiresMarker, expiresBytes);
+  return viem.keccak256(bytes);
+}
+function buildHyperliquidAgentTypedData(args) {
+  const connectionId = createHyperliquidL1ActionHash(args);
+  const source = args.isTestnet ? "b" : "a";
+  return {
+    domain: EXCHANGE_DOMAIN,
+    types: AGENT_TYPES,
+    primaryType: "Agent",
+    message: {
+      source,
+      connectionId
+    },
+    connectionId,
+    nonce: args.nonce,
+    action: args.action
+  };
+}
+function buildHyperliquidUpdateLeverageAction(args) {
+  const leverage = Math.trunc(args.leverage);
+  if (!Number.isFinite(leverage) || leverage < 1) {
+    throw new Error("leverage must be a positive integer");
+  }
+  return {
+    type: "updateLeverage",
+    asset: args.asset,
+    isCross: args.isCross !== false,
+    leverage
+  };
+}
+function hyperliquidFloatToWire(value) {
+  const n = typeof value === "number" ? value : Number.parseFloat(String(value).trim());
+  if (!Number.isFinite(n)) throw new Error("Invalid Hyperliquid wire number.");
+  const rounded = n.toFixed(8);
+  if (Math.abs(Number.parseFloat(rounded) - n) >= 1e-12) {
+    throw new Error(`Hyperliquid wire value ${value} has too many decimal places.`);
+  }
+  const normalized = Number(rounded === "-0" ? "0" : rounded);
+  return String(normalized);
+}
+function hyperliquidL1TifFromKey(tif) {
+  const key = String(tif ?? "gtc").trim().toLowerCase();
+  if (key === "alo") return "Alo";
+  if (key === "ioc") return "Ioc";
+  if (key === "gtc") return "Gtc";
+  throw new Error(`Unknown time-in-force: ${tif}. Use alo, gtc, or ioc.`);
+}
+function buildHyperliquidLimitOrderWire(args) {
+  return {
+    a: args.asset,
+    b: args.isBuy,
+    p: hyperliquidFloatToWire(args.limitPxHuman),
+    s: hyperliquidFloatToWire(args.szHuman),
+    r: Boolean(args.reduceOnly),
+    t: { limit: { tif: hyperliquidL1TifFromKey(args.tif) } }
+  };
+}
+function buildHyperliquidTriggerOrderWire(args) {
+  const mode = args.tpslExecMode ?? "limit_at_trigger";
+  const triggerPx = hyperliquidFloatToWire(args.triggerPxHuman);
+  const limitPx = mode === "market" ? triggerPx : hyperliquidFloatToWire(args.limitPxHuman ?? args.triggerPxHuman);
+  return {
+    a: args.asset,
+    b: args.isBuy,
+    p: limitPx,
+    s: hyperliquidFloatToWire(args.szHuman),
+    r: true,
+    t: {
+      trigger: {
+        isMarket: mode === "market",
+        triggerPx,
+        tpsl: args.tpsl
+      }
+    }
+  };
+}
+function validateHyperliquidTpslGeometry(args) {
+  const entry = Number.parseFloat(String(args.entryPxHuman).trim());
+  const tp = args.takeProfitTriggerPxHuman?.trim() != null && args.takeProfitTriggerPxHuman.trim() !== "" ? Number.parseFloat(args.takeProfitTriggerPxHuman.trim()) : null;
+  const sl = args.stopLossTriggerPxHuman?.trim() != null && args.stopLossTriggerPxHuman.trim() !== "" ? Number.parseFloat(args.stopLossTriggerPxHuman.trim()) : null;
+  if (!Number.isFinite(entry)) throw new Error("Invalid entry limit price for TP/SL validation.");
+  if (tp != null && !Number.isFinite(tp)) throw new Error("Invalid take-profit trigger price.");
+  if (sl != null && !Number.isFinite(sl)) throw new Error("Invalid stop-loss trigger price.");
+  if (args.isBuy) {
+    if (sl != null && sl >= entry) {
+      throw new Error("Long stop-loss must be below entry price.");
+    }
+    if (tp != null && tp <= entry) {
+      throw new Error("Long take-profit must be above entry price.");
+    }
+  } else {
+    if (sl != null && sl <= entry) {
+      throw new Error("Short stop-loss must be above entry price.");
+    }
+    if (tp != null && tp >= entry) {
+      throw new Error("Short take-profit must be below entry price.");
+    }
+  }
+}
+function buildHyperliquidNormalTpslOrderWires(args) {
+  validateHyperliquidTpslGeometry({
+    isBuy: args.isBuy,
+    entryPxHuman: args.limitPxHuman,
+    takeProfitTriggerPxHuman: args.takeProfitTriggerPxHuman,
+    stopLossTriggerPxHuman: args.stopLossTriggerPxHuman
+  });
+  const orders = [
+    buildHyperliquidLimitOrderWire({
+      asset: args.asset,
+      isBuy: args.isBuy,
+      limitPxHuman: args.limitPxHuman,
+      szHuman: args.szHuman,
+      tif: args.tif
+    })
+  ];
+  const closeIsBuy = !args.isBuy;
+  const tp = args.takeProfitTriggerPxHuman?.trim();
+  const sl = args.stopLossTriggerPxHuman?.trim();
+  if (tp) {
+    orders.push(
+      buildHyperliquidTriggerOrderWire({
+        asset: args.asset,
+        isBuy: closeIsBuy,
+        szHuman: args.szHuman,
+        triggerPxHuman: tp,
+        tpsl: "tp",
+        tpslExecMode: args.tpslExecMode
+      })
+    );
+  }
+  if (sl) {
+    orders.push(
+      buildHyperliquidTriggerOrderWire({
+        asset: args.asset,
+        isBuy: closeIsBuy,
+        szHuman: args.szHuman,
+        triggerPxHuman: sl,
+        tpsl: "sl",
+        tpslExecMode: args.tpslExecMode
+      })
+    );
+  }
+  return orders;
+}
+function buildHyperliquidOrderAction(args) {
+  return {
+    type: "order",
+    orders: args.orders,
+    grouping: args.grouping ?? "na"
+  };
+}
+
+// src/protocols/evm/hyperliquid/exchangeMultisign.ts
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+async function buildHyperliquidLimitOrderWithTpslMultisign(args) {
+  const marketKind = args.marketKind ?? "perp";
+  const { asset } = await hyperliquidResolveAsset({
+    chainId: args.chainId,
+    coin: args.coin,
+    marketKind,
+    dex: args.dex
+  });
+  const tp = args.takeProfitTriggerPxHuman?.trim();
+  const sl = args.stopLossTriggerPxHuman?.trim();
+  if (!tp && !sl) {
+    throw new Error("At least one of takeProfitTriggerPxHuman or stopLossTriggerPxHuman is required for bracket orders.");
+  }
+  const orderWires = buildHyperliquidNormalTpslOrderWires({
+    asset,
+    isBuy: args.isBuy,
+    limitPxHuman: args.limitPxHuman,
+    szHuman: args.szHuman,
+    tif: args.tif,
+    takeProfitTriggerPxHuman: tp || void 0,
+    stopLossTriggerPxHuman: sl || void 0,
+    tpslExecMode: args.tpslExecMode
+  });
+  const action = buildHyperliquidOrderAction({
+    orders: orderWires,
+    grouping: "normalTpsl"
+  });
+  const nonce = args.nonce ?? Date.now();
+  const isTestnet = args.chainId === 998;
+  const typed = buildHyperliquidAgentTypedData({ action, nonce, isTestnet });
+  return buildEip712MultisignBody({
+    keyGen: args.keyGen,
+    purposeText: args.purposeText,
+    destinationChainID: String(args.chainId),
+    destinationAddress: ZERO_ADDRESS,
+    typedData: {
+      domain: typed.domain,
+      types: typed.types,
+      primaryType: typed.primaryType,
+      message: typed.message
+    },
+    delivery: {
+      kind: "hyperliquid_exchange",
+      chainId: args.chainId,
+      isTestnet,
+      action,
+      nonce
+    },
+    audit: {
+      protocol: "hyperliquid",
+      action: "limitOrderWithTpsl",
+      coin: args.coin,
+      marketKind,
+      asset,
+      isBuy: args.isBuy,
+      limitPxHuman: args.limitPxHuman,
+      szHuman: args.szHuman,
+      takeProfitTriggerPxHuman: tp ?? null,
+      stopLossTriggerPxHuman: sl ?? null,
+      tpslExecMode: args.tpslExecMode ?? "limit_at_trigger",
+      grouping: "normalTpsl",
+      nonce,
+      connectionId: typed.connectionId
+    }
+  });
+}
+async function buildHyperliquidUpdateLeverageMultisign(args) {
+  const marketKind = args.marketKind ?? "perp";
+  const { asset } = await hyperliquidResolveAsset({
+    chainId: args.chainId,
+    coin: args.coin,
+    marketKind,
+    dex: args.dex
+  });
+  const action = buildHyperliquidUpdateLeverageAction({
+    asset,
+    leverage: args.leverage,
+    isCross: args.isCross
+  });
+  const nonce = args.nonce ?? Date.now();
+  const isTestnet = args.chainId === 998;
+  const typed = buildHyperliquidAgentTypedData({ action, nonce, isTestnet });
+  return buildEip712MultisignBody({
+    keyGen: args.keyGen,
+    purposeText: args.purposeText,
+    destinationChainID: String(args.chainId),
+    destinationAddress: ZERO_ADDRESS,
+    typedData: {
+      domain: typed.domain,
+      types: typed.types,
+      primaryType: typed.primaryType,
+      message: typed.message
+    },
+    delivery: {
+      kind: "hyperliquid_exchange",
+      chainId: args.chainId,
+      isTestnet,
+      action,
+      nonce
+    },
+    audit: {
+      protocol: "hyperliquid",
+      action: "updateLeverage",
+      coin: args.coin,
+      marketKind,
+      asset,
+      leverage: action.leverage,
+      isCross: action.isCross,
+      nonce,
+      connectionId: typed.connectionId
+    }
+  });
+}
 
 // src/protocols/evm/hyperliquid/multisign.ts
+function hasHyperliquidBracketTpsl(args) {
+  return Boolean(args.takeProfitTriggerPxHuman?.trim() || args.stopLossTriggerPxHuman?.trim());
+}
 async function buildCoreWriterMultisign(common, data, signatureMeta) {
   const step = coreWriterStep(data);
   return buildEvmMultisignBatch({
@@ -1185,6 +1587,26 @@ async function buildCoreWriterMultisign(common, data, signatureMeta) {
   });
 }
 async function buildEvmMultisignBodyHyperliquidLimitOrderBatch(args) {
+  if (hasHyperliquidBracketTpsl(args)) {
+    if (args.reduceOnly) {
+      throw new Error("reduceOnly cannot be combined with takeProfitTriggerPxHuman or stopLossTriggerPxHuman.");
+    }
+    return buildHyperliquidLimitOrderWithTpslMultisign({
+      keyGen: args.keyGen,
+      chainId: args.chainId,
+      purposeText: args.purposeText,
+      coin: args.coin,
+      marketKind: args.marketKind,
+      dex: args.dex,
+      isBuy: args.isBuy,
+      limitPxHuman: args.limitPxHuman,
+      szHuman: args.szHuman,
+      tif: args.tif,
+      takeProfitTriggerPxHuman: args.takeProfitTriggerPxHuman,
+      stopLossTriggerPxHuman: args.stopLossTriggerPxHuman,
+      tpslExecMode: args.tpslExecMode
+    });
+  }
   const marketKind = args.marketKind ?? "perp";
   const { asset } = await hyperliquidResolveAsset({
     chainId: args.chainId,
@@ -1334,212 +1756,6 @@ async function buildEvmMultisignBodyHyperliquidDelegateOnlyBatch(args) {
 async function buildEvmMultisignBodyHyperliquidUndelegateBatch(args) {
   return buildEvmMultisignBodyHyperliquidDelegateBatch({ ...args, isUndelegate: true });
 }
-var EXCHANGE_DOMAIN = {
-  name: "Exchange",
-  version: "1",
-  chainId: 1337,
-  verifyingContract: "0x0000000000000000000000000000000000000000"
-};
-var AGENT_TYPES = {
-  Agent: [
-    { name: "source", type: "string" },
-    { name: "connectionId", type: "bytes32" }
-  ]
-};
-function adjustMsgpackValue(value) {
-  if (Array.isArray(value)) return value.map(adjustMsgpackValue);
-  if (typeof value === "object" && value !== null) {
-    const result = {};
-    for (const key of Object.keys(value)) {
-      const entry = value[key];
-      if (entry !== void 0) result[key] = adjustMsgpackValue(entry);
-    }
-    return result;
-  }
-  if (typeof value === "number" && Number.isInteger(value) && (value >= 4294967296 || value < -2147483648)) {
-    return BigInt(value);
-  }
-  return value;
-}
-function toUint64Bytes(n) {
-  const bytes = new Uint8Array(8);
-  new DataView(bytes.buffer).setBigUint64(0, BigInt(n));
-  return bytes;
-}
-function concatBytes(...parts) {
-  const total = parts.reduce((sum, p) => sum + p.length, 0);
-  const out = new Uint8Array(total);
-  let offset = 0;
-  for (const p of parts) {
-    out.set(p, offset);
-    offset += p.length;
-  }
-  return out;
-}
-function hexToBytes(hex) {
-  const h = hex.startsWith("0x") ? hex.slice(2) : hex;
-  const bytes = new Uint8Array(h.length / 2);
-  for (let i = 0; i < bytes.length; i++) {
-    bytes[i] = parseInt(h.slice(i * 2, i * 2 + 2), 16);
-  }
-  return bytes;
-}
-function createHyperliquidL1ActionHash(args) {
-  const { action, nonce, vaultAddress, expiresAfter } = args;
-  const actionBytes = msgpack.encode(adjustMsgpackValue(action));
-  const nonceBytes = toUint64Bytes(nonce);
-  const vaultMarker = vaultAddress ? new Uint8Array([1]) : new Uint8Array([0]);
-  const vaultBytes = vaultAddress ? hexToBytes(vaultAddress) : new Uint8Array();
-  const expiresMarker = expiresAfter !== void 0 ? new Uint8Array([0]) : new Uint8Array();
-  const expiresBytes = expiresAfter !== void 0 ? toUint64Bytes(expiresAfter) : new Uint8Array();
-  const bytes = concatBytes(actionBytes, nonceBytes, vaultMarker, vaultBytes, expiresMarker, expiresBytes);
-  return viem.keccak256(bytes);
-}
-function buildHyperliquidAgentTypedData(args) {
-  const connectionId = createHyperliquidL1ActionHash(args);
-  const source = args.isTestnet ? "b" : "a";
-  return {
-    domain: EXCHANGE_DOMAIN,
-    types: AGENT_TYPES,
-    primaryType: "Agent",
-    message: {
-      source,
-      connectionId
-    },
-    connectionId,
-    nonce: args.nonce,
-    action: args.action
-  };
-}
-function buildHyperliquidUpdateLeverageAction(args) {
-  const leverage = Math.trunc(args.leverage);
-  if (!Number.isFinite(leverage) || leverage < 1) {
-    throw new Error("leverage must be a positive integer");
-  }
-  return {
-    type: "updateLeverage",
-    asset: args.asset,
-    isCross: args.isCross !== false,
-    leverage
-  };
-}
-var EIP712_SIGN_REQUEST_KIND = "eip712";
-function msgHashNo0x(digest) {
-  return digest.startsWith("0x") ? digest.slice(2) : digest;
-}
-function eip712SignatureText(domain, primaryType) {
-  return JSON.stringify({
-    kind: "EIP-712",
-    ...typeof domain.name === "string" ? { name: domain.name } : {},
-    primaryType
-  });
-}
-function jsonStringifyForAudit(value) {
-  return JSON.stringify(value, (_, v) => typeof v === "bigint" ? v.toString() : v);
-}
-function eip712MsgRawHex(typedData, delivery) {
-  const envelope = {
-    version: 1,
-    ...typedData,
-    delivery
-  };
-  return viem.stringToHex(jsonStringifyForAudit(envelope));
-}
-function buildEip712MultisignBody(args) {
-  const { typedData, delivery } = args;
-  const digest = viem.hashTypedData({
-    domain: typedData.domain,
-    types: typedData.types,
-    primaryType: typedData.primaryType,
-    message: typedData.message
-  });
-  const extraJSON = {
-    signRequestKind: EIP712_SIGN_REQUEST_KIND,
-    eip712: {
-      version: 1,
-      digest,
-      domain: typedData.domain,
-      types: typedData.types,
-      primaryType: typedData.primaryType,
-      message: typedData.message
-    },
-    delivery
-  };
-  return finalizeMultisign({
-    keyGen: args.keyGen,
-    purposeText: args.purposeText,
-    purposeSuffix: args.purposeSuffix,
-    destinationChainID: args.destinationChainID,
-    destinationAddress: args.destinationAddress,
-    extraJSON,
-    expiryDate: args.expiryDate,
-    legs: [
-      {
-        msgHash: msgHashNo0x(digest),
-        msgRaw: eip712MsgRawHex(typedData, delivery),
-        destinationAddress: args.destinationAddress,
-        signatureText: eip712SignatureText(typedData.domain, typedData.primaryType),
-        audit: {
-          kind: "EIP712",
-          primaryType: typedData.primaryType,
-          deliveryKind: delivery.kind,
-          ...args.audit ?? {}
-        },
-        feeSnapshot: {}
-      }
-    ]
-  });
-}
-
-// src/protocols/evm/hyperliquid/exchangeMultisign.ts
-var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-async function buildHyperliquidUpdateLeverageMultisign(args) {
-  const marketKind = args.marketKind ?? "perp";
-  const { asset } = await hyperliquidResolveAsset({
-    chainId: args.chainId,
-    coin: args.coin,
-    marketKind,
-    dex: args.dex
-  });
-  const action = buildHyperliquidUpdateLeverageAction({
-    asset,
-    leverage: args.leverage,
-    isCross: args.isCross
-  });
-  const nonce = args.nonce ?? Date.now();
-  const isTestnet = args.chainId === 998;
-  const typed = buildHyperliquidAgentTypedData({ action, nonce, isTestnet });
-  return buildEip712MultisignBody({
-    keyGen: args.keyGen,
-    purposeText: args.purposeText,
-    destinationChainID: String(args.chainId),
-    destinationAddress: ZERO_ADDRESS,
-    typedData: {
-      domain: typed.domain,
-      types: typed.types,
-      primaryType: typed.primaryType,
-      message: typed.message
-    },
-    delivery: {
-      kind: "hyperliquid_exchange",
-      chainId: args.chainId,
-      isTestnet,
-      action,
-      nonce
-    },
-    audit: {
-      protocol: "hyperliquid",
-      action: "updateLeverage",
-      coin: args.coin,
-      marketKind,
-      asset,
-      leverage: action.leverage,
-      isCross: action.isCross,
-      nonce,
-      connectionId: typed.connectionId
-    }
-  });
-}
 var HYPERLIQUID_BRIDGE_MIN_DEPOSIT_USDC = 5;
 var HYPERLIQUID_BRIDGE_ARBITRUM_MAINNET_CHAIN_ID = 42161;
 var HYPERLIQUID_BRIDGE_ARBITRUM_TESTNET_CHAIN_ID = 421614;
@@ -1736,6 +1952,44 @@ async function buildHyperliquidBridgeWithdrawMultisign(args) {
   });
 }
 
+// src/protocols/evm/hyperliquid/pendingClose.ts
+function parsePositiveSize(value) {
+  if (value == null || !String(value).trim()) return null;
+  const n = Number.parseFloat(String(value).trim());
+  if (!Number.isFinite(n) || n <= 0) return null;
+  return n;
+}
+function hyperliquidOrderClosesPosition(position, orderSide) {
+  const side = String(orderSide).trim().toUpperCase();
+  return position.isLong ? side === "A" : side === "B";
+}
+function hyperliquidOrderCountsAsPendingClose(order) {
+  return Boolean(order.reduceOnly) || Boolean(order.isTrigger);
+}
+function hyperliquidPendingCloseForPosition(args) {
+  const positionSize = parsePositiveSize(args.position.size);
+  if (positionSize == null) {
+    return { pendingCloseSz: 0, pendingClosePct: 0 };
+  }
+  let pendingCloseSz = 0;
+  for (const order of args.orders) {
+    if (order.coin !== args.position.coin) continue;
+    if (!hyperliquidOrderClosesPosition(args.position, order.side)) continue;
+    if (!hyperliquidOrderCountsAsPendingClose(order)) continue;
+    const sz = parsePositiveSize(order.sz);
+    if (sz != null) pendingCloseSz += sz;
+  }
+  const pendingClosePct = Math.min(100, pendingCloseSz / positionSize * 100);
+  return { pendingCloseSz, pendingClosePct };
+}
+function hyperliquidPendingCloseByCoin(args) {
+  const out = /* @__PURE__ */ new Map();
+  for (const position of args.positions) {
+    out.set(position.key, hyperliquidPendingCloseForPosition({ position, orders: args.orders }));
+  }
+  return out;
+}
+
 // src/protocols/evm/hyperliquid/index.ts
 var HYPERLIQUID_PROTOCOL_ID = "hyperliquid";
 var hyperliquidProtocolModule = {
@@ -1755,7 +2009,7 @@ var hyperliquidProtocolModule = {
       id: "hyperliquid.limitOrder",
       protocolId: HYPERLIQUID_PROTOCOL_ID,
       chainCategory: "evm",
-      description: "Place a Hyperliquid limit/IoC order via HyperEVM CoreWriter",
+      description: "Place a Hyperliquid limit/IoC order via CoreWriter, or L1 normalTpsl bracket when TP/SL triggers are set",
       commonParams: ["keyGen", "purposeText", "useCustomGas"],
       params: {
         coin: { type: "string", required: true, description: "Market coin e.g. BTC" },
@@ -1764,7 +2018,10 @@ var hyperliquidProtocolModule = {
         szHuman: { type: "string", required: true, description: "Order size in coin units" },
         marketKind: { type: "string", required: false, description: "perp (default) or spot" },
         tif: { type: "string", required: false, description: "gtc, ioc, or alo" },
-        dex: { type: "string", required: false, description: "HIP-3 dex name when applicable" }
+        dex: { type: "string", required: false, description: "HIP-3 dex name when applicable" },
+        takeProfitTriggerPxHuman: { type: "string", required: false, description: "TP trigger \u2014 enables L1 bracket with SL" },
+        stopLossTriggerPxHuman: { type: "string", required: false, description: "SL trigger \u2014 enables L1 bracket with TP" },
+        tpslExecMode: { type: "string", required: false, description: "limit_at_trigger (default) or market" }
       }
     },
     {
@@ -1949,6 +2206,11 @@ exports.buildEvmMultisignBodyHyperliquidVaultDepositBatch = buildEvmMultisignBod
 exports.buildEvmMultisignBodyHyperliquidVaultWithdrawBatch = buildEvmMultisignBodyHyperliquidVaultWithdrawBatch;
 exports.buildHyperliquidAgentTypedData = buildHyperliquidAgentTypedData;
 exports.buildHyperliquidBridgeWithdrawMultisign = buildHyperliquidBridgeWithdrawMultisign;
+exports.buildHyperliquidLimitOrderWire = buildHyperliquidLimitOrderWire;
+exports.buildHyperliquidLimitOrderWithTpslMultisign = buildHyperliquidLimitOrderWithTpslMultisign;
+exports.buildHyperliquidNormalTpslOrderWires = buildHyperliquidNormalTpslOrderWires;
+exports.buildHyperliquidOrderAction = buildHyperliquidOrderAction;
+exports.buildHyperliquidTriggerOrderWire = buildHyperliquidTriggerOrderWire;
 exports.buildHyperliquidUpdateLeverageAction = buildHyperliquidUpdateLeverageAction;
 exports.buildHyperliquidUpdateLeverageMultisign = buildHyperliquidUpdateLeverageMultisign;
 exports.buildHyperliquidWithdraw3Action = buildHyperliquidWithdraw3Action;
@@ -1969,6 +2231,7 @@ exports.hyperliquidFetchClearinghouseState = hyperliquidFetchClearinghouseState;
 exports.hyperliquidFetchDelegations = hyperliquidFetchDelegations;
 exports.hyperliquidFetchDelegationsForExecutor = hyperliquidFetchDelegationsForExecutor;
 exports.hyperliquidFetchDexList = hyperliquidFetchDexList;
+exports.hyperliquidFetchFrontendOpenOrders = hyperliquidFetchFrontendOpenOrders;
 exports.hyperliquidFetchMarketSnapshot = hyperliquidFetchMarketSnapshot;
 exports.hyperliquidFetchMarketSnapshotSummary = hyperliquidFetchMarketSnapshotSummary;
 exports.hyperliquidFetchMarketsSummary = hyperliquidFetchMarketsSummary;
@@ -1994,9 +2257,15 @@ exports.hyperliquidFetchUserVaultEquities = hyperliquidFetchUserVaultEquities;
 exports.hyperliquidFetchUserVaultEquitiesSummary = hyperliquidFetchUserVaultEquitiesSummary;
 exports.hyperliquidFetchVaultCatalogSummary = hyperliquidFetchVaultCatalogSummary;
 exports.hyperliquidFetchVaultSummaries = hyperliquidFetchVaultSummaries;
+exports.hyperliquidFloatToWire = hyperliquidFloatToWire;
 exports.hyperliquidInferDexFromCoin = hyperliquidInferDexFromCoin;
 exports.hyperliquidIsSpotAssetId = hyperliquidIsSpotAssetId;
+exports.hyperliquidL1TifFromKey = hyperliquidL1TifFromKey;
 exports.hyperliquidMarketSymbol = hyperliquidMarketSymbol;
+exports.hyperliquidOrderClosesPosition = hyperliquidOrderClosesPosition;
+exports.hyperliquidOrderCountsAsPendingClose = hyperliquidOrderCountsAsPendingClose;
+exports.hyperliquidPendingCloseByCoin = hyperliquidPendingCloseByCoin;
+exports.hyperliquidPendingCloseForPosition = hyperliquidPendingCloseForPosition;
 exports.hyperliquidProtocolModule = hyperliquidProtocolModule;
 exports.hyperliquidResolveAsset = hyperliquidResolveAsset;
 exports.hyperliquidResolveOhlcvWindow = hyperliquidResolveOhlcvWindow;
@@ -2011,5 +2280,6 @@ exports.isHyperliquidBridgeArbitrumChainSupported = isHyperliquidBridgeArbitrumC
 exports.isHyperliquidBridgeArbitrumUsdcRow = isHyperliquidBridgeArbitrumUsdcRow;
 exports.isHyperliquidChainSupported = isHyperliquidChainSupported;
 exports.isHyperliquidHyperEvmUsdcRow = isHyperliquidHyperEvmUsdcRow;
+exports.validateHyperliquidTpslGeometry = validateHyperliquidTpslGeometry;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map