@veridex/sdk 1.0.0-beta.1

package/dist/wormhole.d.ts

@@ -0,0 +1,167 @@
+import { ethers } from 'ethers';
+import { VAA, VeridexPayload } from './types.js';
+
+/**
+ * Veridex Protocol SDK - Wormhole Utilities
+ *
+ * Functions for fetching VAAs, parsing messages, and interacting with Wormhole
+ *
+ * This module integrates with the official @wormhole-foundation/sdk patterns for
+ * better chain abstraction and reliability, while providing Veridex-specific
+ * utilities for payload handling and VAA management.
+ */
+
+/**
+ * Wormhole Consistency Levels
+ * @see https://docs.wormhole.com/wormhole/reference/glossary#consistency-level
+ */
+declare const CONSISTENCY_LEVELS: {
+    /** Finalized - Wait for block finality (most secure) */
+    readonly FINALIZED: 200;
+    /** Instant - No wait for finality (fastest, less secure) */
+    readonly INSTANT: 201;
+    /** Safe - Standard finality (deprecated, use FINALIZED) */
+    readonly SAFE: 200;
+};
+/**
+ * Guardian network configuration
+ */
+declare const GUARDIAN_CONFIG: {
+    /** Total number of guardians in mainnet */
+    readonly MAINNET_GUARDIAN_COUNT: 19;
+    /** Required signatures for mainnet quorum (13/19) */
+    readonly MAINNET_QUORUM: 13;
+    /** Total number of guardians in testnet */
+    readonly TESTNET_GUARDIAN_COUNT: 1;
+    /** Required signatures for testnet quorum */
+    readonly TESTNET_QUORUM: 1;
+};
+interface FetchVAAOptions {
+    testnet?: boolean;
+    maxRetries?: number;
+    retryDelayMs?: number;
+    onRetry?: (attempt: number, maxRetries: number) => void;
+}
+interface WaitForSignaturesOptions {
+    testnet?: boolean;
+    requiredSignatures?: number;
+    maxWaitMs?: number;
+    checkIntervalMs?: number;
+    onProgress?: (currentSignatures: number, required: number) => void;
+}
+/**
+ * Fetch a VAA from Wormhole guardians by sequence number
+ *
+ * @example
+ * ```ts
+ * const vaa = await fetchVAA(
+ *   WORMHOLE_CHAIN_IDS.TESTNET.BASE_SEPOLIA,
+ *   '0x000...hubAddress',
+ *   97n,
+ *   { testnet: true }
+ * );
+ * ```
+ */
+declare function fetchVAA(emitterChain: number, emitterAddress: string, sequence: bigint, options?: FetchVAAOptions): Promise<string>;
+/**
+ * Fetch VAA by transaction hash using operations API
+ * This is more reliable than the transactions API when sequence numbers don't match
+ */
+declare function fetchVAAByTxHash(txHash: string, options?: {
+    testnet?: boolean;
+    maxRetries?: number;
+    retryDelayMs?: number;
+    onRetry?: (attempt: number, maxRetries: number) => void;
+}): Promise<string>;
+/**
+ * Fetch VAA by transaction hash using transactions API (fallback)
+ */
+declare function fetchVAAByTxHashFallback(txHash: string, options?: {
+    testnet?: boolean;
+    maxRetries?: number;
+    retryDelayMs?: number;
+    onRetry?: (attempt: number, maxRetries: number) => void;
+}): Promise<string>;
+/**
+ * Parse a base64-encoded VAA into its components
+ */
+declare function parseVAA(vaaBase64: string): VAA;
+/**
+ * Parse raw VAA bytes into its components
+ */
+declare function parseVAABytes(vaaBytes: Buffer): VAA;
+/**
+ * Parse a Veridex-specific payload from a VAA
+ */
+declare function parseVeridexPayload(payloadHex: string): VeridexPayload;
+/**
+ * Encode a VAA back to bytes for on-chain submission
+ */
+declare function encodeVAAToBytes(vaaBase64: string): string;
+/**
+ * Encode VAA to bytes for Solana (returns Uint8Array)
+ */
+declare function encodeVAAForSolana(vaaBase64: string): Uint8Array;
+/**
+ * Normalize an address to a 32-byte Wormhole emitter address format
+ */
+declare function normalizeEmitterAddress(address: string): string;
+/**
+ * Convert a 32-byte emitter address back to a 20-byte EVM address
+ */
+declare function emitterToEvmAddress(emitterHex: string): string;
+/**
+ * Extract the VAA sequence from a transaction receipt
+ */
+declare function getSequenceFromTxReceipt(provider: ethers.Provider, txHash: string, wormholeCoreBridge: string): Promise<bigint>;
+/**
+ * Wait for a Wormhole message to be signed by guardians
+ *
+ * @example
+ * ```ts
+ * const vaa = await waitForGuardianSignatures(
+ *   WORMHOLE_CHAIN_IDS.TESTNET.BASE_SEPOLIA,
+ *   hubEmitter,
+ *   97n,
+ *   {
+ *     testnet: true,
+ *     onProgress: (current, required) => console.log(`${current}/${required} signatures`)
+ *   }
+ * );
+ * ```
+ */
+declare function waitForGuardianSignatures(emitterChain: number, emitterAddress: string, sequence: bigint, options?: WaitForSignaturesOptions): Promise<VAA>;
+/**
+ * Get the Wormhole Core Bridge contract address for a chain
+ */
+declare function getWormholeCoreBridge(wormholeChainId: number, testnet?: boolean): string;
+/**
+ * Get the Wormhole Token Bridge contract address for a chain
+ */
+declare function getWormholeTokenBridge(wormholeChainId: number, testnet?: boolean): string;
+/**
+ * Get the Wormhole Relayer contract address for a chain
+ */
+declare function getWormholeRelayer(wormholeChainId: number, testnet?: boolean): string;
+/**
+ * Check if a chain supports Wormhole Relayer
+ */
+declare function supportsRelayer(wormholeChainId: number, testnet?: boolean): boolean;
+/**
+ * Get chain name from Wormhole chain ID
+ */
+declare function getChainName(wormholeChainId: number): string;
+/**
+ * Validate that a VAA has sufficient signatures for the given network
+ */
+declare function hasQuorum(vaa: VAA, testnet?: boolean): boolean;
+/**
+ * Validate VAA emitter matches expected source
+ */
+declare function validateEmitter(vaa: VAA, expectedChain: number, expectedAddress: string): boolean;
+/**
+ * Convert an EVM address to bytes32 format (for Wormhole)
+ */
+declare function evmAddressToBytes32(address: string): string;
+
+export { CONSISTENCY_LEVELS, type FetchVAAOptions, GUARDIAN_CONFIG, type WaitForSignaturesOptions, emitterToEvmAddress, encodeVAAForSolana, encodeVAAToBytes, evmAddressToBytes32, fetchVAA, fetchVAAByTxHash, fetchVAAByTxHashFallback, getChainName, getSequenceFromTxReceipt, getWormholeCoreBridge, getWormholeRelayer, getWormholeTokenBridge, hasQuorum, normalizeEmitterAddress, parseVAA, parseVAABytes, parseVeridexPayload, supportsRelayer, validateEmitter, waitForGuardianSignatures };

package/dist/wormhole.js

@@ -0,0 +1,468 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/wormhole.ts
+var wormhole_exports = {};
+__export(wormhole_exports, {
+  CONSISTENCY_LEVELS: () => CONSISTENCY_LEVELS,
+  GUARDIAN_CONFIG: () => GUARDIAN_CONFIG,
+  emitterToEvmAddress: () => emitterToEvmAddress,
+  encodeVAAForSolana: () => encodeVAAForSolana,
+  encodeVAAToBytes: () => encodeVAAToBytes,
+  evmAddressToBytes32: () => evmAddressToBytes32,
+  fetchVAA: () => fetchVAA,
+  fetchVAAByTxHash: () => fetchVAAByTxHash,
+  fetchVAAByTxHashFallback: () => fetchVAAByTxHashFallback,
+  getChainName: () => getChainName,
+  getSequenceFromTxReceipt: () => getSequenceFromTxReceipt,
+  getWormholeCoreBridge: () => getWormholeCoreBridge,
+  getWormholeRelayer: () => getWormholeRelayer,
+  getWormholeTokenBridge: () => getWormholeTokenBridge,
+  hasQuorum: () => hasQuorum,
+  normalizeEmitterAddress: () => normalizeEmitterAddress,
+  parseVAA: () => parseVAA,
+  parseVAABytes: () => parseVAABytes,
+  parseVeridexPayload: () => parseVeridexPayload,
+  supportsRelayer: () => supportsRelayer,
+  validateEmitter: () => validateEmitter,
+  waitForGuardianSignatures: () => waitForGuardianSignatures
+});
+module.exports = __toCommonJS(wormhole_exports);
+var import_ethers = require("ethers");
+
+// src/constants.ts
+var WORMHOLE_API = {
+  MAINNET: "https://api.wormholescan.io",
+  TESTNET: "https://api.testnet.wormholescan.io",
+  GUARDIAN_RPC_MAINNET: "https://wormhole-v2-mainnet-api.certus.one",
+  GUARDIAN_RPC_TESTNET: "https://wormhole-v2-testnet-api.certus.one"
+};
+
+// src/wormhole.ts
+var CONSISTENCY_LEVELS = {
+  /** Finalized - Wait for block finality (most secure) */
+  FINALIZED: 200,
+  /** Instant - No wait for finality (fastest, less secure) */
+  INSTANT: 201,
+  /** Safe - Standard finality (deprecated, use FINALIZED) */
+  SAFE: 200
+};
+var GUARDIAN_CONFIG = {
+  /** Total number of guardians in mainnet */
+  MAINNET_GUARDIAN_COUNT: 19,
+  /** Required signatures for mainnet quorum (13/19) */
+  MAINNET_QUORUM: 13,
+  /** Total number of guardians in testnet */
+  TESTNET_GUARDIAN_COUNT: 1,
+  /** Required signatures for testnet quorum */
+  TESTNET_QUORUM: 1
+};
+async function fetchVAA(emitterChain, emitterAddress, sequence, options = {}) {
+  const {
+    testnet = true,
+    maxRetries = 30,
+    retryDelayMs = 2e3,
+    onRetry
+  } = options;
+  const apiBase = testnet ? WORMHOLE_API.TESTNET : WORMHOLE_API.MAINNET;
+  const normalizedEmitter = normalizeEmitterAddress(emitterAddress);
+  const url = `${apiBase}/api/v1/vaas/${emitterChain}/${normalizedEmitter}/${sequence.toString()}`;
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      const response = await fetch(url);
+      if (response.ok) {
+        const data = await response.json();
+        if (data.data?.vaa) {
+          return data.data.vaa;
+        }
+      }
+      if (i < maxRetries - 1) {
+        onRetry?.(i + 1, maxRetries);
+        await sleep(retryDelayMs);
+      }
+    } catch {
+      if (i < maxRetries - 1) {
+        onRetry?.(i + 1, maxRetries);
+        await sleep(retryDelayMs);
+      }
+    }
+  }
+  throw new Error(`Failed to fetch VAA after ${maxRetries} attempts`);
+}
+async function fetchVAAByTxHash(txHash, options = {}) {
+  const {
+    testnet = true,
+    maxRetries = 60,
+    retryDelayMs = 3e3,
+    onRetry
+  } = options;
+  const apiBase = testnet ? WORMHOLE_API.TESTNET : WORMHOLE_API.MAINNET;
+  const cleanTxHash = txHash.replace(/^0x/, "");
+  const url = `${apiBase}/api/v1/operations?txHash=${cleanTxHash}`;
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      const response = await fetch(url);
+      if (response.ok) {
+        const data = await response.json();
+        if (data.operations && data.operations.length > 0) {
+          const operation = data.operations[0];
+          if (operation.vaa?.raw) {
+            return operation.vaa.raw;
+          }
+        }
+      }
+      if (i < maxRetries - 1) {
+        onRetry?.(i + 1, maxRetries);
+        await sleep(retryDelayMs);
+      }
+    } catch {
+      if (i < maxRetries - 1) {
+        onRetry?.(i + 1, maxRetries);
+        await sleep(retryDelayMs);
+      }
+    }
+  }
+  throw new Error(`Failed to fetch VAA after ${maxRetries} attempts`);
+}
+async function fetchVAAByTxHashFallback(txHash, options = {}) {
+  const {
+    testnet = true,
+    maxRetries = 30,
+    retryDelayMs = 2e3,
+    onRetry
+  } = options;
+  const apiBase = testnet ? WORMHOLE_API.TESTNET : WORMHOLE_API.MAINNET;
+  const url = `${apiBase}/api/v1/transactions/${txHash}`;
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      const response = await fetch(url);
+      if (response.ok) {
+        const data = await response.json();
+        if (data.data?.globalTx?.originTx?.vaaId) {
+          const vaaId = data.data.globalTx.originTx.vaaId;
+          const vaaUrl = `${apiBase}/api/v1/vaas/${vaaId}`;
+          const vaaResponse = await fetch(vaaUrl);
+          if (vaaResponse.ok) {
+            const vaaData = await vaaResponse.json();
+            if (vaaData.data?.vaa) {
+              return vaaData.data.vaa;
+            }
+          }
+        }
+      }
+      if (i < maxRetries - 1) {
+        onRetry?.(i + 1, maxRetries);
+        await sleep(retryDelayMs);
+      }
+    } catch {
+      if (i < maxRetries - 1) {
+        onRetry?.(i + 1, maxRetries);
+        await sleep(retryDelayMs);
+      }
+    }
+  }
+  throw new Error(`Failed to fetch VAA after ${maxRetries} attempts`);
+}
+function parseVAA(vaaBase64) {
+  const vaaBytes = Buffer.from(vaaBase64, "base64");
+  return parseVAABytes(vaaBytes);
+}
+function parseVAABytes(vaaBytes) {
+  let offset = 0;
+  const version = vaaBytes.readUInt8(offset);
+  offset += 1;
+  const guardianSetIndex = vaaBytes.readUInt32BE(offset);
+  offset += 4;
+  const numSignatures = vaaBytes.readUInt8(offset);
+  offset += 1;
+  const signatures = [];
+  for (let i = 0; i < numSignatures; i++) {
+    const guardianIndex = vaaBytes.readUInt8(offset);
+    offset += 1;
+    const signature = "0x" + vaaBytes.subarray(offset, offset + 65).toString("hex");
+    offset += 65;
+    signatures.push({ guardianIndex, signature });
+  }
+  const bodyOffset = offset;
+  const timestamp = vaaBytes.readUInt32BE(offset);
+  offset += 4;
+  const nonce = vaaBytes.readUInt32BE(offset);
+  offset += 4;
+  const emitterChain = vaaBytes.readUInt16BE(offset);
+  offset += 2;
+  const emitterAddress = "0x" + vaaBytes.subarray(offset, offset + 32).toString("hex");
+  offset += 32;
+  const sequence = vaaBytes.readBigUInt64BE(offset);
+  offset += 8;
+  const consistencyLevel = vaaBytes.readUInt8(offset);
+  offset += 1;
+  const payload = "0x" + vaaBytes.subarray(offset).toString("hex");
+  const body = vaaBytes.subarray(bodyOffset);
+  const hash = import_ethers.ethers.keccak256(import_ethers.ethers.keccak256(body));
+  return {
+    version,
+    guardianSetIndex,
+    signatures,
+    timestamp,
+    nonce,
+    emitterChain,
+    emitterAddress,
+    sequence,
+    consistencyLevel,
+    payload,
+    hash
+  };
+}
+function parseVeridexPayload(payloadHex) {
+  const payload = Buffer.from(payloadHex.replace("0x", ""), "hex");
+  let offset = 0;
+  const version = payload.readUInt8(offset);
+  offset += 1;
+  const userKeyHash = "0x" + payload.subarray(offset, offset + 32).toString("hex");
+  offset += 32;
+  const targetChain = payload.readUInt16BE(offset);
+  offset += 2;
+  const nonce = BigInt("0x" + payload.subarray(offset, offset + 32).toString("hex"));
+  offset += 32;
+  const publicKeyX = BigInt("0x" + payload.subarray(offset, offset + 32).toString("hex"));
+  offset += 32;
+  const publicKeyY = BigInt("0x" + payload.subarray(offset, offset + 32).toString("hex"));
+  offset += 32;
+  const actionPayload = "0x" + payload.subarray(offset).toString("hex");
+  return {
+    version,
+    userKeyHash,
+    targetChain,
+    nonce,
+    publicKeyX,
+    publicKeyY,
+    actionPayload
+  };
+}
+function encodeVAAToBytes(vaaBase64) {
+  const vaaBytes = Buffer.from(vaaBase64, "base64");
+  return "0x" + vaaBytes.toString("hex");
+}
+function encodeVAAForSolana(vaaBase64) {
+  return new Uint8Array(Buffer.from(vaaBase64, "base64"));
+}
+function normalizeEmitterAddress(address) {
+  let hex = address.replace("0x", "");
+  while (hex.length < 64) {
+    hex = "0" + hex;
+  }
+  return hex;
+}
+function emitterToEvmAddress(emitterHex) {
+  const hex = emitterHex.replace("0x", "");
+  return "0x" + hex.slice(-40);
+}
+async function getSequenceFromTxReceipt(provider, txHash, wormholeCoreBridge) {
+  const receipt = await provider.getTransactionReceipt(txHash);
+  if (!receipt) {
+    throw new Error(`Transaction receipt not found: ${txHash}`);
+  }
+  const LOG_MESSAGE_PUBLISHED_TOPIC = import_ethers.ethers.id(
+    "LogMessagePublished(address,uint64,uint32,bytes,uint8)"
+  );
+  for (const log of receipt.logs) {
+    if (log.address.toLowerCase() === wormholeCoreBridge.toLowerCase()) {
+      if (log.topics[0] === LOG_MESSAGE_PUBLISHED_TOPIC && log.topics[1]) {
+        const sequence = BigInt(log.topics[1]);
+        return sequence;
+      }
+    }
+  }
+  throw new Error("LogMessagePublished event not found in transaction");
+}
+async function waitForGuardianSignatures(emitterChain, emitterAddress, sequence, options = {}) {
+  const {
+    testnet = true,
+    requiredSignatures = testnet ? GUARDIAN_CONFIG.TESTNET_QUORUM : GUARDIAN_CONFIG.MAINNET_QUORUM,
+    maxWaitMs = 12e4,
+    checkIntervalMs = 5e3,
+    onProgress
+  } = options;
+  const startTime = Date.now();
+  while (Date.now() - startTime < maxWaitMs) {
+    try {
+      const vaaBase64 = await fetchVAA(emitterChain, emitterAddress, sequence, {
+        testnet,
+        maxRetries: 1,
+        retryDelayMs: 0
+      });
+      const vaa = parseVAA(vaaBase64);
+      onProgress?.(vaa.signatures.length, requiredSignatures);
+      if (vaa.signatures.length >= requiredSignatures) {
+        return vaa;
+      }
+    } catch {
+    }
+    await sleep(checkIntervalMs);
+  }
+  throw new Error(`Timeout waiting for guardian signatures after ${maxWaitMs / 1e3}s`);
+}
+function getWormholeCoreBridge(wormholeChainId, testnet = true) {
+  const testnetBridges = {
+    10004: "0x79A1027a6A159502049F10906D333EC57E95F083",
+    // Base Sepolia
+    10005: "0x31377888146f3253211EFEf5c676D41ECe7D58Fe",
+    // Optimism Sepolia
+    10003: "0x6b9C8671cdDC8dEab9c719bB87cBd3e782bA6a35",
+    // Arbitrum Sepolia
+    1: "3u8hJUVTA4jH1wYAyUur7FFZVQ8H635K3tSHHF4ssjQ5",
+    // Solana Devnet
+    22: "0x5bc11445584a763c1fa7ed39081f1b920954da14e04b32440cba863d03e19625",
+    // Aptos Testnet
+    21: "0x31358d198147da50db32eda2562951d53973a0c0ad5ed738e9b17d88b213d790"
+    // Sui Testnet
+  };
+  const mainnetBridges = {
+    2: "0x98f3c9e6E3fAce36bAAd05FE09d375Ef1464288B",
+    // Ethereum
+    30: "0xbebdb6C8ddC678FfA9f8748f85C815C556Dd8ac6",
+    // Base
+    24: "0xEe91C335eab126dF5fDB3797EA9d6aD93aeC9722",
+    // Optimism
+    23: "0xa5f208e072434bC67592E4C49C1B991BA79BCA46",
+    // Arbitrum
+    5: "0x7A4B5a56256163F07b2C80A7cA55aBE66c4ec4d7",
+    // Polygon
+    1: "worm2ZoG2kUd4vFXhvjh93UUH596ayRfgQ2MgjNMTth",
+    // Solana
+    22: "0x5bc11445584a763c1fa7ed39081f1b920954da14e04b32440cba863d03e19625",
+    // Aptos
+    21: "0xaeab97f96cf9877fee2883315d459552b2b921edc16d7ceac6eab944dd88919c"
+    // Sui
+  };
+  const bridges = testnet ? testnetBridges : mainnetBridges;
+  return bridges[wormholeChainId] ?? "";
+}
+function getWormholeTokenBridge(wormholeChainId, testnet = true) {
+  const testnetBridges = {
+    10004: "0x86F55A04690fd7815A3D802bD587e83eA888B239",
+    // Base Sepolia
+    10005: "0x99737Ec4B815d816c49A385943baf0380e75c0Ac",
+    // Optimism Sepolia
+    10003: "0xC7A204bDBFe983FCD8d8E61D02b475D4073fF97e"
+    // Arbitrum Sepolia
+  };
+  const mainnetBridges = {
+    2: "0x3ee18B2214AFF97000D974cf647E7C347E8fa585",
+    // Ethereum
+    30: "0x8d2de8d2f73F1F4cAB472AC9A881C9b123C79627",
+    // Base
+    24: "0x1D68124e65faFC907325e3EDbF8c4d84499DAa8b",
+    // Optimism
+    23: "0x0b2402144Bb366A632D14B83F244D2e0e21bD39c",
+    // Arbitrum
+    5: "0x5a58505a96D1dbf8dF91cB21B54419FC36e93fdE"
+    // Polygon
+  };
+  const bridges = testnet ? testnetBridges : mainnetBridges;
+  return bridges[wormholeChainId] ?? "";
+}
+function getWormholeRelayer(wormholeChainId, testnet = true) {
+  const testnetRelayers = {
+    10004: "0x93BAD53DDfB6132b0aC8E37f6029163E63372cEE",
+    // Base Sepolia
+    10005: "0x93BAD53DDfB6132b0aC8E37f6029163E63372cEE",
+    // Optimism Sepolia
+    10003: "0x7B1bD7a6b4E61c2a123AC6BC2cbfC614437D0470"
+    // Arbitrum Sepolia
+  };
+  const mainnetRelayers = {
+    2: "0x27428DD2d3DD32A4D7f7C497eAaa23130d894911",
+    // Ethereum
+    30: "0x706F82e9bb5b0813501714Ab5974216704980e31",
+    // Base
+    24: "0x27428DD2d3DD32A4D7f7C497eAaa23130d894911",
+    // Optimism
+    23: "0x27428DD2d3DD32A4D7f7C497eAaa23130d894911",
+    // Arbitrum
+    5: "0x27428DD2d3DD32A4D7f7C497eAaa23130d894911"
+    // Polygon
+  };
+  const relayers = testnet ? testnetRelayers : mainnetRelayers;
+  return relayers[wormholeChainId] ?? "";
+}
+function supportsRelayer(wormholeChainId, testnet = true) {
+  return getWormholeRelayer(wormholeChainId, testnet) !== "";
+}
+function getChainName(wormholeChainId) {
+  const names = {
+    1: "Solana",
+    2: "Ethereum",
+    4: "BSC",
+    5: "Polygon",
+    6: "Avalanche",
+    10: "Fantom",
+    21: "Sui",
+    22: "Aptos",
+    23: "Arbitrum",
+    24: "Optimism",
+    30: "Base",
+    10002: "Sepolia",
+    10003: "Arbitrum Sepolia",
+    10004: "Base Sepolia",
+    10005: "Optimism Sepolia"
+  };
+  return names[wormholeChainId] ?? `Chain ${wormholeChainId}`;
+}
+function hasQuorum(vaa, testnet = true) {
+  const required = testnet ? GUARDIAN_CONFIG.TESTNET_QUORUM : GUARDIAN_CONFIG.MAINNET_QUORUM;
+  return vaa.signatures.length >= required;
+}
+function validateEmitter(vaa, expectedChain, expectedAddress) {
+  const normalizedExpected = "0x" + normalizeEmitterAddress(expectedAddress);
+  return vaa.emitterChain === expectedChain && vaa.emitterAddress.toLowerCase() === normalizedExpected.toLowerCase();
+}
+function evmAddressToBytes32(address) {
+  const hex = address.replace("0x", "").toLowerCase();
+  return "0x" + hex.padStart(64, "0");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONSISTENCY_LEVELS,
+  GUARDIAN_CONFIG,
+  emitterToEvmAddress,
+  encodeVAAForSolana,
+  encodeVAAToBytes,
+  evmAddressToBytes32,
+  fetchVAA,
+  fetchVAAByTxHash,
+  fetchVAAByTxHashFallback,
+  getChainName,
+  getSequenceFromTxReceipt,
+  getWormholeCoreBridge,
+  getWormholeRelayer,
+  getWormholeTokenBridge,
+  hasQuorum,
+  normalizeEmitterAddress,
+  parseVAA,
+  parseVAABytes,
+  parseVeridexPayload,
+  supportsRelayer,
+  validateEmitter,
+  waitForGuardianSignatures
+});
+//# sourceMappingURL=wormhole.js.map