@continuumdao/ctm-mpc-defi 0.2.5 → 0.2.6

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

@@ -0,0 +1,2251 @@
+'use strict';
+
+var module$1 = require('module');
+var url = require('url');
+var viem = require('viem');
+var continuumNodeSdk = require('@continuumdao/continuum-node-sdk');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// src/core/registry.ts
+var modules = [];
+function registerProtocolModule(mod) {
+  const existing = modules.findIndex((m) => m.id === mod.id);
+  if (existing >= 0) {
+    modules[existing] = mod;
+  } else {
+    modules.push(mod);
+  }
+}
+
+// src/protocols/evm/gmx/support.ts
+var GMX_SUPPORTED_CHAIN_IDS = [42161, 43114];
+function isGmxChainSupported(chainId) {
+  return GMX_SUPPORTED_CHAIN_IDS.includes(chainId);
+}
+var require2 = module$1.createRequire(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+var { GmxApiSdk } = require2("@gmx-io/sdk/v2");
+var GMX_HTTP_TIMEOUT_MS = 3e4;
+var GMX_API_BASE_URLS = {
+  42161: ["https://arbitrum.gmxapi.io/v1", "https://arbitrum.gmxapi.ai/v1"],
+  43114: ["https://avalanche.gmxapi.io/v1", "https://avalanche.gmxapi.ai/v1"]
+};
+function buildGmxUrl(baseUrl, path, query) {
+  const base = baseUrl.replace(/\/$/, "");
+  if (!query) return `${base}${path}`;
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== void 0 && value !== null) params.set(key, String(value));
+  }
+  const qs = params.toString();
+  return qs ? `${base}${path}?${qs}` : `${base}${path}`;
+}
+function bigintReplacer(_key, value) {
+  return typeof value === "bigint" ? value.toString() : value;
+}
+async function gmxHttpFetchJson(baseUrl, path, opts) {
+  const url = buildGmxUrl(baseUrl, path, opts?.query);
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), GMX_HTTP_TIMEOUT_MS);
+  try {
+    const response = await fetch(url, {
+      headers: { Accept: "application/json" },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      let message = `HTTP ${response.status}: ${response.statusText}`;
+      try {
+        const body = await response.json();
+        if (body?.message) message = `HTTP ${response.status}: ${body.message}`;
+      } catch {
+      }
+      throw new Error(`${message} (${url})`);
+    }
+    const json = await response.json();
+    return opts?.transform ? opts.transform(json) : json;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function gmxHttpPostJson(baseUrl, path, body, opts) {
+  const url = buildGmxUrl(baseUrl, path);
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), GMX_HTTP_TIMEOUT_MS);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Accept: "application/json" },
+      body: JSON.stringify(body, bigintReplacer),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      let message = `HTTP ${response.status}: ${response.statusText}`;
+      try {
+        const errBody = await response.json();
+        if (errBody?.message) message = `HTTP ${response.status}: ${errBody.message}`;
+      } catch {
+      }
+      throw new Error(`${message} (${url})`);
+    }
+    const json = await response.json();
+    return opts?.transform ? opts.transform(json) : json;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+function createIoFirstGmxHttpApi(chainId) {
+  const urls = GMX_API_BASE_URLS[chainId];
+  if (!urls) {
+    throw new Error(`GMX API URLs are not configured for chain ${chainId}.`);
+  }
+  async function withIoFirstFallback(fn) {
+    let lastError;
+    for (const baseUrl of urls) {
+      try {
+        return await fn(baseUrl);
+      } catch (e) {
+        lastError = e;
+      }
+    }
+    const detail = lastError instanceof Error ? lastError.message : String(lastError);
+    throw new Error(
+      `GMX API request failed on all endpoints (${urls.join(", ")}). Last error: ${detail}`
+    );
+  }
+  return {
+    fetchJson: (path, opts) => withIoFirstFallback((baseUrl) => gmxHttpFetchJson(baseUrl, path, opts)),
+    postJson: (path, body, opts) => withIoFirstFallback((baseUrl) => gmxHttpPostJson(baseUrl, path, body, opts))
+  };
+}
+var sdkByChain = /* @__PURE__ */ new Map();
+function getGmxApiSdk(chainId) {
+  if (!isGmxChainSupported(chainId)) {
+    throw new Error(`GMX is not supported on chain ${chainId}. Supported: 42161 (Arbitrum), 43114 (Avalanche).`);
+  }
+  let sdk = sdkByChain.get(chainId);
+  if (!sdk) {
+    sdk = new GmxApiSdk({ chainId, api: createIoFirstGmxHttpApi(chainId) });
+    sdkByChain.set(chainId, sdk);
+  }
+  return sdk;
+}
+function parseGmxUsd30(amountHuman) {
+  const trimmed = amountHuman.trim();
+  if (!trimmed || !/^\d+(\.\d+)?$/.test(trimmed)) {
+    throw new Error("USD amount must be a positive decimal number.");
+  }
+  const [whole, frac = ""] = trimmed.split(".");
+  const fracPadded = (frac + "0".repeat(30)).slice(0, 30);
+  const wholeN = BigInt(whole);
+  const fracN = BigInt(fracPadded || "0");
+  const value = wholeN * 10n ** 30n + fracN;
+  if (value <= 0n) throw new Error("USD amount must be greater than zero.");
+  return value;
+}
+function parseGmxTokenAmount(amountHuman, decimals) {
+  return viem.parseUnits(amountHuman, decimals);
+}
+function gmxFormatApyPercent(apy) {
+  if (apy == null || !Number.isFinite(apy)) return null;
+  const pct = apy * 100;
+  if (pct <= 0) return null;
+  return `${pct.toLocaleString("en-US", { maximumFractionDigits: 2 })}%`;
+}
+function gmxLookupMarketApy(apyByMarket, marketTokenAddress) {
+  try {
+    const checksum = viem.getAddress(marketTokenAddress);
+    return apyByMarket[checksum] ?? apyByMarket[checksum.toLowerCase()] ?? null;
+  } catch {
+    const lower = marketTokenAddress.trim().toLowerCase();
+    return apyByMarket[lower] ?? null;
+  }
+}
+function gmxEnrichGmMarketRowWithApy(row, apyByMarket) {
+  const entry = gmxLookupMarketApy(apyByMarket, row.marketTokenAddress);
+  const apy = entry?.apy ?? null;
+  return {
+    ...row,
+    apy,
+    baseApy: entry?.baseApy ?? null,
+    bonusApr: entry?.bonusApr ?? null,
+    apyPercentLabel: gmxFormatApyPercent(apy)
+  };
+}
+async function gmxFetchMarkets(chainId) {
+  const sdk = getGmxApiSdk(chainId);
+  const markets = await sdk.fetchMarkets();
+  return markets.filter((m) => !m.isSpotOnly && m.isListed !== false).sort((a, b) => a.symbol.localeCompare(b.symbol, void 0, { sensitivity: "base" }));
+}
+async function gmxFetchTokens(chainId) {
+  const sdk = getGmxApiSdk(chainId);
+  return sdk.fetchTokens();
+}
+async function gmxResolveTokenBySymbol(chainId, symbol) {
+  const sym = symbol.trim().toUpperCase();
+  const tokens = await gmxFetchTokens(chainId);
+  const row = tokens.find((t) => t.symbol?.toUpperCase() === sym);
+  if (!row) throw new Error(`GMX token symbol not found on chain ${chainId}: ${symbol}`);
+  return row;
+}
+async function gmxIsCollateralTokenSupported(chainId, tokenAddress) {
+  try {
+    const addr = viem.getAddress(tokenAddress).toLowerCase();
+    const tokens = await gmxFetchTokens(chainId);
+    return tokens.some((t) => t.address?.toLowerCase() === addr);
+  } catch {
+    return false;
+  }
+}
+function gmxMarketCollateralTokens(marketSymbol) {
+  const m = marketSymbol.match(/\[([^[\]]+)\]/);
+  if (!m?.[1]) return [];
+  return m[1].split("-").map((s) => s.trim()).filter(Boolean);
+}
+function gmxMarketAcceptsCollateral(marketSymbol, collateralSymbol) {
+  const col = collateralSymbol.trim().toUpperCase();
+  if (!col) return true;
+  const tokens = gmxMarketCollateralTokens(marketSymbol);
+  if (tokens.length === 0) return true;
+  return tokens.some((t) => t.toUpperCase() === col);
+}
+async function gmxMarketsForCollateralSymbol(chainId, collateralSymbol) {
+  const markets = await gmxFetchMarkets(chainId);
+  return markets.filter((m) => gmxMarketAcceptsCollateral(m.symbol, collateralSymbol));
+}
+async function gmxResolveMarketBySymbol(chainId, symbol) {
+  const sym = symbol.trim();
+  const markets = await gmxFetchMarkets(chainId);
+  const row = markets.find((m) => m.symbol === sym);
+  if (!row) throw new Error(`GMX market symbol not found on chain ${chainId}: ${symbol}`);
+  if (!row.longTokenAddress || !row.shortTokenAddress) {
+    throw new Error(`GMX market "${symbol}" is missing long/short token addresses.`);
+  }
+  return row;
+}
+async function gmxResolveMarketByGmTokenAddress(chainId, gmTokenAddress) {
+  const addr = viem.getAddress(gmTokenAddress).toLowerCase();
+  const markets = await gmxFetchMarkets(chainId);
+  return markets.find((m) => m.marketTokenAddress?.toLowerCase() === addr) ?? null;
+}
+async function gmxFetchGmMarketsSummary(chainId) {
+  const markets = await gmxFetchMarkets(chainId);
+  const tokens = await gmxFetchTokens(chainId);
+  const tokenByAddr = new Map(tokens.map((t) => [t.address.toLowerCase(), t.symbol]));
+  const sdk = getGmxApiSdk(chainId);
+  const emptyApyMarkets = {};
+  const apyRes = await sdk.fetchApy().catch(() => ({ markets: emptyApyMarkets }));
+  const apyByMarket = apyRes.markets ?? emptyApyMarkets;
+  return markets.map(
+    (m) => gmxEnrichGmMarketRowWithApy(
+      {
+        symbol: m.symbol,
+        marketTokenAddress: m.marketTokenAddress,
+        longTokenSymbol: tokenByAddr.get((m.longTokenAddress ?? "").toLowerCase()) ?? null,
+        shortTokenSymbol: tokenByAddr.get((m.shortTokenAddress ?? "").toLowerCase()) ?? null
+      },
+      apyByMarket
+    )
+  );
+}
+function formatGmxUsd30(value) {
+  if (value == null) return null;
+  let n;
+  try {
+    n = typeof value === "bigint" ? value : BigInt(String(value));
+  } catch {
+    return null;
+  }
+  if (n <= 0n) return null;
+  const negative = n < 0n;
+  const abs = negative ? -n : n;
+  const whole = abs / 10n ** 30n;
+  const frac = abs % 10n ** 30n;
+  const fracStr = frac.toString().padStart(30, "0").replace(/0+$/, "");
+  const num = fracStr ? `${whole}.${fracStr}` : whole.toString();
+  const parsed = Number(num);
+  if (!Number.isFinite(parsed)) return null;
+  const formatted = Math.abs(parsed).toLocaleString("en-US", {
+    minimumFractionDigits: 0,
+    maximumFractionDigits: parsed >= 100 ? 2 : 4
+  });
+  return negative ? `-$${formatted}` : `$${formatted}`;
+}
+function formatGmxUsd30HumanInput(value) {
+  if (value == null) return null;
+  let n;
+  try {
+    n = typeof value === "bigint" ? value : BigInt(String(value));
+  } catch {
+    return null;
+  }
+  if (n <= 0n) return null;
+  const negative = n < 0n;
+  const abs = negative ? -n : n;
+  const whole = abs / 10n ** 30n;
+  const frac = abs % 10n ** 30n;
+  const fracStr = frac.toString().padStart(30, "0").replace(/0+$/, "");
+  const raw = fracStr ? `${whole}.${fracStr}` : whole.toString();
+  return negative ? `-${raw}` : raw;
+}
+function formatGmxTokenAmountHuman(amountWei, decimals) {
+  const raw = viem.formatUnits(amountWei, decimals);
+  if (!raw.includes(".")) return raw;
+  return raw.replace(/\.?0+$/, "");
+}
+function formatGmxLeverageBps(value) {
+  if (value == null) return null;
+  let n;
+  try {
+    n = typeof value === "bigint" ? value : BigInt(String(value));
+  } catch {
+    return null;
+  }
+  if (n <= 0n) return null;
+  const x = Number(n) / 1e4;
+  if (!Number.isFinite(x) || x <= 0) return null;
+  return `${x.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}\xD7`;
+}
+var require3 = module$1.createRequire(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+var { hydrateMarketInfo, getMarketAddressByName } = require3("@gmx-io/sdk/utils/markets");
+var GMX_DEFAULT_MIN_COLLATERAL_USD = 10n * 10n ** 30n;
+var contextByChain = /* @__PURE__ */ new Map();
+function tokensArrayToMap(tokensArr) {
+  const tokensData = {};
+  for (const t of tokensArr) {
+    const address = String(t.address ?? "");
+    if (address) tokensData[address] = t;
+  }
+  return tokensData;
+}
+async function loadGmxMarketContext(chainId) {
+  let pending = contextByChain.get(chainId);
+  if (!pending) {
+    pending = (async () => {
+      const sdk = getGmxApiSdk(chainId);
+      const [marketsInfoArr, tokensArr] = await Promise.all([
+        sdk.fetchMarketsInfo(),
+        sdk.fetchTokensData()
+      ]);
+      const tokensData = tokensArrayToMap(tokensArr);
+      const marketsInfoData = {};
+      for (const raw of marketsInfoArr) {
+        const hydrated = hydrateMarketInfo({ chainId, rawMarketInfo: raw, tokensData });
+        if (hydrated?.marketTokenAddress) {
+          marketsInfoData[String(hydrated.marketTokenAddress)] = hydrated;
+        }
+      }
+      return {
+        marketsInfoData,
+        tokensData,
+        minCollateralUsd: GMX_DEFAULT_MIN_COLLATERAL_USD
+      };
+    })();
+    contextByChain.set(chainId, pending);
+  }
+  return pending;
+}
+async function resolveGmxMarketBySymbol(chainId, symbol) {
+  const ctx = await loadGmxMarketContext(chainId);
+  const trimmed = symbol.trim();
+  if (!trimmed) return void 0;
+  const address = getMarketAddressByName(ctx.marketsInfoData, trimmed);
+  if (!address) return void 0;
+  return ctx.marketsInfoData[address];
+}
+async function resolveGmxTokenBySymbol(chainId, symbol) {
+  const ctx = await loadGmxMarketContext(chainId);
+  const sym = symbol.trim().toUpperCase();
+  return Object.values(ctx.tokensData).find((t) => String(t.symbol ?? "").toUpperCase() === sym);
+}
+
+// src/protocols/evm/gmx/positionDisplay.ts
+var require4 = module$1.createRequire(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+var { getPositionInfo } = require4("@gmx-io/sdk/utils/positions");
+function asBigint(v) {
+  if (v == null) return void 0;
+  try {
+    return typeof v === "bigint" ? v : BigInt(String(v));
+  } catch {
+    return void 0;
+  }
+}
+function pickIndexName(raw, enriched) {
+  const name = String(enriched?.indexName ?? raw.indexName ?? "").trim();
+  if (name) return name;
+  const market = String(raw.marketAddress ?? "").trim();
+  return market ? `Market ${market.slice(0, 6)}\u2026` : "Position";
+}
+async function gmxFormatPositionsForDisplay(chainId, positions) {
+  if (positions.length === 0) return [];
+  const ctx = await loadGmxMarketContext(chainId);
+  return positions.map((raw, i) => {
+    const marketAddress = String(raw.marketAddress ?? "");
+    const marketInfo = marketAddress ? ctx.marketsInfoData[marketAddress] : void 0;
+    let enriched;
+    if (marketInfo) {
+      try {
+        enriched = getPositionInfo({
+          position: raw,
+          marketInfo,
+          minCollateralUsd: ctx.minCollateralUsd,
+          userReferralInfo: void 0,
+          showPnlInLeverage: false,
+          uiFeeFactor: 0n
+        });
+      } catch {
+        enriched = void 0;
+      }
+    }
+    const source = enriched ?? raw;
+    const collateralToken = source.collateralToken;
+    return {
+      key: String(raw.key ?? raw.contractKey ?? `${marketAddress}-${i}`),
+      indexName: pickIndexName(raw, enriched),
+      isLong: Boolean(source.isLong ?? raw.isLong),
+      sizeUsd: formatGmxUsd30(asBigint(source.sizeInUsd ?? raw.sizeInUsd)),
+      collateralUsd: formatGmxUsd30(asBigint(source.collateralUsd ?? raw.collateralUsd)),
+      collateralSymbol: collateralToken?.symbol ? String(collateralToken.symbol) : null,
+      entryPriceUsd: formatGmxUsd30(asBigint(source.entryPrice)),
+      markPriceUsd: formatGmxUsd30(asBigint(source.markPrice)),
+      liquidationPriceUsd: formatGmxUsd30(asBigint(source.liquidationPrice)),
+      leverageLabel: formatGmxLeverageBps(asBigint(source.leverage ?? source.leverageWithoutPnl)),
+      pnlUsd: formatGmxUsd30(asBigint(source.pnl))
+    };
+  });
+}
+var require5 = module$1.createRequire(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+var { getMaxAllowedLeverage } = require5("@gmx-io/sdk/utils/markets");
+function gmxMarketMaxLeverageBps(marketInfo) {
+  return getMaxAllowedLeverage({
+    minCollateralFactor: marketInfo.minCollateralFactor,
+    minCollateralFactorForLiquidation: marketInfo.minCollateralFactorForLiquidation,
+    positionFeeFactorForBalanceWasNotImproved: marketInfo.positionFeeFactorForBalanceWasNotImproved
+  });
+}
+function gmxMarketMaxLeverageLabel(marketInfo) {
+  const bps = gmxMarketMaxLeverageBps(marketInfo);
+  if (!Number.isFinite(bps) || bps <= 0) return null;
+  return formatGmxLeverageBps(BigInt(bps));
+}
+var require6 = module$1.createRequire(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+var { getContract } = require6("@gmx-io/sdk/configs/contracts");
+function gmxContractAddress(chainId, name) {
+  const raw = getContract(chainId, name);
+  if (!raw || raw === "0x0000000000000000000000000000000000000000") {
+    throw new Error(`GMX contract "${name}" is not configured for chain ${chainId}.`);
+  }
+  return raw;
+}
+
+// src/protocols/evm/gmx/reads.ts
+async function gmxFetchPositionsForExecutor(args) {
+  const sdk = getGmxApiSdk(args.chainId);
+  const positions = await sdk.fetchPositionsInfo({
+    address: args.executorAddress,
+    includeRelatedOrders: true
+  });
+  return {
+    positions
+  };
+}
+async function gmxFetchPositionDisplayRows(args) {
+  const { positions } = await gmxFetchPositionsForExecutor(args);
+  return gmxFormatPositionsForDisplay(args.chainId, positions);
+}
+async function gmxFetchOrdersForExecutor(args) {
+  const sdk = getGmxApiSdk(args.chainId);
+  return sdk.fetchOrders({ address: args.executorAddress });
+}
+async function gmxFetchMarketsSummary(args) {
+  const [markets, ctx] = await Promise.all([gmxFetchMarkets(args.chainId), loadGmxMarketContext(args.chainId)]);
+  return {
+    markets: markets.map((m) => {
+      const addr = String(m.marketTokenAddress ?? "");
+      const info = ctx.marketsInfoData[addr] ?? ctx.marketsInfoData[addr.toLowerCase()] ?? Object.values(ctx.marketsInfoData).find(
+        (row) => String(row.marketTokenAddress ?? "").toLowerCase() === addr.toLowerCase()
+      );
+      return {
+        symbol: m.symbol,
+        marketTokenAddress: m.marketTokenAddress,
+        maxLeverageLabel: info ? gmxMarketMaxLeverageLabel(info) : null
+      };
+    })
+  };
+}
+async function gmxFetchCollateralTokens(args) {
+  const tokens = await gmxFetchTokens(args.chainId);
+  return tokens.map((t) => ({
+    symbol: t.symbol,
+    address: t.address,
+    decimals: t.decimals
+  }));
+}
+async function gmxFetchGmMarkets(args) {
+  const markets = await gmxFetchGmMarketsSummary(args.chainId);
+  return { markets };
+}
+async function gmxFetchGmApy(args) {
+  const { markets } = await gmxFetchGmMarkets(args);
+  const sorted = [...markets].sort((a, b) => (b.apy ?? 0) - (a.apy ?? 0));
+  return { markets: sorted };
+}
+async function gmxFetchStakingPower(args) {
+  const sdk = getGmxApiSdk(args.chainId);
+  const power = await sdk.fetchStakingPower({ address: args.executorAddress });
+  return {
+    stakingPower: JSON.parse(JSON.stringify(power, (_, v) => typeof v === "bigint" ? v.toString() : v))
+  };
+}
+async function gmxFetchGmMarketForToken(args) {
+  const market = await gmxResolveMarketByGmTokenAddress(args.chainId, args.gmTokenAddress);
+  if (!market) return { market: null };
+  const tokens = await gmxFetchTokens(args.chainId);
+  const tokenByAddr = new Map(tokens.map((t) => [t.address.toLowerCase(), t]));
+  const long = tokenByAddr.get((market.longTokenAddress ?? "").toLowerCase());
+  const short = tokenByAddr.get((market.shortTokenAddress ?? "").toLowerCase());
+  return {
+    market: {
+      symbol: market.symbol,
+      marketTokenAddress: market.marketTokenAddress,
+      longTokenSymbol: long?.symbol ?? null,
+      shortTokenSymbol: short?.symbol ?? null,
+      gmDecimals: 18
+    }
+  };
+}
+function gmxGmxTokenAddress(chainId) {
+  return gmxContractAddress(chainId, "GMX");
+}
+async function gmxIsGmMarketTokenAddress(chainId, tokenAddress) {
+  try {
+    const market = await gmxResolveMarketByGmTokenAddress(chainId, tokenAddress);
+    return market != null;
+  } catch {
+    return false;
+  }
+}
+function gmxIsGmxStakeTokenAddress(chainId, tokenAddress) {
+  try {
+    return viem.getAddress(tokenAddress).toLowerCase() === gmxGmxTokenAddress(chainId).toLowerCase();
+  } catch {
+    return false;
+  }
+}
+
+// src/core/purpose.ts
+function mergePurposeText(purposeText, purposeSuffix) {
+  const t = purposeText.trim();
+  const suffix = (purposeSuffix ?? "").trim();
+  if (!suffix) return t;
+  return t ? `${t}
+
+${suffix}` : suffix;
+}
+
+// src/core/envelope.ts
+function finalizeMultisign(input) {
+  const { keyGen, destinationChainID, legs } = input;
+  if (legs.length === 0) {
+    throw new Error("finalizeMultisign requires at least one leg");
+  }
+  const ph = (keyGen.pubkeyhex ?? "").trim();
+  if (!ph) throw new Error("keyGen pubKey (pubkeyhex) is required");
+  const keyList = keyGen.keylist ?? [];
+  const clientId = continuumNodeSdk.getClientIdFromKeyGenResult(keyGen);
+  const first = legs[0];
+  const messageHashes = legs.map((l) => l.msgHash);
+  const messageRawBatch = legs.map((l) => l.msgRaw);
+  const batchMeta = legs.map((l) => ({
+    destinationAddress: l.destinationAddress,
+    signatureText: l.signatureText,
+    ...l.audit
+  }));
+  const proposalTxParams = legs.map((l) => l.proposalTxParams).filter((p) => p != null && typeof p === "object");
+  const extraPayload = {
+    batchMeta,
+    ...input.extraJSON ?? {}
+  };
+  const extraJSON = JSON.stringify(extraPayload);
+  const bodyForSign = {
+    keyList,
+    pubKey: ph,
+    msgHash: messageHashes[0],
+    msgRaw: first.msgRaw,
+    destinationChainID,
+    destinationAddress: input.destinationAddress ?? first.destinationAddress,
+    extraJSON,
+    signatureText: first.signatureText,
+    purpose: mergePurposeText(input.purposeText, input.purposeSuffix),
+    ...first.feeSnapshot
+  };
+  if (legs.length > 1) {
+    bodyForSign.messageHashes = messageHashes;
+    bodyForSign.messageRawBatch = messageRawBatch;
+  }
+  if (proposalTxParams.length > 0) {
+    bodyForSign.proposalTxParams = proposalTxParams;
+  }
+  const valueWei = first.valueWei;
+  if (valueWei != null && valueWei > 0n) {
+    bodyForSign.value = valueWei.toString();
+  }
+  if (clientId) bodyForSign.clientId = clientId;
+  return { bodyForSign, messageToSign: JSON.stringify(bodyForSign) };
+}
+function routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimit) {
+  if (chainGasLimit != null && Number.isFinite(chainGasLimit) && chainGasLimit > 0) {
+    return continuumNodeSdk.gasLimitFromEstimateAndChainConfig(estimatedGas, chainGasLimit);
+  }
+  return (estimatedGas * 12n + 9n) / 10n;
+}
+
+// src/chains/evm/buildBatch.ts
+async function buildEvmMultisignBatch(args) {
+  const { context, steps } = args;
+  const {
+    chainId,
+    rpcUrl,
+    executorAddress,
+    chainDetail,
+    useCustomGas,
+    customGasChainDetails,
+    keyGen,
+    purposeText
+  } = context;
+  if (steps.length === 0) throw new Error("buildEvmMultisignBatch requires at least one step");
+  const ch = viem.defineChain({
+    id: chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(rpcUrl) });
+  const feeParams = await continuumNodeSdk.fetchChainFeeParams(rpcUrl, chainId);
+  const legacy = Boolean(chainDetail?.legacy) || !feeParams.isEip1559;
+  const latestBaseFeeWei = !legacy ? (await publicClient.getBlock({ blockTag: "latest" })).baseFeePerGas ?? 0n : 0n;
+  const gasLimitConfig = useCustomGas && chainDetail?.gasLimit != null ? Number(chainDetail.gasLimit) : void 0;
+  const chainGasLimitRouter = chainDetail?.gasLimit != null && Number.isFinite(Number(chainDetail.gasLimit)) && Number(chainDetail.gasLimit) > 0 ? Number(chainDetail.gasLimit) : void 0;
+  const gasFeeMultiplier = useCustomGas && chainDetail?.gasMultiplier != null ? Number(chainDetail.gasMultiplier) : void 0;
+  const executor = viem.getAddress(executorAddress);
+  const baseNonce = await publicClient.getTransactionCount({ address: executor, blockTag: "pending" });
+  const legs = [];
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const currentNonce = baseNonce + i;
+    let estimatedGas;
+    if (args.estimateGasForStep) {
+      estimatedGas = await args.estimateGasForStep({ step, index: i, publicClient, executor });
+    } else {
+      try {
+        estimatedGas = await publicClient.estimateGas({
+          to: step.to,
+          data: step.data,
+          value: step.value,
+          account: executor
+        });
+      } catch {
+        estimatedGas = step.fallbackGas ?? 100000n;
+      }
+    }
+    let gasLimitI;
+    if (args.resolveGasLimit) {
+      gasLimitI = await args.resolveGasLimit({ step, index: i, estimatedGas, publicClient });
+    } else if (step.routerSwap) {
+      gasLimitI = routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimitRouter);
+    } else {
+      gasLimitI = useCustomGas ? continuumNodeSdk.gasLimitFromEstimateAndChainConfig(estimatedGas, gasLimitConfig) : estimatedGas;
+    }
+    let proposalTxParams;
+    let feeSnapshot;
+    let serialized;
+    if (legacy) {
+      let gasPriceWei = await publicClient.getGasPrice();
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        gasPriceWei = gasPriceWei * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      if (useCustomGas && chainDetail?.gasPrice != null && chainDetail.gasPrice > 0) {
+        const configured = viem.parseGwei(continuumNodeSdk.gweiToDecimalString(Number(chainDetail.gasPrice)));
+        if (configured > gasPriceWei) gasPriceWei = configured;
+      }
+      serialized = viem.serializeTransaction({
+        type: "legacy",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        gasPrice: gasPriceWei,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "legacy",
+        gasPrice: gasPriceWei.toString()
+      };
+      feeSnapshot = continuumNodeSdk.proposalTxParamsToFeeSnapshot(proposalTxParams);
+    } else {
+      const fetchedBase = feeParams.baseFeeGwei ?? 0;
+      const fetchedPriority = feeParams.priorityFeeGwei ?? 0;
+      const configuredBase = useCustomGas && chainDetail?.baseFee != null ? Number(chainDetail.baseFee) : 0;
+      const configuredPriority = useCustomGas && chainDetail?.priorityFee != null ? Number(chainDetail.priorityFee) : 0;
+      const effectiveBaseFeeGwei = Math.max(fetchedBase, configuredBase);
+      const effectivePriorityFeeGwei = Math.max(fetchedPriority, configuredPriority);
+      const baseFeeMultiplierPct = useCustomGas && chainDetail?.baseFeeMultiplier != null ? Math.max(100, Number(chainDetail.baseFeeMultiplier)) : 100;
+      const baseComponentGwei = effectiveBaseFeeGwei * baseFeeMultiplierPct / 100;
+      const maxFeePerGasGwei = baseComponentGwei + effectivePriorityFeeGwei;
+      let maxPriorityFeePerGas = effectivePriorityFeeGwei > 0 ? viem.parseGwei(continuumNodeSdk.gweiToDecimalString(effectivePriorityFeeGwei)) : viem.parseGwei("1");
+      let maxFeePerGas = viem.parseGwei(continuumNodeSdk.gweiToDecimalString(maxFeePerGasGwei));
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        maxPriorityFeePerGas = maxPriorityFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+        maxFeePerGas = maxFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      ({ maxFeePerGas, maxPriorityFeePerGas } = continuumNodeSdk.alignEip1559FeesWithLatestBase(
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        latestBaseFeeWei
+      ));
+      serialized = viem.serializeTransaction({
+        type: "eip1559",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "eip1559",
+        maxFeePerGas: maxFeePerGas.toString(),
+        maxPriorityFeePerGas: maxPriorityFeePerGas.toString()
+      };
+      feeSnapshot = i === 0 ? continuumNodeSdk.proposalTxParamsToFeeSnapshot(proposalTxParams) : {};
+    }
+    const h = viem.keccak256(serialized);
+    const msgHash = h.startsWith("0x") ? h.slice(2) : h;
+    const batchMetaExtra = args.buildBatchMeta({ step, index: i, gasLimit: gasLimitI });
+    legs.push({
+      msgHash,
+      msgRaw: i === 0 && args.firstMsgRawNo0x != null ? args.firstMsgRawNo0x : serialized,
+      destinationAddress: step.to,
+      signatureText: typeof batchMetaExtra.signatureText === "string" ? batchMetaExtra.signatureText : JSON.stringify(batchMetaExtra.signatureText ?? {}),
+      audit: batchMetaExtra,
+      feeSnapshot: i === 0 ? feeSnapshot : {},
+      proposalTxParams,
+      valueWei: i === 0 ? step.value : void 0
+    });
+    if (i === 0 && args.firstMsgRawNo0x != null) {
+      legs[0].msgRaw = args.firstMsgRawNo0x;
+    }
+  }
+  const extraJSON = {};
+  if (useCustomGas && customGasChainDetails && Object.keys(customGasChainDetails).length > 0) {
+    extraJSON.customGasChainDetails = customGasChainDetails;
+  }
+  const result = finalizeMultisign({
+    keyGen,
+    purposeText,
+    purposeSuffix: args.purposeSuffix,
+    destinationChainID: String(chainId),
+    destinationAddress: args.destinationAddress ?? steps[0].to,
+    legs,
+    extraJSON: Object.keys(extraJSON).length > 0 ? extraJSON : void 0
+  });
+  const pv = args.payableValueWei;
+  if (pv != null && pv > 0n) {
+    result.bodyForSign.value = pv.toString();
+  }
+  return result;
+}
+var GMX_WRAPPED_NATIVE_SYMBOL_BY_CHAIN = {
+  42161: "WETH",
+  43114: "WAVAX"
+};
+var GMX_NATIVE_GAS_SYMBOL_BY_CHAIN = {
+  42161: "ETH",
+  43114: "AVAX"
+};
+function gmxWrappedNativeSymbolForChain(chainId) {
+  if (!isGmxChainSupported(chainId)) return null;
+  return GMX_WRAPPED_NATIVE_SYMBOL_BY_CHAIN[chainId] ?? null;
+}
+function gmxNativeGasSymbolForChain(chainId) {
+  if (!isGmxChainSupported(chainId)) return null;
+  return GMX_NATIVE_GAS_SYMBOL_BY_CHAIN[chainId] ?? null;
+}
+function gmxFindWrappedNativeToken(tokens, chainId) {
+  const sym = gmxWrappedNativeSymbolForChain(chainId);
+  if (!sym) return null;
+  return tokens.find((t) => t.symbol?.toUpperCase() === sym.toUpperCase()) ?? null;
+}
+function gmxKeyForNodeAssetRow(args) {
+  const raw = (args.contractAddress ?? "").trim();
+  try {
+    const a = viem.getAddress(raw);
+    if (a.toLowerCase() === "0x0000000000000000000000000000000000000000" && args.nativeWrapped) {
+      return viem.getAddress(args.nativeWrapped.trim()).toLowerCase();
+    }
+    return a.toLowerCase();
+  } catch {
+    return null;
+  }
+}
+var require7 = module$1.createRequire(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+var { getIncreasePositionAmounts, getNextPositionValuesForIncreaseTrade } = require7("@gmx-io/sdk/utils/trade");
+var { getDecreasePositionAmounts, getNextPositionValuesForDecreaseTrade } = require7("@gmx-io/sdk/utils/trade");
+var { createFindSwapPath } = require7("@gmx-io/sdk/utils/swap");
+var { SwapPricingType } = require7("@gmx-io/sdk/utils/orders");
+var { convertToTokenAmount } = require7("@gmx-io/sdk/utils/tokens");
+var { getPositionInfo: getPositionInfo2 } = require7("@gmx-io/sdk/utils/positions");
+function asBigint2(v) {
+  if (v == null) return void 0;
+  try {
+    return typeof v === "bigint" ? v : BigInt(String(v));
+  } catch {
+    return void 0;
+  }
+}
+function findSwapPathForCollateral(args) {
+  return createFindSwapPath({
+    chainId: args.chainId,
+    fromTokenAddress: args.fromToken.address,
+    toTokenAddress: args.collateralToken.address,
+    marketsInfoData: args.marketsInfoData,
+    gasEstimationParams: { gasLimits: {}, gasPrice: 1n, tokensData: args.tokensData },
+    swapPricingType: SwapPricingType.Swap
+  });
+}
+async function loadIncreaseSimContext(args) {
+  const market = await resolveGmxMarketBySymbol(args.chainId, args.symbol);
+  if (!market) throw new Error(`GMX market not found: ${args.symbol}`);
+  const collateralToken = await resolveGmxTokenBySymbol(args.chainId, args.collateralToken);
+  if (!collateralToken) throw new Error(`GMX collateral token not found: ${args.collateralToken}`);
+  const ctx = await loadGmxMarketContext(args.chainId);
+  const fromToken = collateralToken;
+  const isLong = args.direction === "long";
+  const sizeUsd = parseGmxUsd30(args.sizeUsdHuman);
+  const indexToken = market.indexToken;
+  const indexPrices = indexToken.prices;
+  const indexPrice = asBigint2(indexPrices?.minPrice);
+  if (!indexPrice || indexPrice <= 0n) throw new Error("GMX index price unavailable for estimate.");
+  const indexTokenAmount = convertToTokenAmount(sizeUsd, Number(indexToken.decimals ?? 18), indexPrice);
+  const findSwapPath = findSwapPathForCollateral({
+    chainId: args.chainId,
+    fromToken,
+    collateralToken,
+    marketsInfoData: ctx.marketsInfoData,
+    tokensData: ctx.tokensData
+  });
+  let existingPosition;
+  if (args.executorAddress?.trim()) {
+    const sdk = getGmxApiSdk(args.chainId);
+    const positions = await sdk.fetchPositionsInfo({ address: args.executorAddress.trim() });
+    existingPosition = positions.find(
+      (p) => String(p.marketAddress ?? "").toLowerCase() === String(market.marketTokenAddress ?? "").toLowerCase() && Boolean(p.isLong) === isLong
+    );
+    if (existingPosition && ctx.marketsInfoData[String(market.marketTokenAddress)]) {
+      existingPosition = getPositionInfo2({
+        position: existingPosition,
+        marketInfo: market,
+        minCollateralUsd: ctx.minCollateralUsd,
+        userReferralInfo: void 0,
+        showPnlInLeverage: false,
+        uiFeeFactor: 0n
+      });
+    }
+  }
+  const maxLeverageBps = gmxMarketMaxLeverageBps(market);
+  return {
+    chainId: args.chainId,
+    market,
+    collateralToken,
+    fromToken,
+    isLong,
+    sizeUsd,
+    indexToken,
+    indexTokenAmount,
+    findSwapPath,
+    existingPosition,
+    ctx,
+    maxLeverageBps,
+    maxLeverageLabel: gmxMarketMaxLeverageLabel(market),
+    collateralDecimals: Number(collateralToken.decimals ?? 18)
+  };
+}
+function simulateIncreaseAtCollateralWei(sim, collateralAmount) {
+  const increaseAmounts = getIncreasePositionAmounts({
+    marketInfo: sim.market,
+    indexToken: sim.indexToken,
+    initialCollateralToken: sim.fromToken,
+    collateralToken: sim.collateralToken,
+    isLong: sim.isLong,
+    initialCollateralAmount: collateralAmount,
+    position: sim.existingPosition,
+    indexTokenAmount: sim.indexTokenAmount,
+    strategy: "independent",
+    findSwapPath: sim.findSwapPath,
+    uiFeeFactor: 0n,
+    marketsInfoData: sim.ctx.marketsInfoData,
+    chainId: sim.chainId,
+    externalSwapQuote: void 0,
+    externalSwapQuoteParams: void 0,
+    isSetAcceptablePriceImpactEnabled: false,
+    userReferralInfo: void 0
+  });
+  const next = getNextPositionValuesForIncreaseTrade({
+    existingPosition: sim.existingPosition,
+    marketInfo: sim.market,
+    collateralToken: sim.collateralToken,
+    positionPriceImpactDeltaUsd: increaseAmounts.positionPriceImpactDeltaUsd,
+    sizeDeltaUsd: increaseAmounts.sizeDeltaUsd,
+    sizeDeltaInTokens: increaseAmounts.sizeDeltaInTokens,
+    collateralDeltaUsd: increaseAmounts.collateralDeltaUsd,
+    collateralDeltaAmount: increaseAmounts.collateralDeltaAmount,
+    indexPrice: increaseAmounts.indexPrice,
+    isLong: sim.isLong,
+    showPnlInLeverage: false,
+    minCollateralUsd: sim.ctx.minCollateralUsd,
+    userReferralInfo: void 0
+  });
+  return {
+    nextLeverageBps: asBigint2(next.nextLeverage) ?? null,
+    nextEntryPrice: asBigint2(next.nextEntryPrice) ?? null,
+    nextLiqPrice: asBigint2(next.nextLiqPrice) ?? null
+  };
+}
+function findMinCollateralWeiForIncrease(sim) {
+  const maxBps = BigInt(sim.maxLeverageBps);
+  const collateralPrices = sim.collateralToken.prices;
+  const collateralPrice = asBigint2(collateralPrices?.minPrice);
+  if (!collateralPrice || collateralPrice <= 0n) return null;
+  let hi = convertToTokenAmount(sim.sizeUsd * 2n, sim.collateralDecimals, collateralPrice);
+  if (hi < 1n) hi = 1n;
+  const hiSim = simulateIncreaseAtCollateralWei(sim, hi);
+  if (hiSim.nextLeverageBps == null || hiSim.nextLeverageBps > maxBps) {
+    return null;
+  }
+  let lo = 0n;
+  while (lo < hi) {
+    const mid = (lo + hi) / 2n;
+    const probe = mid === 0n ? 1n : mid;
+    const { nextLeverageBps } = simulateIncreaseAtCollateralWei(sim, probe);
+    if (nextLeverageBps != null && nextLeverageBps <= maxBps) {
+      hi = probe;
+    } else {
+      lo = probe + 1n;
+    }
+  }
+  return lo > 0n ? lo : 1n;
+}
+async function gmxEstimateIncreasePreview(args) {
+  const sim = await loadIncreaseSimContext(args);
+  const collateralAmount = parseGmxTokenAmount(args.collateralAmountHuman, sim.collateralDecimals);
+  const { nextLeverageBps, nextEntryPrice, nextLiqPrice } = simulateIncreaseAtCollateralWei(sim, collateralAmount);
+  const entry = formatGmxUsd30(nextEntryPrice);
+  const liq = formatGmxUsd30(nextLiqPrice);
+  const lev = formatGmxLeverageBps(nextLeverageBps);
+  const maxBps = BigInt(sim.maxLeverageBps);
+  const minWei = findMinCollateralWeiForIncrease(sim);
+  const minCollateralAmountHuman = minWei != null ? formatGmxTokenAmountHuman(minWei, sim.collateralDecimals) : null;
+  const exceedsMaxLeverage = nextLeverageBps != null && nextLeverageBps > maxBps || minWei != null && collateralAmount < minWei;
+  return {
+    direction: args.direction,
+    marketSymbol: args.symbol.trim(),
+    sizeUsdHuman: args.sizeUsdHuman.trim(),
+    collateralSymbol: args.collateralToken.trim(),
+    collateralAmountHuman: args.collateralAmountHuman.trim(),
+    openPositionSizeUsdHuman: null,
+    openPositionSizeUsdLabel: null,
+    entryPriceUsd: entry,
+    liquidationPriceUsd: liq,
+    leverageLabel: lev,
+    maxLeverageLabel: sim.maxLeverageLabel,
+    minCollateralAmountHuman,
+    exceedsMaxLeverage,
+    note: sim.existingPosition ? "Estimated after adding to your open position." : "Estimated for a new position."
+  };
+}
+async function gmxFindRawClosePosition(args) {
+  const market = await resolveGmxMarketBySymbol(args.chainId, args.symbol);
+  if (!market) return void 0;
+  const isLong = args.direction === "long";
+  const sdk = getGmxApiSdk(args.chainId);
+  const rawPositions = await sdk.fetchPositionsInfo({ address: args.executorAddress.trim() });
+  return rawPositions.find(
+    (p) => String(p.marketAddress ?? "").toLowerCase() === String(market.marketTokenAddress ?? "").toLowerCase() && Boolean(p.isLong) === isLong
+  );
+}
+async function gmxFetchClosePositionCap(args) {
+  const raw = await gmxFindRawClosePosition(args);
+  if (!raw) {
+    return { openPositionSizeUsdHuman: null, openPositionSizeUsdLabel: null };
+  }
+  const sizeInUsd = raw.sizeInUsd;
+  return {
+    openPositionSizeUsdHuman: formatGmxUsd30HumanInput(sizeInUsd),
+    openPositionSizeUsdLabel: formatGmxUsd30(sizeInUsd)
+  };
+}
+async function gmxEstimateDecreasePreview(args) {
+  const market = await resolveGmxMarketBySymbol(args.chainId, args.symbol);
+  if (!market) throw new Error(`GMX market not found: ${args.symbol}`);
+  const collateralToken = await resolveGmxTokenBySymbol(args.chainId, args.collateralToken);
+  if (!collateralToken) throw new Error(`GMX collateral token not found: ${args.collateralToken}`);
+  const ctx = await loadGmxMarketContext(args.chainId);
+  const isLong = args.direction === "long";
+  const closeSizeUsd = parseGmxUsd30(args.sizeUsdHuman);
+  const raw = await gmxFindRawClosePosition({
+    chainId: args.chainId,
+    symbol: args.symbol,
+    direction: args.direction,
+    executorAddress: args.executorAddress
+  });
+  if (!raw) {
+    return {
+      direction: args.direction,
+      marketSymbol: args.symbol.trim(),
+      sizeUsdHuman: args.sizeUsdHuman.trim(),
+      collateralSymbol: args.collateralToken.trim(),
+      collateralAmountHuman: null,
+      openPositionSizeUsdHuman: null,
+      openPositionSizeUsdLabel: null,
+      entryPriceUsd: null,
+      liquidationPriceUsd: null,
+      leverageLabel: null,
+      maxLeverageLabel: gmxMarketMaxLeverageLabel(market),
+      minCollateralAmountHuman: null,
+      exceedsMaxLeverage: false,
+      note: "No matching open position found for this market and direction."
+    };
+  }
+  const sizeInUsd = raw.sizeInUsd;
+  const openPositionSizeUsdHuman = formatGmxUsd30HumanInput(sizeInUsd);
+  const openPositionSizeUsdLabel = formatGmxUsd30(sizeInUsd);
+  const position = getPositionInfo2({
+    position: raw,
+    marketInfo: market,
+    minCollateralUsd: ctx.minCollateralUsd,
+    userReferralInfo: void 0,
+    showPnlInLeverage: false,
+    uiFeeFactor: 0n
+  });
+  const decreaseAmounts = getDecreasePositionAmounts({
+    marketInfo: market,
+    collateralToken: position.collateralToken ?? collateralToken,
+    isLong,
+    position,
+    closeSizeUsd,
+    keepLeverage: false,
+    userReferralInfo: void 0,
+    minCollateralUsd: ctx.minCollateralUsd,
+    minPositionSizeUsd: 1n,
+    uiFeeFactor: 0n,
+    isSetAcceptablePriceImpactEnabled: false
+  });
+  const next = getNextPositionValuesForDecreaseTrade({
+    existingPosition: position,
+    marketInfo: market,
+    collateralToken: position.collateralToken ?? collateralToken,
+    sizeDeltaUsd: decreaseAmounts.sizeDeltaUsd,
+    sizeDeltaInTokens: decreaseAmounts.sizeDeltaInTokens,
+    realizedPnl: decreaseAmounts.realizedPnl,
+    estimatedPnl: decreaseAmounts.estimatedPnl,
+    collateralDeltaUsd: decreaseAmounts.collateralDeltaUsd,
+    collateralDeltaAmount: decreaseAmounts.collateralDeltaAmount,
+    payedRemainingCollateralUsd: decreaseAmounts.payedRemainingCollateralUsd,
+    payedRemainingCollateralAmount: decreaseAmounts.payedRemainingCollateralAmount,
+    proportionalPendingImpactDeltaUsd: decreaseAmounts.proportionalPendingImpactDeltaUsd,
+    showPnlInLeverage: false,
+    isLong,
+    minCollateralUsd: ctx.minCollateralUsd,
+    userReferralInfo: void 0
+  });
+  const nextSize = asBigint2(next.nextSizeUsd) ?? 0n;
+  const liq = nextSize > 0n ? formatGmxUsd30(asBigint2(next.nextLiqPrice)) : null;
+  const lev = nextSize > 0n ? formatGmxLeverageBps(asBigint2(next.nextLeverage)) : null;
+  const fullClose = nextSize <= 0n;
+  return {
+    direction: args.direction,
+    marketSymbol: args.symbol.trim(),
+    sizeUsdHuman: args.sizeUsdHuman.trim(),
+    collateralSymbol: args.collateralToken.trim(),
+    collateralAmountHuman: null,
+    openPositionSizeUsdHuman,
+    openPositionSizeUsdLabel,
+    entryPriceUsd: formatGmxUsd30(asBigint2(position.entryPrice)),
+    liquidationPriceUsd: liq,
+    leverageLabel: lev,
+    maxLeverageLabel: gmxMarketMaxLeverageLabel(market),
+    minCollateralAmountHuman: null,
+    exceedsMaxLeverage: false,
+    note: fullClose ? "Full close \u2014 no remaining position after this order." : "Estimated remaining position after this close."
+  };
+}
+async function gmxAssertIncreaseOrderWithinMaxLeverage(args) {
+  const estimate = await gmxEstimateIncreasePreview(args);
+  if (!estimate.exceedsMaxLeverage) return;
+  const maxLev = estimate.maxLeverageLabel ?? "market max";
+  const minCol = estimate.minCollateralAmountHuman;
+  const sym = estimate.collateralSymbol;
+  if (minCol) {
+    throw new Error(
+      `Collateral is too low for ${maxLev} max leverage on ${estimate.marketSymbol}. Need at least ${minCol} ${sym}.`
+    );
+  }
+  throw new Error(
+    `Collateral is too low for ${maxLev} max leverage on ${estimate.marketSymbol}. Increase collateral or reduce size.`
+  );
+}
+function gmxIsCloseSizeWithinPosition(args) {
+  try {
+    const close = parseGmxUsd30(args.closeSizeUsdHuman);
+    const open = parseGmxUsd30(args.openPositionSizeUsdHuman);
+    return close > 0n && close <= open;
+  } catch {
+    return false;
+  }
+}
+
+// src/protocols/evm/gmx/multisign.ts
+var GMX_ORDER_GAS_FALLBACK = 2500000n;
+var GMX_WETH_DEPOSIT_FALLBACK = 120000n;
+var GMX_ERC20_APPROVE_FALLBACK = 100000n;
+var wethDepositAbi = viem.parseAbi(["function deposit() payable"]);
+var erc20AllowanceAbi = viem.parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)"
+]);
+var erc20ApproveAbi = viem.parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
+function payloadToStep(payload) {
+  if (!payload?.to || !payload?.data) {
+    throw new Error("GMX prepareOrder did not return classic transaction calldata (to/data).");
+  }
+  const to = viem.getAddress(payload.to.trim());
+  const raw = payload.data.toString();
+  const data = raw.startsWith("0x") ? raw : `0x${raw}`;
+  let value = 0n;
+  if (payload.value != null) {
+    value = typeof payload.value === "bigint" ? payload.value : BigInt(String(payload.value));
+  }
+  return { to, data, value, fallbackGas: GMX_ORDER_GAS_FALLBACK };
+}
+async function buildNativeCollateralPrepSteps(args) {
+  const weth = viem.getAddress(args.nativeWrapped);
+  const executor = viem.getAddress(args.executorAddress);
+  const router = viem.getAddress(args.exchangeRouter);
+  const token = await gmxResolveTokenBySymbol(args.chainId, args.collateralToken);
+  const amountWei = parseGmxTokenAmount(args.collateralAmountHuman, token.decimals);
+  if (amountWei === 0n) throw new Error("Collateral amount is zero after converting with token decimals.");
+  const ch = viem.defineChain({
+    id: args.chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Native", symbol: "N" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const steps = [];
+  const dataDeposit = viem.encodeFunctionData({ abi: wethDepositAbi, functionName: "deposit", args: [] });
+  steps.push({ to: weth, data: dataDeposit, value: amountWei, fallbackGas: GMX_WETH_DEPOSIT_FALLBACK });
+  const allowance = await publicClient.readContract({
+    address: weth,
+    abi: erc20AllowanceAbi,
+    functionName: "allowance",
+    args: [executor, router]
+  });
+  if (allowance < amountWei) {
+    if (allowance > 0n) {
+      steps.push({
+        to: weth,
+        data: viem.encodeFunctionData({ abi: erc20ApproveAbi, functionName: "approve", args: [router, 0n] }),
+        value: 0n,
+        fallbackGas: GMX_ERC20_APPROVE_FALLBACK
+      });
+    }
+    steps.push({
+      to: weth,
+      data: viem.encodeFunctionData({ abi: erc20ApproveAbi, functionName: "approve", args: [router, amountWei] }),
+      value: 0n,
+      fallbackGas: GMX_ERC20_APPROVE_FALLBACK
+    });
+  }
+  return steps;
+}
+async function buildGmxClassicPreparedMultisignBatch(common, prepared, signatureMeta, prepSteps = []) {
+  const executor = viem.getAddress(common.executorAddress);
+  const orderStep = payloadToStep(prepared.payload);
+  const steps = [...prepSteps, orderStep];
+  const firstStep = steps[0];
+  const dataNo0x = firstStep.data.startsWith("0x") ? firstStep.data.slice(2) : firstStep.data;
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: common.keyGen,
+      purposeText: common.purposeText,
+      chainId: common.chainId,
+      rpcUrl: common.rpcUrl,
+      executorAddress: executor,
+      chainDetail: common.chainDetail,
+      useCustomGas: common.useCustomGas,
+      customGasChainDetails: common.customGasChainDetails
+    },
+    steps,
+    purposeSuffix: "GMX: classic on-chain order (keeper-executed asynchronously).",
+    firstMsgRawNo0x: dataNo0x,
+    destinationAddress: firstStep.to,
+    resolveGasLimit: async ({ estimatedGas, index }) => {
+      const step = steps[index];
+      const fallback = step?.fallbackGas ?? GMX_ORDER_GAS_FALLBACK;
+      return estimatedGas > fallback ? estimatedGas : fallback;
+    },
+    buildBatchMeta: ({ index }) => {
+      if (index < prepSteps.length) {
+        const kind = index === 0 && prepSteps[0]?.value > 0n ? "weth_deposit" : "approve";
+        return {
+          signatureText: JSON.stringify({ kind: "GMX", step: kind, ...signatureMeta }),
+          evm: { type: kind === "weth_deposit" ? "gmx_weth_deposit" : "gmx_erc20_approve", version: 1, chainId: String(common.chainId) }
+        };
+      }
+      return {
+        signatureText: JSON.stringify({
+          kind: "GMX",
+          mode: "classic",
+          ...signatureMeta
+        }),
+        evm: { type: "gmx_classic_order", version: 1, chainId: String(common.chainId) }
+      };
+    }
+  });
+}
+async function collateralToPay(collateralToken, collateralAmountHuman, chainId) {
+  const token = await gmxResolveTokenBySymbol(chainId, collateralToken);
+  const amount = parseGmxTokenAmount(collateralAmountHuman, token.decimals);
+  return { amount, token: token.symbol };
+}
+function resolveIncreaseCollateralToken(args) {
+  if (args.isNativeIn) {
+    const wrapped = gmxWrappedNativeSymbolForChain(args.chainId);
+    if (!wrapped) throw new Error("Wrapped native collateral symbol is not configured for this chain.");
+    return wrapped;
+  }
+  return args.collateralToken.trim();
+}
+async function buildEvmMultisignBodyGmxIncreaseBatch(args) {
+  const sdk = getGmxApiSdk(args.chainId);
+  const executor = viem.getAddress(args.executorAddress);
+  const size = parseGmxUsd30(args.sizeUsdHuman);
+  const collateralSymbol = resolveIncreaseCollateralToken(args);
+  await gmxAssertIncreaseOrderWithinMaxLeverage({
+    chainId: args.chainId,
+    symbol: args.symbol.trim(),
+    direction: args.direction,
+    sizeUsdHuman: args.sizeUsdHuman,
+    collateralToken: collateralSymbol,
+    collateralAmountHuman: args.collateralAmountHuman,
+    executorAddress: executor
+  });
+  const collateralToPayArg = await collateralToPay(collateralSymbol, args.collateralAmountHuman, args.chainId);
+  if (args.isNativeIn) {
+    if (!args.nativeWrapped) throw new Error("nativeWrapped is required when isNativeIn is true.");
+    const wrapped = gmxWrappedNativeSymbolForChain(args.chainId);
+    if (collateralSymbol.toUpperCase() !== wrapped?.toUpperCase()) {
+      throw new Error("Native GMX collateral path requires the chain wrapped native token.");
+    }
+  }
+  const prepareArgs = {
+    kind: "increase",
+    symbol: args.symbol.trim(),
+    direction: args.direction,
+    orderType: args.orderType,
+    size,
+    collateralToken: collateralSymbol,
+    collateralToPay: collateralToPayArg,
+    mode: "classic",
+    from: executor
+  };
+  if (args.orderType === "limit") {
+    if (!args.triggerPriceUsdHuman?.trim()) throw new Error("Limit orders require triggerPriceUsdHuman.");
+    prepareArgs.triggerPrice = parseGmxUsd30(args.triggerPriceUsdHuman);
+  }
+  if (args.slippageBps != null) prepareArgs.slippage = args.slippageBps;
+  if (args.executionFeeBufferBps != null) prepareArgs.executionFeeBufferBps = args.executionFeeBufferBps;
+  const prepared = await sdk.prepareOrder(prepareArgs);
+  if (prepared.payloadType !== "transaction") {
+    throw new Error("GMX prepareOrder returned typed-data; classic mode required for MPC multi-sign.");
+  }
+  const orderStep = payloadToStep(prepared.payload);
+  let prepSteps = [];
+  if (args.isNativeIn && args.nativeWrapped) {
+    prepSteps = await buildNativeCollateralPrepSteps({
+      chainId: args.chainId,
+      rpcUrl: args.rpcUrl,
+      executorAddress: executor,
+      nativeWrapped: args.nativeWrapped,
+      collateralToken: collateralSymbol,
+      collateralAmountHuman: args.collateralAmountHuman,
+      exchangeRouter: orderStep.to
+    });
+  }
+  return buildGmxClassicPreparedMultisignBatch(
+    args,
+    prepared,
+    {
+      action: "increase",
+      symbol: args.symbol,
+      direction: args.direction,
+      orderType: args.orderType,
+      sizeUsdHuman: args.sizeUsdHuman,
+      collateralToken: collateralSymbol,
+      collateralAmountHuman: args.collateralAmountHuman,
+      isNativeIn: Boolean(args.isNativeIn)
+    },
+    prepSteps
+  );
+}
+async function buildEvmMultisignBodyGmxDecreaseBatch(args) {
+  const sdk = getGmxApiSdk(args.chainId);
+  const executor = viem.getAddress(args.executorAddress);
+  const size = parseGmxUsd30(args.sizeUsdHuman);
+  const prepareArgs = {
+    kind: "decrease",
+    symbol: args.symbol.trim(),
+    direction: args.direction,
+    orderType: args.orderType,
+    size,
+    collateralToken: args.collateralToken.trim(),
+    mode: "classic",
+    from: executor
+  };
+  if (args.isNativeOut) {
+    const nativeSym = gmxNativeGasSymbolForChain(args.chainId);
+    if (!nativeSym) throw new Error("Native receive symbol is not configured for this chain.");
+    prepareArgs.receiveToken = nativeSym;
+  } else if (args.receiveToken?.trim()) {
+    prepareArgs.receiveToken = args.receiveToken.trim();
+  }
+  if (args.keepLeverage != null) prepareArgs.keepLeverage = args.keepLeverage;
+  if (args.orderType === "limit") {
+    if (!args.triggerPriceUsdHuman?.trim()) throw new Error("Limit orders require triggerPriceUsdHuman.");
+    prepareArgs.triggerPrice = parseGmxUsd30(args.triggerPriceUsdHuman);
+  }
+  if (args.slippageBps != null) prepareArgs.slippage = args.slippageBps;
+  if (args.executionFeeBufferBps != null) prepareArgs.executionFeeBufferBps = args.executionFeeBufferBps;
+  const prepared = await sdk.prepareOrder(prepareArgs);
+  if (prepared.payloadType !== "transaction") {
+    throw new Error("GMX prepareOrder returned typed-data; classic mode required for MPC multi-sign.");
+  }
+  return buildGmxClassicPreparedMultisignBatch(args, prepared, {
+    action: "decrease",
+    symbol: args.symbol,
+    direction: args.direction,
+    orderType: args.orderType,
+    sizeUsdHuman: args.sizeUsdHuman,
+    collateralToken: args.collateralToken,
+    isNativeOut: Boolean(args.isNativeOut)
+  });
+}
+var buildEvmMultisignBodyGmxLimitIncreaseBatch = buildEvmMultisignBodyGmxIncreaseBatch;
+var buildEvmMultisignBodyGmxLimitDecreaseBatch = buildEvmMultisignBodyGmxDecreaseBatch;
+async function buildEvmMultisignBodyGmxCancelBatch(args) {
+  const sdk = getGmxApiSdk(args.chainId);
+  const executor = viem.getAddress(args.executorAddress);
+  const orderId = args.orderId.trim();
+  if (!orderId) throw new Error("orderId is required to cancel a GMX order.");
+  const prepared = await sdk.prepareCancelOrder({
+    orderId,
+    mode: "classic",
+    from: executor
+  });
+  if (prepared.payloadType !== "transaction") {
+    throw new Error("GMX prepareCancelOrder returned typed-data; classic mode required for MPC multi-sign.");
+  }
+  return buildGmxClassicPreparedMultisignBatch(args, prepared, {
+    action: "cancel",
+    orderId
+  });
+}
+var require8 = module$1.createRequire(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+var {
+  depositGasLimitKey,
+  withdrawalGasLimitKey,
+  singleSwapGasLimitKey,
+  ESTIMATED_GAS_FEE_BASE_AMOUNT_V2_1,
+  ESTIMATED_GAS_FEE_MULTIPLIER_FACTOR,
+  ESTIMATED_GAS_FEE_PER_ORACLE_PRICE
+} = require8("@gmx-io/sdk/configs/dataStore");
+var { applyFactor } = require8("@gmx-io/sdk/utils/numbers");
+var {
+  estimateExecuteDepositGasLimit,
+  estimateExecuteWithdrawalGasLimit
+} = require8("@gmx-io/sdk/utils/fees");
+var dataStoreAbi = viem.parseAbi(["function getUint(bytes32 key) view returns (uint256)"]);
+var gasLimitsCache = /* @__PURE__ */ new Map();
+async function gmxLoadGasLimits(chainId, rpcUrl) {
+  const cached = gasLimitsCache.get(chainId);
+  if (cached) return cached;
+  const dataStore = gmxContractAddress(chainId, "DataStore");
+  const ch = viem.defineChain({
+    id: chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Native", symbol: "N" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(rpcUrl) });
+  const keys = [
+    ["depositToken", depositGasLimitKey()],
+    ["withdrawalMultiToken", withdrawalGasLimitKey()],
+    ["singleSwap", singleSwapGasLimitKey()],
+    ["estimatedGasFeeBaseAmount", ESTIMATED_GAS_FEE_BASE_AMOUNT_V2_1],
+    ["estimatedGasFeePerOraclePrice", ESTIMATED_GAS_FEE_PER_ORACLE_PRICE],
+    ["estimatedFeeMultiplierFactor", ESTIMATED_GAS_FEE_MULTIPLIER_FACTOR]
+  ];
+  const limits = {
+    depositToken: 0n,
+    withdrawalMultiToken: 0n,
+    singleSwap: 0n,
+    estimatedGasFeeBaseAmount: 0n,
+    estimatedGasFeePerOraclePrice: 0n,
+    estimatedFeeMultiplierFactor: 0n
+  };
+  await Promise.all(
+    keys.map(async ([field, key]) => {
+      const value = await publicClient.readContract({
+        address: dataStore,
+        abi: dataStoreAbi,
+        functionName: "getUint",
+        args: [key]
+      });
+      limits[field] = value;
+    })
+  );
+  gasLimitsCache.set(chainId, limits);
+  return limits;
+}
+function applyGmxExecutionFeeFormula(args) {
+  const { gasLimits, estimatedGasLimit, gasPrice, oraclePriceCount, bufferBps } = args;
+  let gasLimit = gasLimits.estimatedGasFeeBaseAmount;
+  gasLimit += gasLimits.estimatedGasFeePerOraclePrice * oraclePriceCount;
+  const multiplier = gasLimits.estimatedFeeMultiplierFactor;
+  gasLimit += applyFactor(estimatedGasLimit, multiplier);
+  const buffered = gasLimit + gasLimit * BigInt(bufferBps) / 10000n;
+  return buffered * gasPrice;
+}
+var DEFAULT_EXECUTION_FEE_BUFFER_BPS = 3e3;
+async function gmxEstimateGmExecutionFee(args) {
+  const bufferBps = args.executionFeeBufferBps ?? DEFAULT_EXECUTION_FEE_BUFFER_BPS;
+  const gasLimits = await gmxLoadGasLimits(args.chainId, args.rpcUrl);
+  const ch = viem.defineChain({
+    id: args.chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Native", symbol: "N" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const gasPrice = await publicClient.getGasPrice();
+  const oraclePriceCount = 3n;
+  const estimatedGasLimit = args.operation === "deposit" ? estimateExecuteDepositGasLimit(gasLimits, { swapsCount: 0, callbackGasLimit: 0n }) : estimateExecuteWithdrawalGasLimit(gasLimits, { swapsCount: 0n, callbackGasLimit: 0n });
+  return applyGmxExecutionFeeFormula({
+    gasLimits,
+    estimatedGasLimit,
+    gasPrice,
+    oraclePriceCount,
+    bufferBps
+  });
+}
+function gmxZeroAddress() {
+  return "0x0000000000000000000000000000000000000000";
+}
+
+// src/protocols/evm/gmx/gmLiquidityMultisign.ts
+var require9 = module$1.createRequire(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+var ExchangeRouterAbi = require9("@gmx-io/sdk/abis/ExchangeRouter").default;
+var GMX_GM_MULTICALL_FALLBACK = 2800000n;
+var GMX_WETH_DEPOSIT_FALLBACK2 = 120000n;
+var GMX_ERC20_APPROVE_FALLBACK2 = 100000n;
+var wethDepositAbi2 = viem.parseAbi(["function deposit() payable"]);
+var erc20AllowanceAbi2 = viem.parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)"
+]);
+var erc20ApproveAbi2 = viem.parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
+async function buildApproveStepsIfNeeded(args) {
+  const ch = viem.defineChain({
+    id: args.chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Native", symbol: "N" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const allowance = await publicClient.readContract({
+    address: args.token,
+    abi: erc20AllowanceAbi2,
+    functionName: "allowance",
+    args: [args.executorAddress, args.spender]
+  });
+  if (allowance >= args.amountWei) return [];
+  const steps = [];
+  if (allowance > 0n) {
+    steps.push({
+      to: args.token,
+      data: viem.encodeFunctionData({ abi: erc20ApproveAbi2, functionName: "approve", args: [args.spender, 0n] }),
+      value: 0n,
+      fallbackGas: GMX_ERC20_APPROVE_FALLBACK2
+    });
+  }
+  steps.push({
+    to: args.token,
+    data: viem.encodeFunctionData({ abi: erc20ApproveAbi2, functionName: "approve", args: [args.spender, args.amountWei] }),
+    value: 0n,
+    fallbackGas: GMX_ERC20_APPROVE_FALLBACK2
+  });
+  return steps;
+}
+async function buildNativeWrapPrepSteps(args) {
+  const weth = viem.getAddress(args.nativeWrapped);
+  const router = viem.getAddress(args.exchangeRouter);
+  const steps = [];
+  steps.push({
+    to: weth,
+    data: viem.encodeFunctionData({ abi: wethDepositAbi2, functionName: "deposit", args: [] }),
+    value: args.amountWei,
+    fallbackGas: GMX_WETH_DEPOSIT_FALLBACK2
+  });
+  const approveSteps = await buildApproveStepsIfNeeded({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    executorAddress: args.executorAddress,
+    token: weth,
+    spender: router,
+    amountWei: args.amountWei
+  });
+  steps.push(...approveSteps);
+  return steps;
+}
+function resolveGmCollateralAddress(args) {
+  if (args.isNativeIn) {
+    if (!args.nativeWrapped) throw new Error("nativeWrapped is required when isNativeIn is true.");
+    const wrapped = gmxWrappedNativeSymbolForChain(args.chainId);
+    if (!wrapped) throw new Error("Wrapped native symbol is not configured for this chain.");
+    if (args.collateralToken.trim().toUpperCase() !== wrapped.toUpperCase()) {
+      throw new Error("Native GM deposit requires the chain wrapped native collateral symbol.");
+    }
+    return Promise.resolve(viem.getAddress(args.nativeWrapped));
+  }
+  return gmxResolveTokenBySymbol(args.chainId, args.collateralToken).then((t) => viem.getAddress(t.address));
+}
+async function buildGmLiquidityMultisignBatch(common, steps, signatureMeta, purposeSuffix) {
+  const executor = viem.getAddress(common.executorAddress);
+  const firstStep = steps[0];
+  const dataNo0x = firstStep.data.startsWith("0x") ? firstStep.data.slice(2) : firstStep.data;
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: common.keyGen,
+      purposeText: common.purposeText,
+      chainId: common.chainId,
+      rpcUrl: common.rpcUrl,
+      executorAddress: executor,
+      chainDetail: common.chainDetail,
+      useCustomGas: common.useCustomGas,
+      customGasChainDetails: common.customGasChainDetails
+    },
+    steps,
+    purposeSuffix,
+    firstMsgRawNo0x: dataNo0x,
+    destinationAddress: firstStep.to,
+    resolveGasLimit: async ({ estimatedGas, index }) => {
+      const step = steps[index];
+      const fallback = step?.fallbackGas ?? GMX_GM_MULTICALL_FALLBACK;
+      return estimatedGas > fallback ? estimatedGas : fallback;
+    },
+    buildBatchMeta: ({ index }) => {
+      const step = steps[index];
+      const isApprove = step?.fallbackGas === GMX_ERC20_APPROVE_FALLBACK2;
+      const isWrap = step?.value > 0n && step?.fallbackGas === GMX_WETH_DEPOSIT_FALLBACK2;
+      if (isWrap) {
+        return {
+          signatureText: JSON.stringify({ kind: "GMX", step: "weth_deposit", ...signatureMeta }),
+          evm: { type: "gmx_weth_deposit", version: 1, chainId: String(common.chainId) }
+        };
+      }
+      if (isApprove) {
+        return {
+          signatureText: JSON.stringify({ kind: "GMX", step: "approve", ...signatureMeta }),
+          evm: { type: "gmx_erc20_approve", version: 1, chainId: String(common.chainId) }
+        };
+      }
+      return {
+        signatureText: JSON.stringify({ kind: "GMX", ...signatureMeta }),
+        evm: { type: "gmx_gm_liquidity", version: 1, chainId: String(common.chainId) }
+      };
+    }
+  });
+}
+async function buildEvmMultisignBodyGmxGmDepositBatch(args) {
+  const executor = viem.getAddress(args.executorAddress);
+  const market = await gmxResolveMarketBySymbol(args.chainId, args.marketSymbol);
+  const collateralAddr = await resolveGmCollateralAddress(args);
+  const collateralRow = await gmxResolveTokenBySymbol(args.chainId, args.collateralToken);
+  const amountWei = parseGmxTokenAmount(args.collateralAmountHuman, collateralRow.decimals);
+  if (amountWei === 0n) throw new Error("Collateral amount is zero after converting with token decimals.");
+  const longToken = viem.getAddress(market.longTokenAddress);
+  const shortToken = viem.getAddress(market.shortTokenAddress);
+  if (collateralAddr !== longToken && collateralAddr !== shortToken) {
+    throw new Error("Collateral token is not a pool token for the selected GM market.");
+  }
+  const exchangeRouter = gmxContractAddress(args.chainId, "ExchangeRouter");
+  const depositVault = gmxContractAddress(args.chainId, "DepositVault");
+  const executionFee = await gmxEstimateGmExecutionFee({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    operation: "deposit",
+    executionFeeBufferBps: args.executionFeeBufferBps
+  });
+  const prepSteps = [];
+  if (args.isNativeIn && args.nativeWrapped) {
+    prepSteps.push(
+      ...await buildNativeWrapPrepSteps({
+        chainId: args.chainId,
+        rpcUrl: args.rpcUrl,
+        executorAddress: executor,
+        nativeWrapped: args.nativeWrapped,
+        exchangeRouter,
+        amountWei
+      })
+    );
+  } else {
+    prepSteps.push(
+      ...await buildApproveStepsIfNeeded({
+        chainId: args.chainId,
+        rpcUrl: args.rpcUrl,
+        executorAddress: executor,
+        token: collateralAddr,
+        spender: exchangeRouter,
+        amountWei
+      })
+    );
+  }
+  const multicallData = [
+    viem.encodeFunctionData({
+      abi: ExchangeRouterAbi,
+      functionName: "sendWnt",
+      args: [depositVault, executionFee]
+    }),
+    viem.encodeFunctionData({
+      abi: ExchangeRouterAbi,
+      functionName: "sendTokens",
+      args: [collateralAddr, depositVault, amountWei]
+    }),
+    viem.encodeFunctionData({
+      abi: ExchangeRouterAbi,
+      functionName: "createDeposit",
+      args: [
+        {
+          addresses: {
+            receiver: executor,
+            callbackContract: gmxZeroAddress(),
+            uiFeeReceiver: gmxZeroAddress(),
+            market: viem.getAddress(market.marketTokenAddress),
+            initialLongToken: longToken,
+            initialShortToken: shortToken,
+            longTokenSwapPath: [],
+            shortTokenSwapPath: []
+          },
+          minMarketTokens: 0n,
+          shouldUnwrapNativeToken: Boolean(args.isNativeIn),
+          executionFee,
+          callbackGasLimit: 0n,
+          dataList: []
+        }
+      ]
+    })
+  ];
+  const orderStep = {
+    to: exchangeRouter,
+    data: viem.encodeFunctionData({
+      abi: ExchangeRouterAbi,
+      functionName: "multicall",
+      args: [multicallData]
+    }),
+    value: executionFee,
+    fallbackGas: GMX_GM_MULTICALL_FALLBACK
+  };
+  return buildGmLiquidityMultisignBatch(
+    args,
+    [...prepSteps, orderStep],
+    {
+      action: "gm-deposit",
+      marketSymbol: args.marketSymbol,
+      collateralToken: args.collateralToken,
+      collateralAmountHuman: args.collateralAmountHuman,
+      isNativeIn: Boolean(args.isNativeIn)
+    },
+    "GMX: GM pool deposit (keeper-executed asynchronously)."
+  );
+}
+async function buildEvmMultisignBodyGmxGmWithdrawBatch(args) {
+  const executor = viem.getAddress(args.executorAddress);
+  const market = await gmxResolveMarketBySymbol(args.chainId, args.marketSymbol);
+  const gmToken = viem.getAddress(market.marketTokenAddress);
+  const gmDecimals = args.gmDecimals ?? 18;
+  const gmAmountWei = parseGmxTokenAmount(args.gmAmountHuman, gmDecimals);
+  if (gmAmountWei === 0n) throw new Error("GM amount is zero after converting with token decimals.");
+  const exchangeRouter = gmxContractAddress(args.chainId, "ExchangeRouter");
+  const withdrawalVault = gmxContractAddress(args.chainId, "WithdrawalVault");
+  const executionFee = await gmxEstimateGmExecutionFee({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    operation: "withdrawal",
+    executionFeeBufferBps: args.executionFeeBufferBps
+  });
+  const prepSteps = await buildApproveStepsIfNeeded({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    executorAddress: executor,
+    token: gmToken,
+    spender: exchangeRouter,
+    amountWei: gmAmountWei
+  });
+  const multicallData = [
+    viem.encodeFunctionData({
+      abi: ExchangeRouterAbi,
+      functionName: "sendWnt",
+      args: [withdrawalVault, executionFee]
+    }),
+    viem.encodeFunctionData({
+      abi: ExchangeRouterAbi,
+      functionName: "sendTokens",
+      args: [gmToken, withdrawalVault, gmAmountWei]
+    }),
+    viem.encodeFunctionData({
+      abi: ExchangeRouterAbi,
+      functionName: "createWithdrawal",
+      args: [
+        {
+          addresses: {
+            receiver: executor,
+            callbackContract: gmxZeroAddress(),
+            uiFeeReceiver: gmxZeroAddress(),
+            market: gmToken,
+            longTokenSwapPath: [],
+            shortTokenSwapPath: []
+          },
+          minLongTokenAmount: 0n,
+          minShortTokenAmount: 0n,
+          shouldUnwrapNativeToken: Boolean(args.isNativeOut),
+          executionFee,
+          callbackGasLimit: 0n,
+          dataList: []
+        }
+      ]
+    })
+  ];
+  const orderStep = {
+    to: exchangeRouter,
+    data: viem.encodeFunctionData({
+      abi: ExchangeRouterAbi,
+      functionName: "multicall",
+      args: [multicallData]
+    }),
+    value: executionFee,
+    fallbackGas: GMX_GM_MULTICALL_FALLBACK
+  };
+  return buildGmLiquidityMultisignBatch(
+    args,
+    [...prepSteps, orderStep],
+    {
+      action: "gm-withdraw",
+      marketSymbol: args.marketSymbol,
+      gmAmountHuman: args.gmAmountHuman,
+      isNativeOut: Boolean(args.isNativeOut)
+    },
+    "GMX: GM pool withdrawal (keeper-executed asynchronously)."
+  );
+}
+var require10 = module$1.createRequire(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+var RewardRouterAbi = require10("@gmx-io/sdk/abis/RewardRouter").default;
+var GMX_STAKE_FALLBACK = 600000n;
+var GMX_ERC20_APPROVE_FALLBACK3 = 100000n;
+var erc20AllowanceAbi3 = viem.parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)"
+]);
+var erc20ApproveAbi3 = viem.parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
+async function buildGmxStakeMultisignBatch(common, steps, signatureMeta, purposeSuffix) {
+  const executor = viem.getAddress(common.executorAddress);
+  const firstStep = steps[0];
+  const dataNo0x = firstStep.data.startsWith("0x") ? firstStep.data.slice(2) : firstStep.data;
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: common.keyGen,
+      purposeText: common.purposeText,
+      chainId: common.chainId,
+      rpcUrl: common.rpcUrl,
+      executorAddress: executor,
+      chainDetail: common.chainDetail,
+      useCustomGas: common.useCustomGas,
+      customGasChainDetails: common.customGasChainDetails
+    },
+    steps,
+    purposeSuffix,
+    firstMsgRawNo0x: dataNo0x,
+    destinationAddress: firstStep.to,
+    resolveGasLimit: async ({ estimatedGas, index }) => {
+      const step = steps[index];
+      const fallback = step?.fallbackGas ?? GMX_STAKE_FALLBACK;
+      return estimatedGas > fallback ? estimatedGas : fallback;
+    },
+    buildBatchMeta: ({ index }) => {
+      const step = steps[index];
+      const isApprove = step?.fallbackGas === GMX_ERC20_APPROVE_FALLBACK3;
+      if (isApprove) {
+        return {
+          signatureText: JSON.stringify({ kind: "GMX", step: "approve", ...signatureMeta }),
+          evm: { type: "gmx_erc20_approve", version: 1, chainId: String(common.chainId) }
+        };
+      }
+      return {
+        signatureText: JSON.stringify({ kind: "GMX", ...signatureMeta }),
+        evm: { type: "gmx_token_stake", version: 1, chainId: String(common.chainId) }
+      };
+    }
+  });
+}
+async function buildGmxApproveSteps(args) {
+  const ch = viem.defineChain({
+    id: args.chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Native", symbol: "N" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const allowance = await publicClient.readContract({
+    address: args.gmxToken,
+    abi: erc20AllowanceAbi3,
+    functionName: "allowance",
+    args: [args.executorAddress, args.rewardRouter]
+  });
+  if (allowance >= args.amountWei) return [];
+  const steps = [];
+  if (allowance > 0n) {
+    steps.push({
+      to: args.gmxToken,
+      data: viem.encodeFunctionData({ abi: erc20ApproveAbi3, functionName: "approve", args: [args.rewardRouter, 0n] }),
+      value: 0n,
+      fallbackGas: GMX_ERC20_APPROVE_FALLBACK3
+    });
+  }
+  steps.push({
+    to: args.gmxToken,
+    data: viem.encodeFunctionData({ abi: erc20ApproveAbi3, functionName: "approve", args: [args.rewardRouter, args.amountWei] }),
+    value: 0n,
+    fallbackGas: GMX_ERC20_APPROVE_FALLBACK3
+  });
+  return steps;
+}
+async function buildEvmMultisignBodyGmxStakeGmxBatch(args) {
+  const executor = viem.getAddress(args.executorAddress);
+  const gmxToken = gmxContractAddress(args.chainId, "GMX");
+  const rewardRouter = gmxContractAddress(args.chainId, "RewardRouter");
+  const amountWei = parseGmxTokenAmount(args.amountHuman, args.gmxDecimals ?? 18);
+  if (amountWei === 0n) throw new Error("GMX stake amount is zero after converting with token decimals.");
+  const prepSteps = await buildGmxApproveSteps({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    executorAddress: executor,
+    gmxToken,
+    rewardRouter,
+    amountWei
+  });
+  const stakeStep = {
+    to: rewardRouter,
+    data: viem.encodeFunctionData({
+      abi: RewardRouterAbi,
+      functionName: "stakeGmx",
+      args: [amountWei]
+    }),
+    value: 0n,
+    fallbackGas: GMX_STAKE_FALLBACK
+  };
+  return buildGmxStakeMultisignBatch(
+    args,
+    [...prepSteps, stakeStep],
+    { action: "stake-gmx", amountHuman: args.amountHuman },
+    "GMX: stake GMX tokens via RewardRouter."
+  );
+}
+async function buildEvmMultisignBodyGmxUnstakeGmxBatch(args) {
+  const rewardRouter = gmxContractAddress(args.chainId, "RewardRouter");
+  const amountWei = parseGmxTokenAmount(args.amountHuman, args.gmxDecimals ?? 18);
+  if (amountWei === 0n) throw new Error("GMX unstake amount is zero after converting with token decimals.");
+  const unstakeStep = {
+    to: rewardRouter,
+    data: viem.encodeFunctionData({
+      abi: RewardRouterAbi,
+      functionName: "unstakeGmx",
+      args: [amountWei]
+    }),
+    value: 0n,
+    fallbackGas: GMX_STAKE_FALLBACK
+  };
+  return buildGmxStakeMultisignBatch(
+    args,
+    [unstakeStep],
+    { action: "unstake-gmx", amountHuman: args.amountHuman },
+    "GMX: unstake GMX tokens via RewardRouter."
+  );
+}
+var erc20BalanceAbi = viem.parseAbi([
+  "function balanceOf(address account) view returns (uint256)",
+  "function decimals() view returns (uint8)"
+]);
+var GM_DECIMALS_DEFAULT = 18;
+function gmTokenListSymbol(marketSymbol) {
+  const bracket = marketSymbol.match(/^([^[\]]+)/)?.[1]?.trim();
+  const base = (bracket ?? marketSymbol).replace(/\s+/g, "");
+  const compact = base.length > 20 ? `${base.slice(0, 17)}\u2026` : base;
+  return `GM:${compact}`;
+}
+function gmTokenListName(marketSymbol) {
+  return `GMX GM ${marketSymbol.trim()}`;
+}
+async function gmxFetchGmLiquidityPositions(args) {
+  const executor = viem.getAddress(args.executorAddress);
+  const rpcUrl = args.rpcUrl.trim();
+  if (!rpcUrl) throw new Error("rpcUrl is required to read GM liquidity balances.");
+  const sdk = getGmxApiSdk(args.chainId);
+  const [markets, apyRes] = await Promise.all([
+    gmxFetchGmMarketsSummary(args.chainId),
+    sdk.fetchApy().catch(() => ({ markets: {} }))
+  ]);
+  const apyByMarket = apyRes.markets ?? {};
+  const ch = viem.defineChain({
+    id: args.chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Native", symbol: "N" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(rpcUrl) });
+  const rows = [];
+  await Promise.all(
+    markets.map(async (market) => {
+      const token = viem.getAddress(market.marketTokenAddress);
+      let balance = 0n;
+      let decimals = GM_DECIMALS_DEFAULT;
+      try {
+        ;
+        [balance, decimals] = await Promise.all([
+          publicClient.readContract({
+            address: token,
+            abi: erc20BalanceAbi,
+            functionName: "balanceOf",
+            args: [executor]
+          }),
+          publicClient.readContract({
+            address: token,
+            abi: erc20BalanceAbi,
+            functionName: "decimals"
+          }).catch(() => GM_DECIMALS_DEFAULT)
+        ]);
+      } catch {
+        return;
+      }
+      if (!args.includeZeroBalance && balance === 0n) return;
+      const apyEntry = gmxLookupMarketApy(apyByMarket, token);
+      rows.push({
+        symbol: market.symbol,
+        marketTokenAddress: market.marketTokenAddress,
+        longTokenSymbol: market.longTokenSymbol,
+        shortTokenSymbol: market.shortTokenSymbol,
+        gmDecimals: Number(decimals),
+        gmBalanceWei: balance.toString(),
+        gmBalanceHuman: viem.formatUnits(balance, Number(decimals)),
+        apyPercentLabel: gmxFormatApyPercent(apyEntry?.apy),
+        tokenListSymbol: gmTokenListSymbol(market.symbol),
+        tokenListName: gmTokenListName(market.symbol)
+      });
+    })
+  );
+  rows.sort((a, b) => a.symbol.localeCompare(b.symbol, void 0, { sensitivity: "base" }));
+  return { rows };
+}
+
+// src/protocols/evm/gmx/prices.ts
+var GMX_OHLCV_TIMEFRAMES = ["1m", "5m", "15m", "1h", "4h", "1d", "1w", "1M"];
+var DEFAULT_OHLCV_LIMIT = 16;
+function indexLabelFromMarketSymbol(symbol) {
+  const m = symbol.trim().match(/^([^/]+)\/USD/i);
+  return m?.[1]?.trim() || symbol.trim();
+}
+function asBigint3(v) {
+  if (v == null) return void 0;
+  try {
+    return typeof v === "bigint" ? v : BigInt(String(v));
+  } catch {
+    return void 0;
+  }
+}
+function formatIndexPerCollateral(indexMark, collateralUsd) {
+  if (indexMark <= 0n || collateralUsd <= 0n) return null;
+  const index = Number(indexMark) / 1e30;
+  const coll = Number(collateralUsd) / 1e30;
+  if (!Number.isFinite(index) || !Number.isFinite(coll) || coll <= 0) return null;
+  const ratio = index / coll;
+  return ratio.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 6 });
+}
+function formatCandleTime(timestampMs) {
+  try {
+    return new Date(timestampMs).toLocaleString(void 0, {
+      month: "short",
+      day: "numeric",
+      hour: "2-digit",
+      minute: "2-digit"
+    });
+  } catch {
+    return String(timestampMs);
+  }
+}
+function mapOhlcvRows(raw, sort) {
+  const sorted = [...raw].sort((a, b) => sort === "asc" ? a.timestamp - b.timestamp : b.timestamp - a.timestamp);
+  return sorted.map((c) => ({
+    timestampMs: c.timestamp,
+    timeLabel: formatCandleTime(c.timestamp),
+    open: c.open,
+    high: c.high,
+    low: c.low,
+    close: c.close
+  }));
+}
+function assertGmxOhlcvTimeframe(timeframe) {
+  const tf = timeframe.trim();
+  if (!GMX_OHLCV_TIMEFRAMES.includes(tf)) {
+    throw new Error(`Invalid timeframe: ${timeframe}. Valid: ${GMX_OHLCV_TIMEFRAMES.join(", ")}`);
+  }
+  return tf;
+}
+async function gmxFetchMarketPrices(args) {
+  const symbol = args.symbol.trim();
+  const collateralSymbol = args.collateralSymbol.trim();
+  if (!symbol) throw new Error("GMX market symbol is required.");
+  if (!collateralSymbol) throw new Error("Collateral symbol is required.");
+  const sdk = getGmxApiSdk(args.chainId);
+  const [tickers, collateralToken] = await Promise.all([
+    sdk.fetchMarketsTickers({ symbols: [symbol] }),
+    resolveGmxTokenBySymbol(args.chainId, collateralSymbol)
+  ]);
+  const ticker = tickers.find((t) => String(t.symbol ?? "") === symbol) ?? tickers[0];
+  const mark = asBigint3(ticker?.markPrice ?? ticker?.minPrice);
+  const indexMarkUsd = formatGmxUsd30(mark);
+  const collateralPrice = asBigint3(
+    collateralToken?.prices?.minPrice
+  );
+  const collateralUsd = formatGmxUsd30(collateralPrice);
+  const indexPerCollateral = mark != null && collateralPrice != null ? formatIndexPerCollateral(mark, collateralPrice) : null;
+  return {
+    symbol,
+    indexLabel: indexLabelFromMarketSymbol(symbol),
+    collateralSymbol,
+    indexMarkUsd,
+    collateralUsd,
+    indexPerCollateral,
+    fetchedAtMs: Date.now()
+  };
+}
+async function gmxFetchOhlcv(args) {
+  const symbol = args.symbol.trim();
+  if (!symbol) throw new Error("GMX market symbol is required.");
+  const timeframe = assertGmxOhlcvTimeframe(args.timeframe ?? "15m");
+  const limit = args.limit ?? DEFAULT_OHLCV_LIMIT;
+  const sort = args.sort ?? "desc";
+  const sdk = getGmxApiSdk(args.chainId);
+  const ohlcvRaw = await sdk.fetchOhlcv({ symbol, timeframe, limit });
+  return {
+    symbol,
+    timeframe,
+    candles: mapOhlcvRows(ohlcvRaw, sort)
+  };
+}
+async function gmxFetchMarketSnapshot(args) {
+  const ohlcvTimeframe = assertGmxOhlcvTimeframe(args.ohlcvTimeframe ?? "15m");
+  const [prices, ohlcv] = await Promise.all([
+    gmxFetchMarketPrices(args),
+    gmxFetchOhlcv({ chainId: args.chainId, symbol: args.symbol, timeframe: ohlcvTimeframe, sort: "desc" })
+  ]);
+  return {
+    ...prices,
+    ohlcvTimeframe: ohlcv.timeframe,
+    ohlcv: ohlcv.candles
+  };
+}
+
+// src/protocols/evm/gmx/index.ts
+var GMX_PROTOCOL_ID = "gmx";
+var gmxProtocolModule = {
+  id: GMX_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    const chainId = typeof ctx.chainId === "number" ? ctx.chainId : Number(ctx.chainId);
+    return Number.isFinite(chainId) && isGmxChainSupported(chainId);
+  },
+  isTokenSupported(token) {
+    if (token.category !== "evm") return false;
+    return token.kind === "erc20";
+  },
+  actions: [
+    {
+      id: "gmx.increase",
+      protocolId: GMX_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Open or add to a GMX perp position (classic on-chain order)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        symbol: { type: "string", required: true, description: "GMX market symbol e.g. ETH/USD [WETH-USDC]" },
+        direction: { type: "string", required: true, description: "long or short" },
+        orderType: { type: "string", required: true, description: "market or limit" },
+        sizeUsdHuman: { type: "string", required: true, description: "Position size in USD" },
+        collateralToken: { type: "string", required: true, description: "Collateral token symbol e.g. USDC" },
+        collateralAmountHuman: { type: "string", required: true, description: "Collateral amount in token units" }
+      }
+    },
+    {
+      id: "gmx.decrease",
+      protocolId: GMX_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Close or reduce a GMX perp position (classic on-chain order)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        symbol: { type: "string", required: true, description: "GMX market symbol" },
+        direction: { type: "string", required: true, description: "long or short" },
+        orderType: { type: "string", required: true, description: "market or limit" },
+        sizeUsdHuman: { type: "string", required: true, description: "Size to close in USD" },
+        collateralToken: { type: "string", required: true, description: "Position collateral token symbol" }
+      }
+    },
+    {
+      id: "gmx.cancel",
+      protocolId: GMX_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Cancel a pending GMX order (classic on-chain)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        orderId: { type: "string", required: true, description: "Order key from fetchOrders" }
+      }
+    },
+    {
+      id: "gmx.gmDeposit",
+      protocolId: GMX_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Deposit collateral into a GMX GM liquidity pool (ExchangeRouter multicall)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        marketSymbol: { type: "string", required: true, description: "GM market symbol e.g. ETH/USD [WETH-USDC]" },
+        collateralToken: { type: "string", required: true, description: "Pool collateral token symbol" },
+        collateralAmountHuman: { type: "string", required: true, description: "Amount in token units" }
+      }
+    },
+    {
+      id: "gmx.gmWithdraw",
+      protocolId: GMX_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Withdraw GM market tokens from a GMX liquidity pool",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        marketSymbol: { type: "string", required: true, description: "GM market symbol" },
+        gmAmountHuman: { type: "string", required: true, description: "GM token amount to withdraw" }
+      }
+    },
+    {
+      id: "gmx.stakeGmx",
+      protocolId: GMX_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Stake GMX tokens via RewardRouter",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        amountHuman: { type: "string", required: true, description: "GMX amount to stake" }
+      }
+    },
+    {
+      id: "gmx.unstakeGmx",
+      protocolId: GMX_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Unstake GMX tokens via RewardRouter",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        amountHuman: { type: "string", required: true, description: "GMX amount to unstake" }
+      }
+    }
+  ]
+};
+registerProtocolModule(gmxProtocolModule);
+
+exports.GMX_NATIVE_GAS_SYMBOL_BY_CHAIN = GMX_NATIVE_GAS_SYMBOL_BY_CHAIN;
+exports.GMX_OHLCV_TIMEFRAMES = GMX_OHLCV_TIMEFRAMES;
+exports.GMX_PROTOCOL_ID = GMX_PROTOCOL_ID;
+exports.GMX_SUPPORTED_CHAIN_IDS = GMX_SUPPORTED_CHAIN_IDS;
+exports.GMX_WRAPPED_NATIVE_SYMBOL_BY_CHAIN = GMX_WRAPPED_NATIVE_SYMBOL_BY_CHAIN;
+exports.assertGmxOhlcvTimeframe = assertGmxOhlcvTimeframe;
+exports.buildEvmMultisignBodyGmxCancelBatch = buildEvmMultisignBodyGmxCancelBatch;
+exports.buildEvmMultisignBodyGmxDecreaseBatch = buildEvmMultisignBodyGmxDecreaseBatch;
+exports.buildEvmMultisignBodyGmxGmDepositBatch = buildEvmMultisignBodyGmxGmDepositBatch;
+exports.buildEvmMultisignBodyGmxGmWithdrawBatch = buildEvmMultisignBodyGmxGmWithdrawBatch;
+exports.buildEvmMultisignBodyGmxIncreaseBatch = buildEvmMultisignBodyGmxIncreaseBatch;
+exports.buildEvmMultisignBodyGmxLimitDecreaseBatch = buildEvmMultisignBodyGmxLimitDecreaseBatch;
+exports.buildEvmMultisignBodyGmxLimitIncreaseBatch = buildEvmMultisignBodyGmxLimitIncreaseBatch;
+exports.buildEvmMultisignBodyGmxStakeGmxBatch = buildEvmMultisignBodyGmxStakeGmxBatch;
+exports.buildEvmMultisignBodyGmxUnstakeGmxBatch = buildEvmMultisignBodyGmxUnstakeGmxBatch;
+exports.formatGmxLeverageBps = formatGmxLeverageBps;
+exports.formatGmxTokenAmountHuman = formatGmxTokenAmountHuman;
+exports.formatGmxUsd30 = formatGmxUsd30;
+exports.formatGmxUsd30HumanInput = formatGmxUsd30HumanInput;
+exports.getGmxApiSdk = getGmxApiSdk;
+exports.gmxAssertIncreaseOrderWithinMaxLeverage = gmxAssertIncreaseOrderWithinMaxLeverage;
+exports.gmxContractAddress = gmxContractAddress;
+exports.gmxEnrichGmMarketRowWithApy = gmxEnrichGmMarketRowWithApy;
+exports.gmxEstimateDecreasePreview = gmxEstimateDecreasePreview;
+exports.gmxEstimateGmExecutionFee = gmxEstimateGmExecutionFee;
+exports.gmxEstimateIncreasePreview = gmxEstimateIncreasePreview;
+exports.gmxFetchClosePositionCap = gmxFetchClosePositionCap;
+exports.gmxFetchCollateralTokens = gmxFetchCollateralTokens;
+exports.gmxFetchGmApy = gmxFetchGmApy;
+exports.gmxFetchGmLiquidityPositions = gmxFetchGmLiquidityPositions;
+exports.gmxFetchGmMarketForToken = gmxFetchGmMarketForToken;
+exports.gmxFetchGmMarkets = gmxFetchGmMarkets;
+exports.gmxFetchGmMarketsSummary = gmxFetchGmMarketsSummary;
+exports.gmxFetchMarketPrices = gmxFetchMarketPrices;
+exports.gmxFetchMarketSnapshot = gmxFetchMarketSnapshot;
+exports.gmxFetchMarkets = gmxFetchMarkets;
+exports.gmxFetchMarketsSummary = gmxFetchMarketsSummary;
+exports.gmxFetchOhlcv = gmxFetchOhlcv;
+exports.gmxFetchOrdersForExecutor = gmxFetchOrdersForExecutor;
+exports.gmxFetchPositionDisplayRows = gmxFetchPositionDisplayRows;
+exports.gmxFetchPositionsForExecutor = gmxFetchPositionsForExecutor;
+exports.gmxFetchStakingPower = gmxFetchStakingPower;
+exports.gmxFetchTokens = gmxFetchTokens;
+exports.gmxFindWrappedNativeToken = gmxFindWrappedNativeToken;
+exports.gmxFormatApyPercent = gmxFormatApyPercent;
+exports.gmxFormatPositionsForDisplay = gmxFormatPositionsForDisplay;
+exports.gmxGmxTokenAddress = gmxGmxTokenAddress;
+exports.gmxIsCloseSizeWithinPosition = gmxIsCloseSizeWithinPosition;
+exports.gmxIsCollateralTokenSupported = gmxIsCollateralTokenSupported;
+exports.gmxIsGmMarketTokenAddress = gmxIsGmMarketTokenAddress;
+exports.gmxIsGmxStakeTokenAddress = gmxIsGmxStakeTokenAddress;
+exports.gmxKeyForNodeAssetRow = gmxKeyForNodeAssetRow;
+exports.gmxLookupMarketApy = gmxLookupMarketApy;
+exports.gmxMarketAcceptsCollateral = gmxMarketAcceptsCollateral;
+exports.gmxMarketCollateralTokens = gmxMarketCollateralTokens;
+exports.gmxMarketMaxLeverageBps = gmxMarketMaxLeverageBps;
+exports.gmxMarketMaxLeverageLabel = gmxMarketMaxLeverageLabel;
+exports.gmxMarketsForCollateralSymbol = gmxMarketsForCollateralSymbol;
+exports.gmxNativeGasSymbolForChain = gmxNativeGasSymbolForChain;
+exports.gmxProtocolModule = gmxProtocolModule;
+exports.gmxResolveMarketByGmTokenAddress = gmxResolveMarketByGmTokenAddress;
+exports.gmxResolveMarketBySymbol = gmxResolveMarketBySymbol;
+exports.gmxResolveTokenBySymbol = gmxResolveTokenBySymbol;
+exports.gmxWrappedNativeSymbolForChain = gmxWrappedNativeSymbolForChain;
+exports.gmxZeroAddress = gmxZeroAddress;
+exports.isGmxChainSupported = isGmxChainSupported;
+exports.parseGmxTokenAmount = parseGmxTokenAmount;
+exports.parseGmxUsd30 = parseGmxUsd30;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map