@continuumdao/ctm-mpc-defi 0.2.56 → 0.2.58

package/dist/protocols/evm/railgun/index.js

@@ -0,0 +1,1218 @@
+import { getAddress, parseAbi, zeroAddress, encodeFunctionData, defineChain, createPublicClient, parseGwei, serializeTransaction, keccak256, hashMessage, stringToHex, http } from 'viem';
+import { fetchChainFeeParams, gasLimitFromEstimateAndChainConfig, gweiToDecimalString, proposalTxParamsToFeeSnapshot, alignEip1559FeesWithLatestBase, getClientIdFromKeyGenResult } from '@continuumdao/continuum-node-sdk';
+import { TXIDVersion, calculateGasPrice, ChainType, EVMGasType, RailgunWalletBalanceBucket } from '@railgun-community/shared-models';
+import { createRequire } from 'module';
+import { join, dirname } from 'path';
+
+// 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/railgun/networks.ts
+function selectRailgunNetworks(config) {
+  const rows = [];
+  for (const entry of Object.values(config)) {
+    if (!entry || entry.deprecated || entry.isDevOnlyNetwork) continue;
+    const chainId = Number(entry.chain?.id);
+    const proxyContract = String(entry.proxyContract ?? "").trim();
+    const wrappedAddress = String(entry.baseToken?.wrappedAddress ?? "").trim();
+    if (!Number.isFinite(chainId) || chainId <= 0 || !proxyContract || !wrappedAddress) continue;
+    rows.push({
+      chainId,
+      networkName: String(entry.name ?? ""),
+      publicName: String(entry.publicName ?? entry.name ?? ""),
+      proxyContract,
+      deploymentBlock: Number(entry.deploymentBlock ?? 0),
+      wrappedAddress,
+      wrappedSymbol: String(entry.baseToken?.wrappedSymbol ?? entry.baseToken?.symbol ?? ""),
+      wrappedDecimals: Number(entry.baseToken?.decimals ?? 18),
+      isTestnet: Boolean(entry.isTestnet)
+    });
+  }
+  rows.sort((a, b) => a.chainId - b.chainId);
+  return rows;
+}
+var cached = null;
+async function loadRailgunNetworks() {
+  if (cached) return cached;
+  const mod = await import('@railgun-community/shared-models');
+  cached = selectRailgunNetworks(mod.NETWORK_CONFIG);
+  return cached;
+}
+async function loadRailgunSupportedChainIds() {
+  const rows = await loadRailgunNetworks();
+  return new Set(rows.map((row) => row.chainId));
+}
+async function railgunNetworkByChainId(chainId) {
+  const rows = await loadRailgunNetworks();
+  return rows.find((row) => row.chainId === chainId);
+}
+function clearRailgunNetworkCache() {
+  cached = null;
+}
+var CONTINUUM_DAO_ETHEREUM_CHAIN_ID = 1;
+var CONTINUUM_DAO_LINEA_CHAIN_ID = 59144;
+var CONTINUUM_DAO_LINEA_SEPOLIA_CHAIN_ID = 59141;
+var UNSET = {
+  ctm: zeroAddress,
+  votingEscrow: zeroAddress,
+  nodeProperties: zeroAddress,
+  rewards: zeroAddress,
+  governor: zeroAddress
+};
+var CTM_TOKEN_ADDRESS = getAddress("0x7581696b0ED142f6534E5797baaABBb9a1b27086");
+var VOTING_ESCROW_LINEA_ADDRESS = getAddress("0x221EC90B3B083A8501A37bdeb7035CeaedF3C31f");
+getAddress("0x4ebd7cCBe32a51d1638cFE90E8eD1c4BdF42f729");
+getAddress("0x92557d38beAe4658d3c03A02F349FFB60c3bfFA5");
+getAddress("0xe5D7C2a44FfDDf6b295A15c148167daaAf5Cf34f");
+getAddress("0x176211869cA2b568f2A7D4EE941E073a821EE1ff");
+var CONTINUUM_DAO_LINEA_GOVERNOR_ADDRESS = getAddress("0x76FF2CB03175900F1D83328C82D27EA9aeaF2355");
+getAddress("0x4800F9f1dC1b6daCA841B71E0531F547D374168E");
+var CONTINUUM_DAO_DEPLOYMENTS = {
+  [CONTINUUM_DAO_LINEA_CHAIN_ID]: {
+    ...UNSET,
+    ctm: CTM_TOKEN_ADDRESS,
+    votingEscrow: VOTING_ESCROW_LINEA_ADDRESS,
+    governor: CONTINUUM_DAO_LINEA_GOVERNOR_ADDRESS
+  },
+  [CONTINUUM_DAO_LINEA_SEPOLIA_CHAIN_ID]: { ...UNSET },
+  [CONTINUUM_DAO_ETHEREUM_CHAIN_ID]: {
+    ...UNSET,
+    ctm: CTM_TOKEN_ADDRESS
+  }
+};
+function isConfiguredAddress(addr) {
+  if (!addr?.trim()) return false;
+  try {
+    return getAddress(addr) !== zeroAddress;
+  } catch {
+    return false;
+  }
+}
+function continuumDaoDeployment(chainId) {
+  return CONTINUUM_DAO_DEPLOYMENTS[chainId] ?? null;
+}
+function ctmTokenAddressOnEvmChain(chainId) {
+  const ctm = continuumDaoDeployment(chainId)?.ctm;
+  return ctm && isConfiguredAddress(ctm) ? getAddress(ctm) : null;
+}
+
+// src/protocols/evm/railgun/popular-assets.ts
+var RAILGUN_POPULAR_ASSET_LIMIT = 5;
+var RAILGUN_CTM_ENABLED = false;
+var RAILGUN_CTM_DISABLED_MESSAGE = "Railgun support for CTM is off until a broadcaster quotes CTM.";
+var POPULAR_ASSET_CACHE_MS = 10 * 60 * 1e3;
+var RECENT_SHIELD_LIMIT = 200;
+var SHIELD_INDEX_BY_NETWORK_NAME = {
+  Ethereum: "https://rail-squid.squids.live/squid-railgun-ethereum-v2/graphql",
+  BNB_Chain: "https://rail-squid.squids.live/squid-railgun-bsc-v2/graphql",
+  Polygon: "https://rail-squid.squids.live/squid-railgun-polygon-v2/graphql",
+  Arbitrum: "https://rail-squid.squids.live/squid-railgun-arbitrum-v2/graphql"
+};
+var RECENT_SHIELDS_QUERY = `query RecentShields($limit: Int!) {
+  shieldCommitments(orderBy: [blockNumber_DESC], limit: $limit) {
+    preimage { token { tokenType tokenAddress } }
+  }
+}`;
+var cache = /* @__PURE__ */ new Map();
+function rankPopularShieldTokens(rows, limit = RAILGUN_POPULAR_ASSET_LIMIT) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (Number(row.tokenType) !== 0) continue;
+    let address;
+    try {
+      address = getAddress(row.tokenAddress);
+    } catch {
+      continue;
+    }
+    if (address === zeroAddress) continue;
+    const key = address.toLowerCase();
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)).slice(0, limit).map(([address]) => getAddress(address));
+}
+function shieldIndexEndpoint(networkName) {
+  return SHIELD_INDEX_BY_NETWORK_NAME[networkName] ?? null;
+}
+function commitmentsFromShieldIndex(payload) {
+  const rows = payload?.data?.shieldCommitments;
+  if (!Array.isArray(rows)) return [];
+  return rows.map((row) => {
+    const token = row?.preimage?.token;
+    const tokenType = token?.tokenType === "ERC20" || token?.tokenType === 0 ? 0 : Number(token?.tokenType ?? -1);
+    return {
+      tokenAddress: String(token?.tokenAddress ?? ""),
+      tokenType: Number.isFinite(tokenType) ? tokenType : -1
+    };
+  });
+}
+var shieldLogReaderOverride = null;
+function setRailgunShieldLogReaderForTests(fn) {
+  shieldLogReaderOverride = fn;
+}
+async function readShieldCommitments(args) {
+  const endpoint = shieldIndexEndpoint(args.networkName);
+  if (!endpoint) return [];
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      query: RECENT_SHIELDS_QUERY,
+      variables: { limit: RECENT_SHIELD_LIMIT }
+    })
+  });
+  if (!response.ok) throw new Error(`Railgun shield index returned ${response.status}`);
+  return commitmentsFromShieldIndex(await response.json());
+}
+function assertRailgunCtmAllowed(chainId, tokenAddress) {
+  const ctm = ctmTokenAddressOnEvmChain(chainId);
+  if (!ctm) return;
+  let normalized;
+  try {
+    normalized = getAddress(tokenAddress);
+  } catch {
+    return;
+  }
+  if (normalized.toLowerCase() === ctm.toLowerCase()) throw new Error(RAILGUN_CTM_DISABLED_MESSAGE);
+}
+function applyContinuumToken(chainId, result) {
+  const ctm = ctmTokenAddressOnEvmChain(chainId);
+  if (!ctm) return result;
+  const present = result.tokens.some((token) => token.address.toLowerCase() === ctm.toLowerCase());
+  {
+    if (!present) return result;
+    return {
+      ...result,
+      tokens: result.tokens.filter((token) => token.address.toLowerCase() !== ctm.toLowerCase())
+    };
+  }
+}
+async function loadRailgunPopularAssets(args) {
+  const network = await railgunNetworkByChainId(args.chainId);
+  if (!network) {
+    return { tokens: [], notes: "Railgun is not deployed on this chain." };
+  }
+  const cached2 = cache.get(args.chainId);
+  if (cached2 && Date.now() - cached2.at < POPULAR_ASSET_CACHE_MS) {
+    return applyContinuumToken(args.chainId, {
+      tokens: cached2.tokens,
+      nativeWrapped: cached2.nativeWrapped,
+      notes: cached2.notes
+    });
+  }
+  const rpcUrl = args.rpcUrl?.trim() ?? "";
+  if (!shieldIndexEndpoint(network.networkName) && !shieldLogReaderOverride) {
+    return applyContinuumToken(args.chainId, {
+      tokens: [],
+      nativeWrapped: network.wrappedAddress,
+      notes: "This chain has no indexed Railgun shield feed."
+    });
+  }
+  try {
+    const commitments = await (shieldLogReaderOverride ?? readShieldCommitments)({
+      rpcUrl,
+      chainId: args.chainId,
+      proxy: getAddress(network.proxyContract),
+      deploymentBlock: network.deploymentBlock,
+      networkName: network.networkName
+    });
+    const tokens = rankPopularShieldTokens(commitments).map((address) => ({ address }));
+    const notes = tokens.length === 0 ? "No recent ERC-20 shields were returned for this chain." : `Top ${tokens.length} ERC-20s by recent indexed shield count.`;
+    const entry = {
+      at: Date.now(),
+      tokens,
+      nativeWrapped: network.wrappedAddress,
+      notes
+    };
+    cache.set(args.chainId, entry);
+    return applyContinuumToken(args.chainId, { tokens, nativeWrapped: network.wrappedAddress, notes });
+  } catch {
+    return applyContinuumToken(args.chainId, {
+      tokens: [],
+      nativeWrapped: network.wrappedAddress,
+      notes: "The Railgun shield index could not be read."
+    });
+  }
+}
+function clearRailgunPopularAssetCache() {
+  cache.clear();
+}
+
+// src/protocols/evm/railgun/snapshot.ts
+var byChain = /* @__PURE__ */ new Map();
+function publishRailgunPrivateBalanceSnapshot(snapshot) {
+  byChain.set(snapshot.chainId, snapshot);
+}
+function readRailgunPrivateBalanceSnapshot(chainId) {
+  return byChain.get(chainId);
+}
+function clearRailgunPrivateBalanceSnapshots() {
+  byChain.clear();
+}
+function railgunFetchPrivateBalances(args) {
+  const row = readRailgunPrivateBalanceSnapshot(args.chainId);
+  if (!row || row.scanStatus === "scanning") {
+    return {
+      chainId: args.chainId,
+      scanned: false,
+      scanStatus: row?.scanStatus ?? "unscanned",
+      balances: [],
+      notes: "No Railgun scan is stored for this chain yet."
+    };
+  }
+  return {
+    chainId: args.chainId,
+    scanned: true,
+    scanStatus: row.scanStatus,
+    balances: row.balances,
+    notes: row.notes ?? (row.balances.length === 0 ? "No private balance on this chain yet." : "Private balances from the latest Railgun wallet scan.")
+  };
+}
+
+// src/protocols/evm/railgun/session.ts
+var RAILGUN_WALLET_LOCKED_MESSAGE = "Railgun wallet is not stored on this KeyGen.";
+var session = null;
+function setRailgunWalletSession(next) {
+  session = next;
+}
+function getRailgunWalletSession() {
+  return session;
+}
+function requireRailgunWalletSession() {
+  if (!session) throw new Error(RAILGUN_WALLET_LOCKED_MESSAGE);
+  return session;
+}
+
+// src/protocols/evm/railgun/reads.ts
+async function railgunFetchPopularAssets(args) {
+  const result = await loadRailgunPopularAssets(args);
+  return {
+    chainId: args.chainId,
+    tokens: result.tokens,
+    nativeWrapped: result.nativeWrapped,
+    notes: result.notes ?? ""
+  };
+}
+function railgunFetchPrivateBalancesSummary(args) {
+  return railgunFetchPrivateBalances(args);
+}
+function defiEvmTransport(rpcUrl, opts) {
+  const url = rpcUrl.trim();
+  return http(url, opts);
+}
+
+// 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 = 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, (_, v) => typeof v === "bigint" ? v.toString() : v);
+  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;
+  if (input.expiryDate != null && input.expiryDate > 0) {
+    bodyForSign.expiryDate = Math.floor(input.expiryDate);
+  }
+  return { bodyForSign, messageToSign: JSON.stringify(bodyForSign) };
+}
+function routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimit) {
+  if (chainGasLimit != null && Number.isFinite(chainGasLimit) && chainGasLimit > 0) {
+    return 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 = defineChain({
+    id: chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  const publicClient = createPublicClient({ chain: ch, transport: defiEvmTransport(rpcUrl) });
+  const feeParams = await 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 = 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 ? 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 = parseGwei(gweiToDecimalString(Number(chainDetail.gasPrice)));
+        if (configured > gasPriceWei) gasPriceWei = configured;
+      }
+      serialized = 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 = 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 ? parseGwei(gweiToDecimalString(effectivePriorityFeeGwei)) : parseGwei("1");
+      let maxFeePerGas = parseGwei(gweiToDecimalString(maxFeePerGasGwei));
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        maxPriorityFeePerGas = maxPriorityFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+        maxFeePerGas = maxFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      ({ maxFeePerGas, maxPriorityFeePerGas } = alignEip1559FeesWithLatestBase(
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        latestBaseFeeWei
+      ));
+      serialized = 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 ? proposalTxParamsToFeeSnapshot(proposalTxParams) : {};
+    }
+    const h = 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,
+    expiryDate: context.expiryDate
+  });
+  const pv = args.payableValueWei;
+  if (pv != null && pv > 0n) {
+    result.bodyForSign.value = pv.toString();
+  }
+  return result;
+}
+var require2 = createRequire(import.meta.url);
+var artifacts = /* @__PURE__ */ new Map();
+var started = false;
+var loadedProviders = /* @__PURE__ */ new Set();
+var lastEngineError = "";
+function errorChain(err) {
+  const parts = [];
+  let current = err;
+  for (let depth = 0; current && depth < 4; depth += 1) {
+    if (current instanceof Error) {
+      parts.push(current.message);
+      current = current.cause;
+      continue;
+    }
+    parts.push(String(current));
+    break;
+  }
+  return parts.join(": ");
+}
+function latestRailgunEngineError() {
+  return lastEngineError;
+}
+var POI_NODE_URLS = ["https://ppoi.fdi.network"];
+async function walletModule() {
+  return await import('@railgun-community/wallet');
+}
+var artifactStore = {
+  async get(path) {
+    return artifacts.get(path) ?? null;
+  },
+  async store(_dir, path, item) {
+    artifacts.set(path, item);
+  },
+  async exists(path) {
+    return artifacts.has(path);
+  }
+};
+async function ensureRailgunEngine() {
+  if (started) return;
+  const wallet = await walletModule();
+  const walletEntry = require2.resolve("@railgun-community/wallet");
+  const { setLoggers } = require2(join(dirname(walletEntry), "utils/logger.js"));
+  setLoggers(
+    () => void 0,
+    (err) => {
+      lastEngineError = errorChain(err);
+    }
+  );
+  const memdown = (await import('memdown')).default;
+  const store = new wallet.ArtifactStore(
+    (path) => artifactStore.get(path),
+    (dir, path, item) => artifactStore.store(dir, path, item),
+    (path) => artifactStore.exists(path)
+  );
+  await wallet.startRailgunEngine("continuum", new memdown(), true, store, false, false, POI_NODE_URLS, [], false);
+  started = true;
+}
+async function ensureRailgunProvider(chainId, rpcUrl) {
+  await ensureRailgunEngine();
+  const network = await railgunNetworkByChainId(chainId);
+  if (!network) throw new Error("Railgun is not deployed on this chain.");
+  const networkName = network.networkName;
+  if (!loadedProviders.has(networkName)) {
+    const wallet = await walletModule();
+    await wallet.loadProvider(
+      {
+        chainId,
+        providers: [{ provider: rpcUrl, priority: 1, weight: 2, stallTimeout: 2500 }]
+      },
+      networkName,
+      1e3 * 60 * 5
+    );
+    loadedProviders.add(networkName);
+  }
+  return networkName;
+}
+function railgunGasDetails(chainDetail, gasEstimate) {
+  if (chainDetail.legacy) {
+    return {
+      evmGasType: EVMGasType.Type0,
+      gasEstimate,
+      gasPrice: BigInt(Math.round(Number(chainDetail.gasPrice ?? 1) * 1e9))
+    };
+  }
+  return {
+    evmGasType: EVMGasType.Type2,
+    gasEstimate,
+    maxFeePerGas: BigInt(Math.round(Number(chainDetail.baseFee ?? 1) * 1e9)),
+    maxPriorityFeePerGas: BigInt(Math.round(Number(chainDetail.priorityFee ?? 1) * 1e9))
+  };
+}
+
+// src/protocols/evm/railgun/shield.ts
+var erc20Abi = parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function approve(address spender, uint256 amount) returns (bool)"
+]);
+var wethAbi = parseAbi(["function deposit() payable", "function withdraw(uint256 wad)"]);
+var populateShieldOverride = null;
+var allowanceReaderOverride = null;
+function setRailgunPopulateShieldForTests(fn) {
+  populateShieldOverride = fn;
+}
+function setRailgunAllowanceReaderForTests(fn) {
+  allowanceReaderOverride = fn;
+}
+async function shieldSignatureMessage() {
+  const wallet = await import('@railgun-community/wallet');
+  return wallet.getShieldPrivateKeySignatureMessage();
+}
+function personalSignBody(args, message) {
+  const executor = getAddress(args.executorAddress);
+  const digest = hashMessage(message);
+  return finalizeMultisign({
+    keyGen: args.keyGen,
+    purposeText: args.purposeText,
+    destinationChainID: String(args.chainId),
+    destinationAddress: executor,
+    expiryDate: args.expiryDate,
+    extraJSON: {
+      signRequestKind: "personal_sign",
+      delivery: {
+        kind: "railgun_shield_signature",
+        chainId: args.chainId,
+        message
+      }
+    },
+    legs: [
+      {
+        msgHash: digest.startsWith("0x") ? digest.slice(2) : digest,
+        msgRaw: stringToHex(message),
+        destinationAddress: executor,
+        signatureText: "Railgun shield key",
+        audit: {
+          kind: "PERSONAL_SIGN",
+          protocol: "railgun",
+          action: "shield-signature"
+        },
+        feeSnapshot: {}
+      }
+    ]
+  });
+}
+async function readAllowance(args) {
+  if (allowanceReaderOverride) return allowanceReaderOverride(args);
+  const client = createPublicClient({ transport: defiEvmTransport(args.rpcUrl) });
+  return client.readContract({
+    address: args.tokenAddress,
+    abi: erc20Abi,
+    functionName: "allowance",
+    args: [args.owner, args.spender]
+  });
+}
+async function buildEvmMultisignBodyWethUnwrap(args) {
+  const network = await railgunNetworkByChainId(args.chainId);
+  if (!network) throw new Error("Railgun is not deployed on this chain.");
+  const tokenAddress = getAddress(network.wrappedAddress);
+  const amount = BigInt(args.amountWei);
+  if (amount <= 0n) throw new Error("Amount must be greater than zero.");
+  const rpcUrl = args.rpcUrl.trim();
+  if (!rpcUrl) throw new Error("rpcUrl is required.");
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      chainId: args.chainId,
+      rpcUrl,
+      executorAddress: getAddress(args.executorAddress),
+      chainDetail: args.chainDetail,
+      useCustomGas: Boolean(args.useCustomGas),
+      customGasChainDetails: args.customGasChainDetails,
+      keyGen: args.keyGen,
+      purposeText: args.purposeText
+    },
+    steps: [
+      {
+        to: tokenAddress,
+        data: encodeFunctionData({ abi: wethAbi, functionName: "withdraw", args: [amount] }),
+        value: 0n,
+        fallbackGas: 80000n
+      }
+    ],
+    buildBatchMeta: () => ({ evm: { type: "railgun_unwrap" } })
+  });
+}
+async function buildEvmMultisignBodyRailgunShield(args) {
+  assertRailgunCtmAllowed(args.chainId, args.tokenAddress);
+  const signature = args.shieldSignature?.trim();
+  if (!signature) {
+    return personalSignBody(args, await shieldSignatureMessage());
+  }
+  const network = await railgunNetworkByChainId(args.chainId);
+  if (!network) throw new Error("Railgun is not deployed on this chain.");
+  const tokenAddress = getAddress(args.tokenAddress);
+  if (tokenAddress === zeroAddress) {
+    throw new Error("Shield the wrapped gas token. Railgun does not shield the native gas token directly.");
+  }
+  const amount = BigInt(args.amountWei);
+  if (amount <= 0n) throw new Error("Amount must be greater than zero.");
+  const executor = getAddress(args.executorAddress);
+  const spender = getAddress(network.proxyContract);
+  const rpcUrl = args.rpcUrl.trim();
+  if (!rpcUrl) throw new Error("rpcUrl is required.");
+  const allowance = await readAllowance({
+    rpcUrl,
+    tokenAddress,
+    owner: executor,
+    spender
+  });
+  const steps = [];
+  if (args.wrapNative) {
+    if (getAddress(network.wrappedAddress) !== tokenAddress) {
+      throw new Error("Native wrap only applies to this chain\u2019s wrapped gas token.");
+    }
+    steps.push({
+      to: tokenAddress,
+      data: encodeFunctionData({ abi: wethAbi, functionName: "deposit" }),
+      value: amount,
+      fallbackGas: 80000n
+    });
+  }
+  if (allowance > 0n && allowance < amount) {
+    steps.push({
+      to: tokenAddress,
+      data: encodeFunctionData({ abi: erc20Abi, functionName: "approve", args: [spender, 0n] }),
+      value: 0n,
+      fallbackGas: 80000n
+    });
+  }
+  if (allowance < amount) {
+    steps.push({
+      to: tokenAddress,
+      data: encodeFunctionData({ abi: erc20Abi, functionName: "approve", args: [spender, amount] }),
+      value: 0n,
+      fallbackGas: 80000n
+    });
+  }
+  const networkName = populateShieldOverride ? network.networkName : await ensureRailgunProvider(args.chainId, rpcUrl);
+  const populate = populateShieldOverride ?? (await import('@railgun-community/wallet')).populateShield;
+  const populated = await populate(
+    TXIDVersion.V2_PoseidonMerkle,
+    networkName,
+    signature,
+    [{ tokenAddress, amount, recipientAddress: args.railgunAddress.trim() }],
+    [],
+    railgunGasDetails(args.chainDetail, 1200000n)
+  );
+  const tx = populated.transaction;
+  const to = tx?.to ? getAddress(tx.to) : spender;
+  const data = tx?.data;
+  if (!data || !data.startsWith("0x")) throw new Error("Railgun shield transaction was empty.");
+  steps.push({
+    to,
+    data,
+    value: BigInt(tx?.value ?? 0),
+    fallbackGas: 1200000n
+  });
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      chainId: args.chainId,
+      rpcUrl,
+      executorAddress: executor,
+      chainDetail: args.chainDetail,
+      useCustomGas: Boolean(args.useCustomGas),
+      customGasChainDetails: args.customGasChainDetails,
+      keyGen: args.keyGen,
+      purposeText: args.purposeText
+    },
+    steps,
+    buildBatchMeta: ({ step }) => ({
+      evm: {
+        type: step.value > 0n ? "railgun_wrap" : step.to === tokenAddress ? "railgun_approve" : "railgun_shield"
+      }
+    })
+  });
+}
+function chainFor(chainId) {
+  return { type: ChainType.EVM, id: chainId };
+}
+async function assertDeployed(chainId) {
+  const network = await railgunNetworkByChainId(chainId);
+  if (!network) throw new Error("Railgun is not deployed on this chain.");
+  return network;
+}
+function parsedAmount(amountWei) {
+  const amount = BigInt(amountWei);
+  if (amount <= 0n) throw new Error("Amount must be greater than zero.");
+  return amount;
+}
+async function broadcasterClient() {
+  try {
+    return await import('@railgun-community/waku-broadcaster-client-web');
+  } catch {
+    throw new Error("Railgun broadcaster client is not available.");
+  }
+}
+async function selectedBroadcaster(chain, tokenAddress) {
+  const { WakuBroadcasterClient } = await broadcasterClient();
+  if (!WakuBroadcasterClient.isStarted()) {
+    await WakuBroadcasterClient.start(chain, { useDNSDiscovery: true }, () => void 0);
+  } else {
+    await WakuBroadcasterClient.setChain(chain);
+  }
+  const deadline = Date.now() + 2e4;
+  let selected;
+  while (Date.now() < deadline) {
+    selected = await WakuBroadcasterClient.findBestBroadcaster(chain, tokenAddress, false);
+    if (selected) return selected;
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+  }
+  throw new Error("No Railgun broadcaster is available for this token.");
+}
+async function submitProved(args) {
+  const to = args.populated.transaction.to;
+  const data = args.populated.transaction.data;
+  if (!to || !data) throw new Error("Railgun proof did not produce a transaction.");
+  const { BroadcasterTransaction } = await broadcasterClient();
+  const tx = await BroadcasterTransaction.create(
+    TXIDVersion.V2_PoseidonMerkle,
+    to,
+    data,
+    args.broadcaster.railgunAddress,
+    args.broadcaster.tokenFee.feesID,
+    args.chain,
+    args.populated.nullifiers ?? [],
+    args.overallBatchMinGasPrice,
+    false,
+    args.populated.preTransactionPOIsPerTxidLeafPerList
+  );
+  return tx.send();
+}
+function feeRecipient(wallet, broadcaster, gasDetails) {
+  const fee = wallet.calculateBroadcasterFeeERC20Amount(
+    {
+      tokenAddress: broadcaster.tokenAddress,
+      feePerUnitGas: BigInt(broadcaster.tokenFee.feePerUnitGas)
+    },
+    gasDetails
+  );
+  return {
+    tokenAddress: fee.tokenAddress,
+    amount: fee.amount,
+    recipientAddress: broadcaster.railgunAddress
+  };
+}
+async function railgunPrivateTransfer(args) {
+  assertRailgunCtmAllowed(args.chainId, args.tokenAddress);
+  await assertDeployed(args.chainId);
+  const tokenAddress = getAddress(args.tokenAddress);
+  const amount = parsedAmount(args.amountWei);
+  const recipientAddress = args.recipientAddress.trim();
+  if (!recipientAddress.startsWith("0zk")) throw new Error("Private transfer recipient must be a 0zk address.");
+  const session2 = requireRailgunWalletSession();
+  const rpcUrl = args.rpcUrl?.trim() ?? "";
+  if (!rpcUrl || !args.chainDetail) throw new Error("rpcUrl and chain details are required.");
+  const networkName = await ensureRailgunProvider(args.chainId, rpcUrl);
+  const wallet = await import('@railgun-community/wallet');
+  const chain = chainFor(args.chainId);
+  const broadcaster = await selectedBroadcaster(chain, tokenAddress);
+  const recipients = [{ tokenAddress, amount, recipientAddress }];
+  const feeToken = {
+    tokenAddress: broadcaster.tokenAddress,
+    feePerUnitGas: BigInt(broadcaster.tokenFee.feePerUnitGas)
+  };
+  const original = railgunGasDetails(args.chainDetail, 0n);
+  const { gasEstimate } = await wallet.gasEstimateForUnprovenTransfer(
+    TXIDVersion.V2_PoseidonMerkle,
+    networkName,
+    session2.walletId,
+    session2.encryptionKey,
+    args.memoText ?? null,
+    recipients,
+    [],
+    original,
+    feeToken,
+    false
+  );
+  const gasDetails = railgunGasDetails(args.chainDetail, gasEstimate);
+  const broadcasterFee = feeRecipient(wallet, broadcaster, gasDetails);
+  const overallBatchMinGasPrice = calculateGasPrice(gasDetails);
+  await wallet.generateTransferProof(
+    TXIDVersion.V2_PoseidonMerkle,
+    networkName,
+    session2.walletId,
+    session2.encryptionKey,
+    false,
+    args.memoText ?? null,
+    recipients,
+    [],
+    broadcasterFee,
+    false,
+    overallBatchMinGasPrice,
+    (progress) => args.onProofProgress?.(progress)
+  );
+  const populated = await wallet.populateProvedTransfer(
+    TXIDVersion.V2_PoseidonMerkle,
+    networkName,
+    session2.walletId,
+    false,
+    args.memoText ?? null,
+    recipients,
+    [],
+    broadcasterFee,
+    false,
+    overallBatchMinGasPrice,
+    gasDetails
+  );
+  return { txHash: await submitProved({ chain, populated, broadcaster, overallBatchMinGasPrice }) };
+}
+async function railgunUnshield(args) {
+  assertRailgunCtmAllowed(args.chainId, args.tokenAddress);
+  await assertDeployed(args.chainId);
+  const tokenAddress = getAddress(args.tokenAddress);
+  const amount = parsedAmount(args.amountWei);
+  const recipientAddress = getAddress(args.recipientAddress);
+  const session2 = requireRailgunWalletSession();
+  const rpcUrl = args.rpcUrl?.trim() ?? "";
+  if (!rpcUrl || !args.chainDetail) throw new Error("rpcUrl and chain details are required.");
+  const networkName = await ensureRailgunProvider(args.chainId, rpcUrl);
+  const wallet = await import('@railgun-community/wallet');
+  const chain = chainFor(args.chainId);
+  const broadcaster = await selectedBroadcaster(chain, tokenAddress);
+  const recipients = [{ tokenAddress, amount, recipientAddress }];
+  const feeToken = {
+    tokenAddress: broadcaster.tokenAddress,
+    feePerUnitGas: BigInt(broadcaster.tokenFee.feePerUnitGas)
+  };
+  const original = railgunGasDetails(args.chainDetail, 0n);
+  const { gasEstimate } = await wallet.gasEstimateForUnprovenUnshield(
+    TXIDVersion.V2_PoseidonMerkle,
+    networkName,
+    session2.walletId,
+    session2.encryptionKey,
+    recipients,
+    [],
+    original,
+    feeToken,
+    false
+  );
+  const gasDetails = railgunGasDetails(args.chainDetail, gasEstimate);
+  const broadcasterFee = feeRecipient(wallet, broadcaster, gasDetails);
+  const overallBatchMinGasPrice = calculateGasPrice(gasDetails);
+  await wallet.generateUnshieldProof(
+    TXIDVersion.V2_PoseidonMerkle,
+    networkName,
+    session2.walletId,
+    session2.encryptionKey,
+    recipients,
+    [],
+    broadcasterFee,
+    false,
+    overallBatchMinGasPrice,
+    (progress) => args.onProofProgress?.(progress)
+  );
+  const populated = await wallet.populateProvedUnshield(
+    TXIDVersion.V2_PoseidonMerkle,
+    networkName,
+    session2.walletId,
+    recipients,
+    [],
+    broadcasterFee,
+    false,
+    overallBatchMinGasPrice,
+    gasDetails
+  );
+  return { txHash: await submitProved({ chain, populated, broadcaster, overallBatchMinGasPrice }) };
+}
+async function walletModule2() {
+  return await import('@railgun-community/wallet');
+}
+async function createRailgunBrowserWallet(args) {
+  await ensureRailgunEngine();
+  const network = await railgunNetworkByChainId(args.chainId);
+  const wallet = await walletModule2();
+  const created = await wallet.createRailgunWallet(
+    args.encryptionKey,
+    args.mnemonic,
+    network ? { [network.networkName]: network.deploymentBlock } : void 0
+  );
+  const session2 = {
+    walletId: created.id,
+    encryptionKey: args.encryptionKey,
+    railgunAddress: created.railgunAddress
+  };
+  setRailgunWalletSession(session2);
+  return session2;
+}
+async function unlockRailgunBrowserWallet(args) {
+  const wallet = await walletModule2();
+  const loaded = await wallet.loadWalletByID(args.encryptionKey, args.walletId, false);
+  const session2 = {
+    walletId: loaded.id,
+    encryptionKey: args.encryptionKey,
+    railgunAddress: loaded.railgunAddress
+  };
+  setRailgunWalletSession(session2);
+  return session2;
+}
+async function railgunShareableViewingKey(walletId) {
+  const wallet = await walletModule2();
+  const viewingKey = await wallet.getWalletShareableViewingKey(walletId);
+  if (!viewingKey) throw new Error("Railgun viewing key is not available.");
+  return viewingKey;
+}
+async function openRailgunViewOnlyWallet(args) {
+  await ensureRailgunEngine();
+  const network = await railgunNetworkByChainId(args.chainId);
+  const wallet = await walletModule2();
+  const created = await wallet.createViewOnlyRailgunWallet(
+    args.encryptionKey,
+    args.shareableViewingKey,
+    network ? { [network.networkName]: network.deploymentBlock } : void 0
+  );
+  return { walletId: created.id, railgunAddress: created.railgunAddress };
+}
+async function discardRailgunWallet(walletId) {
+  setRailgunWalletSession(null);
+  const wallet = await walletModule2();
+  wallet.unloadWalletByID(walletId);
+  await wallet.deleteWalletByID(walletId);
+}
+function railgunAddressIsValid(address) {
+  return walletModule2().then((wallet) => wallet.validateRailgunAddress(address));
+}
+var buckets = /* @__PURE__ */ new Map();
+function rowMap(chainId) {
+  let rows = buckets.get(chainId);
+  if (!rows) {
+    rows = /* @__PURE__ */ new Map();
+    buckets.set(chainId, rows);
+  }
+  return rows;
+}
+function cellFor(rows, tokenAddress) {
+  const key = tokenAddress.toLowerCase();
+  let cell = rows.get(key);
+  if (!cell) {
+    cell = { spendable: 0n, pending: /* @__PURE__ */ new Map() };
+    rows.set(key, cell);
+  }
+  return cell;
+}
+function applyBalanceEvent(event) {
+  if (event.txidVersion !== TXIDVersion.V2_PoseidonMerkle) return;
+  const rows = rowMap(event.chain.id);
+  const spendable = event.balanceBucket === RailgunWalletBalanceBucket.Spendable;
+  const pending = event.balanceBucket === RailgunWalletBalanceBucket.ShieldPending || event.balanceBucket === RailgunWalletBalanceBucket.ProofSubmitted || event.balanceBucket === RailgunWalletBalanceBucket.MissingExternalPOI || event.balanceBucket === RailgunWalletBalanceBucket.MissingInternalPOI;
+  if (!spendable && !pending) return;
+  if (spendable) {
+    for (const cell of rows.values()) cell.spendable = 0n;
+  }
+  if (pending) {
+    for (const cell of rows.values()) cell.pending.delete(event.balanceBucket);
+  }
+  for (const amount of event.erc20Amounts) {
+    const cell = cellFor(rows, amount.tokenAddress);
+    if (spendable) cell.spendable = amount.amount;
+    if (pending) cell.pending.set(event.balanceBucket, amount.amount);
+  }
+}
+function snapshotRows(chainId) {
+  const rows = buckets.get(chainId);
+  if (!rows) return [];
+  return [...rows.entries()].filter(([, cell]) => cell.spendable > 0n || [...cell.pending.values()].some((amount) => amount > 0n)).map(([tokenAddress, cell]) => ({
+    tokenAddress,
+    spendable: cell.spendable.toString(),
+    pending: [...cell.pending.values()].reduce((sum, amount) => sum + amount, 0n).toString()
+  }));
+}
+function utxoScanTerminalStatus(scanStatus) {
+  if (scanStatus === "Complete") return "done";
+  if (scanStatus === "Incomplete") return "failed";
+  return "pending";
+}
+async function scanRailgunPrivateBalances(args) {
+  const rpcUrl = args.rpcUrl.trim();
+  if (!rpcUrl) throw new Error("rpcUrl is required.");
+  buckets.set(args.chainId, /* @__PURE__ */ new Map());
+  publishRailgunPrivateBalanceSnapshot({
+    chainId: args.chainId,
+    scanStatus: "scanning",
+    balances: [],
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const wallet = await walletModule2();
+  let resolveScan = () => {
+  };
+  const scanSettled = new Promise((resolve) => {
+    resolveScan = resolve;
+  });
+  wallet.setOnBalanceUpdateCallback((event) => {
+    if (event.railgunWalletID !== args.walletId) return;
+    applyBalanceEvent(event);
+  });
+  wallet.setOnUTXOMerkletreeScanCallback((event) => {
+    if (event.chain.id !== args.chainId) return;
+    args.onProgress?.(event.progress);
+    const terminal = utxoScanTerminalStatus(event.scanStatus);
+    if (terminal !== "pending") resolveScan(terminal);
+  });
+  await ensureRailgunProvider(args.chainId, rpcUrl);
+  const chain = { type: ChainType.EVM, id: args.chainId };
+  await wallet.refreshBalances(chain, [args.walletId]);
+  if (await scanSettled === "failed") {
+    const cause = latestRailgunEngineError();
+    throw new Error(cause ? `Railgun note scan stopped before it finished. ${cause}` : "Railgun note scan stopped before it finished.");
+  }
+  const balances = snapshotRows(args.chainId);
+  const scanStatus = balances.length === 0 ? "empty" : "ready";
+  publishRailgunPrivateBalanceSnapshot({
+    chainId: args.chainId,
+    scanStatus,
+    balances,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    notes: balances.length === 0 ? "No private balance on this chain yet." : void 0
+  });
+  return { scanStatus, balances };
+}
+
+// src/protocols/evm/railgun/index.ts
+var RAILGUN_PROTOCOL_ID = "railgun";
+var railgunProtocolModule = {
+  id: RAILGUN_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    return loadRailgunSupportedChainIds().then((ids) => ids.has(Number(ctx.chainId)));
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && (token.kind === "native" || token.kind === "erc20");
+  },
+  actions: [
+    {
+      id: "railgun.shield",
+      protocolId: RAILGUN_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Shield an ERC-20 into a Railgun 0zk address",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        tokenAddress: { type: "string", required: true, description: "ERC-20 to shield" },
+        amountWei: { type: "string", required: true, description: "Amount in wei" },
+        railgunAddress: { type: "string", required: true, description: "Recipient 0zk address" }
+      }
+    },
+    {
+      id: "railgun.private-transfer",
+      protocolId: RAILGUN_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Private transfer from the unlocked Railgun wallet",
+      commonParams: ["purposeText"],
+      params: {
+        tokenAddress: { type: "string", required: true, description: "Shielded ERC-20" },
+        amountWei: { type: "string", required: true, description: "Amount in wei" },
+        recipientAddress: { type: "string", required: true, description: "Recipient 0zk address" }
+      }
+    },
+    {
+      id: "railgun.unshield",
+      protocolId: RAILGUN_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Unshield from the unlocked Railgun wallet to a public address",
+      commonParams: ["purposeText"],
+      params: {
+        tokenAddress: { type: "string", required: true, description: "Shielded ERC-20" },
+        amountWei: { type: "string", required: true, description: "Amount in wei" },
+        recipientAddress: { type: "string", required: true, description: "Public recipient" }
+      }
+    }
+  ]
+};
+registerProtocolModule(railgunProtocolModule);
+
+export { RAILGUN_CTM_DISABLED_MESSAGE, RAILGUN_CTM_ENABLED, RAILGUN_POPULAR_ASSET_LIMIT, RAILGUN_PROTOCOL_ID, RAILGUN_WALLET_LOCKED_MESSAGE, assertRailgunCtmAllowed, buildEvmMultisignBodyRailgunShield, buildEvmMultisignBodyWethUnwrap, clearRailgunNetworkCache, clearRailgunPopularAssetCache, clearRailgunPrivateBalanceSnapshots, commitmentsFromShieldIndex, createRailgunBrowserWallet, discardRailgunWallet, getRailgunWalletSession, loadRailgunNetworks, loadRailgunPopularAssets, loadRailgunSupportedChainIds, openRailgunViewOnlyWallet, publishRailgunPrivateBalanceSnapshot, railgunAddressIsValid, railgunFetchPopularAssets, railgunFetchPrivateBalances, railgunFetchPrivateBalancesSummary, railgunNetworkByChainId, railgunPrivateTransfer, railgunProtocolModule, railgunShareableViewingKey, railgunUnshield, rankPopularShieldTokens, readRailgunPrivateBalanceSnapshot, requireRailgunWalletSession, scanRailgunPrivateBalances, selectRailgunNetworks, setRailgunAllowanceReaderForTests, setRailgunPopulateShieldForTests, setRailgunShieldLogReaderForTests, setRailgunWalletSession, shieldIndexEndpoint, unlockRailgunBrowserWallet, utxoScanTerminalStatus };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map