@continuumdao/ctm-mpc-defi 0.2.19 → 0.2.20

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

@@ -2,6 +2,7 @@
 
 var viem = require('viem');
 var continuumNodeSdk = require('@continuumdao/continuum-node-sdk');
+var msgpack = require('@msgpack/msgpack');
 
 // src/core/registry.ts
 var modules = [];
@@ -204,6 +205,7 @@ async function hyperliquidFetchOhlcvRange(args) {
     );
   }
   const latestCandle = candles.length > 0 ? candles[candles.length - 1] : null;
+  const effectiveLookbackDays = args.lookbackDays ?? (args.lookbackHours == null && args.startTimeMs == null ? HYPERLIQUID_DEFAULT_LOOKBACK_DAYS : void 0);
   return {
     coin,
     dex,
@@ -212,6 +214,8 @@ async function hyperliquidFetchOhlcvRange(args) {
     endTimeMs,
     expectedBars,
     candleCount: candles.length,
+    ...effectiveLookbackDays != null ? { lookbackDays: effectiveLookbackDays } : {},
+    ...args.lookbackHours != null ? { lookbackHours: args.lookbackHours } : {},
     latestCandle,
     candles,
     fetchedAtMs: Date.now()
@@ -955,7 +959,7 @@ function finalizeMultisign(input) {
     batchMeta,
     ...input.extraJSON ?? {}
   };
-  const extraJSON = JSON.stringify(extraPayload);
+  const extraJSON = JSON.stringify(extraPayload, (_, v) => typeof v === "bigint" ? v.toString() : v);
   const bodyForSign = {
     keyList,
     pubKey: ph,
@@ -1326,6 +1330,406 @@ 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,
+    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;
+var BRIDGE_MAINNET = {
+  bridge2: "0x2df1c51e09aecf9cacb7bc98cb1742757f163df7",
+  usdc: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+  label: "Arbitrum One"
+};
+var BRIDGE_TESTNET = {
+  bridge2: "0x08cfc1B6b2dCF36A1480b99353A354AA8AC56f89",
+  usdc: "0x1baAbB04529D43a73232B713C0FE471f7c7334d5",
+  label: "Arbitrum Sepolia"
+};
+var HYPERLIQUID_HYPEREVM_USDC_MAINNET = "0xb88339cb7199b77e23db6e890353e22632ba630f";
+var HYPERLIQUID_HYPEREVM_USDC_TESTNET = "0x2B3370eE501B4a559b57D449569354196457D8Ab";
+var HYPERLIQUID_USER_SIGNED_SIGNATURE_CHAIN_ID = "0x66eee";
+var HYPERLIQUID_BRIDGE_ERC20_TRANSFER_FALLBACK_GAS = 80000n;
+function hyperliquidBridgeArbitrumChainId(hyperEvmChainId) {
+  if (hyperEvmChainId === 999) return HYPERLIQUID_BRIDGE_ARBITRUM_MAINNET_CHAIN_ID;
+  if (hyperEvmChainId === 998) return HYPERLIQUID_BRIDGE_ARBITRUM_TESTNET_CHAIN_ID;
+  return null;
+}
+function hyperliquidBridgeConfig(arbitrumChainId) {
+  if (arbitrumChainId === HYPERLIQUID_BRIDGE_ARBITRUM_MAINNET_CHAIN_ID) {
+    return {
+      bridge2: viem.getAddress(BRIDGE_MAINNET.bridge2),
+      usdc: viem.getAddress(BRIDGE_MAINNET.usdc),
+      label: BRIDGE_MAINNET.label
+    };
+  }
+  if (arbitrumChainId === HYPERLIQUID_BRIDGE_ARBITRUM_TESTNET_CHAIN_ID) {
+    return {
+      bridge2: viem.getAddress(BRIDGE_TESTNET.bridge2),
+      usdc: viem.getAddress(BRIDGE_TESTNET.usdc),
+      label: BRIDGE_TESTNET.label
+    };
+  }
+  return null;
+}
+function isHyperliquidBridgeArbitrumChainSupported(chainId) {
+  return hyperliquidBridgeConfig(chainId) != null;
+}
+function isHyperliquidBridgeArbitrumUsdcRow(chainId, contractAddress) {
+  const cfg = hyperliquidBridgeConfig(chainId);
+  if (!cfg) return false;
+  try {
+    return viem.getAddress(contractAddress).toLowerCase() === cfg.usdc.toLowerCase();
+  } catch {
+    return false;
+  }
+}
+function isHyperliquidHyperEvmUsdcRow(hyperEvmChainId, contractAddress) {
+  const expected = hyperEvmChainId === 999 ? HYPERLIQUID_HYPEREVM_USDC_MAINNET : hyperEvmChainId === 998 ? HYPERLIQUID_HYPEREVM_USDC_TESTNET : null;
+  if (!expected) return false;
+  try {
+    return viem.getAddress(contractAddress).toLowerCase() === viem.getAddress(expected).toLowerCase();
+  } catch {
+    return false;
+  }
+}
+var HYPERLIQUID_USER_SIGNED_DOMAIN = {
+  name: "HyperliquidSignTransaction",
+  version: "1",
+  verifyingContract: "0x0000000000000000000000000000000000000000"
+};
+var HYPERLIQUID_WITHDRAW_SIGN_TYPES = {
+  "HyperliquidTransaction:Withdraw": [
+    { name: "hyperliquidChain", type: "string" },
+    { name: "destination", type: "string" },
+    { name: "amount", type: "string" },
+    { name: "time", type: "uint64" }
+  ]
+};
+function buildHyperliquidWithdraw3Action(args) {
+  const amount = args.amountHuman.trim();
+  if (!amount || !/^\d+(\.\d+)?$/.test(amount.replace(/,/g, ""))) {
+    throw new Error("amountHuman must be a positive decimal string");
+  }
+  if (Number(amount.replace(/,/g, "")) <= 0) {
+    throw new Error("amountHuman must be greater than zero");
+  }
+  const destination = viem.getAddress(args.destination);
+  const time = args.timeMs ?? Date.now();
+  const hyperliquidChain = args.isTestnet ? "Testnet" : "Mainnet";
+  const signatureChainId = "0x66eee";
+  const action = {
+    type: "withdraw3",
+    signatureChainId,
+    hyperliquidChain,
+    destination: destination.toLowerCase(),
+    amount,
+    time
+  };
+  return { action, nonce: time };
+}
+function buildHyperliquidWithdraw3TypedData(args) {
+  const chainId = Number.parseInt(args.action.signatureChainId, 16);
+  return {
+    domain: {
+      ...HYPERLIQUID_USER_SIGNED_DOMAIN,
+      chainId
+    },
+    types: HYPERLIQUID_WITHDRAW_SIGN_TYPES,
+    primaryType: "HyperliquidTransaction:Withdraw",
+    message: {
+      hyperliquidChain: args.action.hyperliquidChain,
+      destination: args.action.destination,
+      amount: args.action.amount,
+      time: args.action.time
+    }
+  };
+}
+var erc20TransferAbi = viem.parseAbi(["function transfer(address to, uint256 amount) returns (bool)"]);
+var ZERO_ADDRESS2 = "0x0000000000000000000000000000000000000000";
+function parseUsdHumanTo6(usdHuman) {
+  const trimmed = usdHuman.trim().replace(/,/g, "");
+  if (!trimmed || !/^\d+(\.\d+)?$/.test(trimmed)) {
+    throw new Error("usdHuman must be a positive decimal string");
+  }
+  return viem.parseUnits(trimmed, 6);
+}
+async function buildEvmMultisignBodyHyperliquidBridgeDepositBatch(args) {
+  const cfg = hyperliquidBridgeConfig(args.chainId);
+  if (!cfg) throw new Error("chainId must be Arbitrum One (42161) or Arbitrum Sepolia (421614)");
+  const amountWei = parseUsdHumanTo6(args.usdHuman);
+  const minWei = viem.parseUnits(String(HYPERLIQUID_BRIDGE_MIN_DEPOSIT_USDC), 6);
+  if (amountWei < minWei) {
+    throw new Error(`Bridge deposit must be at least ${HYPERLIQUID_BRIDGE_MIN_DEPOSIT_USDC} USDC`);
+  }
+  const executor = viem.getAddress(args.executorAddress);
+  const data = viem.encodeFunctionData({
+    abi: erc20TransferAbi,
+    functionName: "transfer",
+    args: [cfg.bridge2, amountWei]
+  });
+  return buildEvmMultisignBatch({
+    context: {
+      keyGen: args.keyGen,
+      chainCategory: "evm",
+      chainId: args.chainId,
+      rpcUrl: args.rpcUrl,
+      chainDetail: args.chainDetail,
+      useCustomGas: args.useCustomGas,
+      customGasChainDetails: args.customGasChainDetails ?? null,
+      executorAddress: executor,
+      purposeText: args.purposeText
+    },
+    steps: [{ to: cfg.usdc, data, value: 0n, fallbackGas: HYPERLIQUID_BRIDGE_ERC20_TRANSFER_FALLBACK_GAS }],
+    destinationAddress: cfg.usdc,
+    buildBatchMeta: () => ({
+      kind: "Hyperliquid",
+      action: "bridgeDeposit",
+      arbitrumChainId: args.chainId,
+      usdc: cfg.usdc,
+      bridge2: cfg.bridge2,
+      usdHuman: args.usdHuman,
+      evm: { type: "hyperliquid_bridge_deposit", version: 1, chainId: String(args.chainId) }
+    })
+  });
+}
+async function buildHyperliquidBridgeWithdrawMultisign(args) {
+  if (!isHyperliquidChainSupported(args.chainId)) {
+    throw new Error("chainId must be 999 or 998");
+  }
+  const isTestnet = args.chainId === 998;
+  const destination = viem.getAddress(args.destination ?? args.executorAddress);
+  const { action, nonce } = buildHyperliquidWithdraw3Action({
+    destination,
+    amountHuman: args.usdHuman,
+    isTestnet
+  });
+  const typed = buildHyperliquidWithdraw3TypedData({ action });
+  return buildEip712MultisignBody({
+    keyGen: args.keyGen,
+    purposeText: args.purposeText,
+    destinationChainID: String(args.chainId),
+    destinationAddress: ZERO_ADDRESS2,
+    typedData: typed,
+    delivery: {
+      kind: "hyperliquid_exchange",
+      chainId: args.chainId,
+      isTestnet,
+      action,
+      nonce
+    },
+    audit: {
+      protocol: "hyperliquid",
+      action: "bridgeWithdraw",
+      usdHuman: args.usdHuman,
+      destination,
+      nonce,
+      hyperliquidChain: action.hyperliquidChain
+    }
+  });
+}
 
 // src/protocols/evm/hyperliquid/index.ts
 var HYPERLIQUID_PROTOCOL_ID = "hyperliquid";
@@ -1446,6 +1850,40 @@ var hyperliquidProtocolModule = {
         validator: { type: "string", required: true, description: "Validator address" }
       }
     },
+    {
+      id: "hyperliquid.bridgeDeposit",
+      protocolId: HYPERLIQUID_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Deposit USDC from Arbitrum to Hyperliquid via Bridge2 (ERC20 transfer)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        usdHuman: { type: "string", required: true, description: "USDC amount (min 5)" }
+      }
+    },
+    {
+      id: "hyperliquid.bridgeWithdraw",
+      protocolId: HYPERLIQUID_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Withdraw USDC from Hyperliquid to Arbitrum via withdraw3 (EIP-712 /exchange)",
+      commonParams: ["keyGen", "purposeText"],
+      params: {
+        usdHuman: { type: "string", required: true, description: "USDC amount" },
+        destination: { type: "string", required: false, description: "Arbitrum recipient (defaults to executor)" }
+      }
+    },
+    {
+      id: "hyperliquid.updateLeverage",
+      protocolId: HYPERLIQUID_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Update per-market cross/isolated leverage via Hyperliquid L1 /exchange (EIP-712)",
+      commonParams: ["keyGen", "purposeText"],
+      params: {
+        coin: { type: "string", required: true, description: "Market coin e.g. BTC" },
+        leverage: { type: "number", required: true, description: "New leverage (1..market max)" },
+        isCross: { type: "boolean", required: false, description: "true for cross (default), false for isolated" },
+        marketKind: { type: "string", required: false, description: "perp (default) or spot" }
+      }
+    },
     {
       id: "hyperliquid.undelegate",
       protocolId: HYPERLIQUID_PROTOCOL_ID,
@@ -1461,12 +1899,18 @@ var hyperliquidProtocolModule = {
 };
 registerProtocolModule(hyperliquidProtocolModule);
 
+exports.HYPERLIQUID_BRIDGE_ARBITRUM_MAINNET_CHAIN_ID = HYPERLIQUID_BRIDGE_ARBITRUM_MAINNET_CHAIN_ID;
+exports.HYPERLIQUID_BRIDGE_ARBITRUM_TESTNET_CHAIN_ID = HYPERLIQUID_BRIDGE_ARBITRUM_TESTNET_CHAIN_ID;
+exports.HYPERLIQUID_BRIDGE_ERC20_TRANSFER_FALLBACK_GAS = HYPERLIQUID_BRIDGE_ERC20_TRANSFER_FALLBACK_GAS;
+exports.HYPERLIQUID_BRIDGE_MIN_DEPOSIT_USDC = HYPERLIQUID_BRIDGE_MIN_DEPOSIT_USDC;
 exports.HYPERLIQUID_CORE_WRITER_ADDRESS = HYPERLIQUID_CORE_WRITER_ADDRESS;
 exports.HYPERLIQUID_CORE_WRITER_GAS_FALLBACK = HYPERLIQUID_CORE_WRITER_GAS_FALLBACK;
 exports.HYPERLIQUID_DEFAULT_CANDLE_LIMIT = HYPERLIQUID_DEFAULT_CANDLE_LIMIT;
 exports.HYPERLIQUID_DEFAULT_LOOKBACK_DAYS = HYPERLIQUID_DEFAULT_LOOKBACK_DAYS;
 exports.HYPERLIQUID_DEFAULT_OHLCV_INTERVAL = HYPERLIQUID_DEFAULT_OHLCV_INTERVAL;
 exports.HYPERLIQUID_HLP_VAULT_ADDRESS = HYPERLIQUID_HLP_VAULT_ADDRESS;
+exports.HYPERLIQUID_HYPEREVM_USDC_MAINNET = HYPERLIQUID_HYPEREVM_USDC_MAINNET;
+exports.HYPERLIQUID_HYPEREVM_USDC_TESTNET = HYPERLIQUID_HYPEREVM_USDC_TESTNET;
 exports.HYPERLIQUID_INTERVAL_MS = HYPERLIQUID_INTERVAL_MS;
 exports.HYPERLIQUID_MAX_CANDLE_LIMIT = HYPERLIQUID_MAX_CANDLE_LIMIT;
 exports.HYPERLIQUID_MAX_LOOKBACK_DAYS = HYPERLIQUID_MAX_LOOKBACK_DAYS;
@@ -1475,6 +1919,9 @@ exports.HYPERLIQUID_PROTOCOL_ID = HYPERLIQUID_PROTOCOL_ID;
 exports.HYPERLIQUID_SPOT_ASSET_OFFSET = HYPERLIQUID_SPOT_ASSET_OFFSET;
 exports.HYPERLIQUID_SUPPORTED_CHAIN_IDS = HYPERLIQUID_SUPPORTED_CHAIN_IDS;
 exports.HYPERLIQUID_TIF = HYPERLIQUID_TIF;
+exports.HYPERLIQUID_USER_SIGNED_DOMAIN = HYPERLIQUID_USER_SIGNED_DOMAIN;
+exports.HYPERLIQUID_USER_SIGNED_SIGNATURE_CHAIN_ID = HYPERLIQUID_USER_SIGNED_SIGNATURE_CHAIN_ID;
+exports.HYPERLIQUID_WITHDRAW_SIGN_TYPES = HYPERLIQUID_WITHDRAW_SIGN_TYPES;
 exports.buildCoreWriterCancelByCloidCalldata = buildCoreWriterCancelByCloidCalldata;
 exports.buildCoreWriterCancelByOidCalldata = buildCoreWriterCancelByOidCalldata;
 exports.buildCoreWriterLimitOrderCalldata = buildCoreWriterLimitOrderCalldata;
@@ -1483,6 +1930,7 @@ exports.buildCoreWriterStakingWithdrawCalldata = buildCoreWriterStakingWithdrawC
 exports.buildCoreWriterTokenDelegateCalldata = buildCoreWriterTokenDelegateCalldata;
 exports.buildCoreWriterUsdClassTransferCalldata = buildCoreWriterUsdClassTransferCalldata;
 exports.buildCoreWriterVaultTransferCalldata = buildCoreWriterVaultTransferCalldata;
+exports.buildEvmMultisignBodyHyperliquidBridgeDepositBatch = buildEvmMultisignBodyHyperliquidBridgeDepositBatch;
 exports.buildEvmMultisignBodyHyperliquidCancelBatch = buildEvmMultisignBodyHyperliquidCancelBatch;
 exports.buildEvmMultisignBodyHyperliquidCloseBatch = buildEvmMultisignBodyHyperliquidCloseBatch;
 exports.buildEvmMultisignBodyHyperliquidDelegateBatch = buildEvmMultisignBodyHyperliquidDelegateBatch;
@@ -1494,8 +1942,17 @@ exports.buildEvmMultisignBodyHyperliquidUndelegateBatch = buildEvmMultisignBodyH
 exports.buildEvmMultisignBodyHyperliquidUsdClassTransferBatch = buildEvmMultisignBodyHyperliquidUsdClassTransferBatch;
 exports.buildEvmMultisignBodyHyperliquidVaultDepositBatch = buildEvmMultisignBodyHyperliquidVaultDepositBatch;
 exports.buildEvmMultisignBodyHyperliquidVaultWithdrawBatch = buildEvmMultisignBodyHyperliquidVaultWithdrawBatch;
+exports.buildHyperliquidAgentTypedData = buildHyperliquidAgentTypedData;
+exports.buildHyperliquidBridgeWithdrawMultisign = buildHyperliquidBridgeWithdrawMultisign;
+exports.buildHyperliquidUpdateLeverageAction = buildHyperliquidUpdateLeverageAction;
+exports.buildHyperliquidUpdateLeverageMultisign = buildHyperliquidUpdateLeverageMultisign;
+exports.buildHyperliquidWithdraw3Action = buildHyperliquidWithdraw3Action;
+exports.buildHyperliquidWithdraw3TypedData = buildHyperliquidWithdraw3TypedData;
 exports.coreWriterStep = coreWriterStep;
+exports.createHyperliquidL1ActionHash = createHyperliquidL1ActionHash;
 exports.hyperliquidApiBaseUrl = hyperliquidApiBaseUrl;
+exports.hyperliquidBridgeArbitrumChainId = hyperliquidBridgeArbitrumChainId;
+exports.hyperliquidBridgeConfig = hyperliquidBridgeConfig;
 exports.hyperliquidCollectAllPerpMarkets = hyperliquidCollectAllPerpMarkets;
 exports.hyperliquidEncodePx8 = hyperliquidEncodePx8;
 exports.hyperliquidEncodeUsd6 = hyperliquidEncodeUsd6;
@@ -1545,6 +2002,9 @@ exports.hyperliquidResolveTif = hyperliquidResolveTif;
 exports.hyperliquidSearchMarkets = hyperliquidSearchMarkets;
 exports.hyperliquidSearchMarketsSummary = hyperliquidSearchMarketsSummary;
 exports.hyperliquidVaultStatsUrl = hyperliquidVaultStatsUrl;
+exports.isHyperliquidBridgeArbitrumChainSupported = isHyperliquidBridgeArbitrumChainSupported;
+exports.isHyperliquidBridgeArbitrumUsdcRow = isHyperliquidBridgeArbitrumUsdcRow;
 exports.isHyperliquidChainSupported = isHyperliquidChainSupported;
+exports.isHyperliquidHyperEvmUsdcRow = isHyperliquidHyperEvmUsdcRow;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map