@gala-chain/launchpad-sdk 5.0.4-beta.6 → 5.0.4-beta.60

package/dist/bridge/constants/tokens.d.ts

@@ -0,0 +1,212 @@
+/**
+ * Bridge Token Constants
+ *
+ * Static token configurations and chain IDs for bridging.
+ */
+import type { BridgeTokenDescriptor, BridgeTokenMetadata, EthereumTokenConfig, SolanaTokenConfig } from '../types/bridge.dto.js';
+/**
+ * Chain IDs used by the external bridge system (Ethereum/Solana)
+ */
+export declare const CHAIN_IDS: {
+    readonly GALA_CHAIN: 1;
+    readonly ETHEREUM: 2;
+    readonly SOLANA: 1002;
+};
+/**
+ * Internal GalaChain Channel IDs (for wrap/unwrap operations)
+ *
+ * Different from external CHAIN_IDS used for Ethereum/Solana bridges.
+ * These represent internal GalaChain channels for cross-channel token transfers.
+ *
+ * @example
+ * ```typescript
+ * // Wrap: MUSIC (music channel) → GMUSIC (asset channel)
+ * destinationChainId: GALACHAIN_CHANNELS.ASSET
+ *
+ * // Unwrap: GMUSIC (asset channel) → MUSIC (music channel)
+ * destinationChainId: GALACHAIN_CHANNELS.MUSIC
+ * ```
+ */
+export declare const GALACHAIN_CHANNELS: {
+    /** Asset channel - where wrapped tokens (GMUSIC, GWETH, GALA, etc.) live */
+    readonly ASSET: 1;
+    /** Music channel - where native MUSIC token lives (legacy) */
+    readonly MUSIC: 3;
+};
+/** Type for internal GalaChain channel IDs */
+export type GalaChainChannel = (typeof GALACHAIN_CHANNELS)[keyof typeof GALACHAIN_CHANNELS];
+/**
+ * Check if a number is a valid GalaChain channel ID
+ *
+ * @param channel - Channel ID to validate
+ * @returns True if valid GalaChain channel
+ */
+export declare function isValidGalaChainChannel(channel: number): channel is GalaChainChannel;
+/**
+ * Rate limit for GalaConnect API (requests per second)
+ */
+export declare const DEFAULT_RATE_LIMIT_RPS = 12;
+/**
+ * Default polling interval for bridge status (15 seconds)
+ */
+export declare const DEFAULT_POLL_INTERVAL_MS = 15000;
+/**
+ * Default polling timeout (45 minutes)
+ */
+export declare const DEFAULT_POLL_TIMEOUT_MS: number;
+/**
+ * Delay before registering inbound bridge transactions (30 seconds)
+ */
+export declare const REGISTRATION_DELAY_MS = 30000;
+/**
+ * Solana compute budget settings
+ */
+export declare const SOLANA_COMPUTE: {
+    readonly UNIT_LIMIT: 200000;
+    readonly UNIT_PRICE_MICROLAMPORTS: 375000;
+};
+/**
+ * Default Ethereum RPC URL (public endpoint)
+ *
+ * **WARNING: Public RPC Endpoint Limitations**
+ *
+ * This is a free public endpoint with the following limitations:
+ * - **Rate Limits**: Typically 10-25 requests/second (varies by provider load)
+ * - **Reliability**: No SLA, may experience downtime during high network activity
+ * - **Privacy**: Requests may be logged by the provider
+ * - **Features**: May not support all RPC methods (e.g., trace_* calls)
+ * - **Monitoring**: No error tracking, request analytics, or debugging tools available
+ *
+ * **For Production Use**, provide your own RPC URL from:
+ * - Infura: https://infura.io (free tier: 100k requests/day)
+ * - Alchemy: https://alchemy.com (free tier: 300M compute units/month)
+ * - QuickNode: https://quicknode.com
+ * - Your own Ethereum node
+ *
+ * @example
+ * ```typescript
+ * const bridgeService = new BridgeService({
+ *   ethereumRpcUrl: 'https://mainnet.infura.io/v3/YOUR_API_KEY',
+ *   // ... other config
+ * });
+ * ```
+ */
+export declare const DEFAULT_ETHEREUM_RPC_URL = "https://ethereum.publicnode.com";
+/**
+ * Default Solana RPC URL (public endpoint)
+ *
+ * **WARNING: Public RPC Endpoint Limitations**
+ *
+ * This is the official Solana public RPC with the following limitations:
+ * - **Rate Limits**: Aggressive rate limiting (may return 429 errors under load)
+ * - **Reliability**: Best-effort availability, no SLA
+ * - **Performance**: Higher latency than dedicated endpoints
+ * - **Features**: Some methods may be disabled or limited
+ * - **Monitoring**: No error tracking, request analytics, or debugging tools available
+ *
+ * **For Production Use**, provide your own RPC URL from:
+ * - Helius: https://helius.dev (free tier: 500k credits/month)
+ * - QuickNode: https://quicknode.com
+ * - Triton: https://triton.one
+ * - Your own Solana validator
+ *
+ * @example
+ * ```typescript
+ * const bridgeService = new BridgeService({
+ *   solanaRpcUrl: 'https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY',
+ *   // ... other config
+ * });
+ * ```
+ */
+export declare const DEFAULT_SOLANA_RPC_URL = "https://api.mainnet-beta.solana.com";
+/**
+ * Default Ethereum bridge contract address (mainnet)
+ */
+export declare const DEFAULT_ETHEREUM_BRIDGE_CONTRACT = "0x9f452b7cC24e6e6FA690fe77CF5dD2ba3DbF1ED9";
+/**
+ * Ethereum bridge contract address for Sepolia testnet
+ */
+export declare const ETHEREUM_BRIDGE_CONTRACT_SEPOLIA = "0x6a1734E09f3099a3675645D214ce547080ea67e0";
+/**
+ * Default Solana bridge program ID (mainnet)
+ */
+export declare const DEFAULT_SOLANA_BRIDGE_PROGRAM = "AaE4dTnL75XqgUJpdxBKg6vS9sTJgBPJwBQRVhD29WwS";
+/**
+ * GalaConnect production base URL (DEX API platform)
+ */
+export declare const GALACONNECT_PRODUCTION_URL = "https://dex-api-platform-dex-prod-gala.gala.com";
+/**
+ * Ethereum tokens for bridging - Production (Mainnet)
+ */
+export declare const ETHEREUM_TOKENS_PROD: EthereumTokenConfig[];
+/**
+ * Ethereum tokens for bridging - Stage (Sepolia testnet)
+ *
+ * Note: GWTRX is not available on Sepolia
+ */
+export declare const ETHEREUM_TOKENS_STAGE: EthereumTokenConfig[];
+/** Bridge environment type for token selection */
+export type BridgeEnvironment = 'PROD' | 'STAGE';
+/**
+ * Get Ethereum tokens by environment
+ *
+ * @param environment - Target environment (PROD or STAGE)
+ * @returns Token configurations for the specified environment
+ */
+export declare function getEthereumTokensByEnvironment(environment: BridgeEnvironment): EthereumTokenConfig[];
+/**
+ * Get Ethereum bridge contract address by environment
+ *
+ * @param environment - Target environment (PROD or STAGE)
+ * @returns Bridge contract address for the specified environment
+ */
+export declare function getEthereumBridgeContractByEnvironment(environment: BridgeEnvironment): string;
+/**
+ * Default supported Ethereum tokens for bridging (Production/Mainnet)
+ *
+ * @deprecated Use `getEthereumTokensByEnvironment()` for environment-aware token selection
+ */
+export declare const DEFAULT_ETHEREUM_TOKENS: EthereumTokenConfig[];
+/**
+ * Default supported Solana tokens for bridging
+ */
+export declare const DEFAULT_SOLANA_TOKENS: SolanaTokenConfig[];
+/**
+ * Static token metadata for common bridge tokens
+ *
+ * This avoids API calls for well-known tokens.
+ */
+export declare const STATIC_TOKEN_METADATA: Record<string, BridgeTokenMetadata>;
+/**
+ * Ethereum ERC-20 ABI for bridge operations
+ */
+export declare const ERC20_ABI: readonly ["function decimals() view returns (uint8)", "function balanceOf(address owner) view returns (uint256)", "function approve(address spender, uint256 value) returns (bool)", "function allowance(address owner, address spender) view returns (uint256)", "function transfer(address to, uint256 value) returns (bool)", "function name() view returns (string)", "function nonces(address owner) view returns (uint256)", "function permit(address owner,address spender,uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s)"];
+/**
+ * Ethereum bridge contract ABI
+ */
+export declare const BRIDGE_CONTRACT_ABI: readonly ["function bridgeOut(address token,uint256 amount,uint256 tokenId,uint16 destinationChainId,bytes recipient) external", "function bridgeOutWithPermit(address token,uint256 amount,uint16 destinationChainId,bytes recipient,uint256 deadline,uint8 v,bytes32 r,bytes32 s) external"];
+/**
+ * Solana bridge instruction discriminators
+ */
+export declare const SOLANA_DISCRIMINATORS: {
+    readonly BRIDGE_OUT: Buffer<ArrayBuffer>;
+    readonly BRIDGE_OUT_NATIVE: Buffer<ArrayBuffer>;
+};
+/**
+ * Get token metadata by symbol
+ */
+export declare function getStaticTokenMetadata(symbol: string): BridgeTokenMetadata | undefined;
+/**
+ * Get Ethereum token config by symbol
+ */
+export declare function getEthereumTokenConfig(symbol: string): EthereumTokenConfig | undefined;
+/**
+ * Get Solana token config by symbol
+ */
+export declare function getSolanaTokenConfig(symbol: string): SolanaTokenConfig | undefined;
+/**
+ * Format a BridgeTokenDescriptor as a pipe-separated string
+ * Uses centralized stringification from token-stringification.ts
+ */
+export declare function formatTokenDescriptor(descriptor: BridgeTokenDescriptor): string;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/bridge/constants/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../../src/bridge/constants/tokens.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EACV,qBAAqB,EACrB,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,wBAAwB,CAAC;AAEhC;;GAEG;AACH,eAAO,MAAM,SAAS;;;;CAIZ,CAAC;AAEX;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kBAAkB;IAC7B,4EAA4E;;IAE5E,8DAA8D;;CAEtD,CAAC;AAEX,8CAA8C;AAC9C,MAAM,MAAM,gBAAgB,GAC1B,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAC;AAE/D;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,GACd,OAAO,IAAI,gBAAgB,CAI7B;AAED;;GAEG;AACH,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC;;GAEG;AACH,eAAO,MAAM,wBAAwB,QAAS,CAAC;AAE/C;;GAEG;AACH,eAAO,MAAM,uBAAuB,QAAkB,CAAC;AAEvD;;GAEG;AACH,eAAO,MAAM,qBAAqB,QAAS,CAAC;AAE5C;;GAEG;AACH,eAAO,MAAM,cAAc;;;CAGjB,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,wBAAwB,oCAAoC,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,sBAAsB,wCAAwC,CAAC;AAE5E;;GAEG;AACH,eAAO,MAAM,gCAAgC,+CAA+C,CAAC;AAE7F;;GAEG;AACH,eAAO,MAAM,gCAAgC,+CAA+C,CAAC;AAE7F;;GAEG;AACH,eAAO,MAAM,6BAA6B,iDAAiD,CAAC;AAE5F;;GAEG;AACH,eAAO,MAAM,0BAA0B,oDAAoD,CAAC;AAE5F;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,mBAAmB,EA2CrD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,EAoCtD,CAAC;AAEF,kDAAkD;AAClD,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,OAAO,CAAC;AAEjD;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC5C,WAAW,EAAE,iBAAiB,GAC7B,mBAAmB,EAAE,CAEvB;AAED;;;;;GAKG;AACH,wBAAgB,sCAAsC,CACpD,WAAW,EAAE,iBAAiB,GAC7B,MAAM,CAIR;AAED;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,EAAyB,CAAC;AAEnF;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAE,iBAAiB,EAepD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAoCrE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS,ihBASZ,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,mBAAmB,gSAGtB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;CAGxB,CAAC;AAEX;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAgBtF;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAKtF;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAKlF;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,qBAAqB,GAAG,MAAM,CAE/E"}

package/dist/bridge/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Bridge Module
+ *
+ * Cross-chain bridging capabilities for GalaChain.
+ * Supports bridging between:
+ * - GalaChain ↔ Ethereum (6 tokens)
+ * - GalaChain ↔ Solana (2 tokens)
+ *
+ * @module bridge
+ */
+export { type BridgeEnvironment, BridgeService, type BridgeServiceConfig } from './BridgeService.js';
+export { GalaConnectClient, GalaConnectHttpError } from './GalaConnectClient.js';
+export { BaseBridgeStrategy, type BridgeStrategy, type WaitOptions, } from './strategies/BridgeStrategy.js';
+export { type EthereumBridgeConfig, EthereumBridgeStrategy, } from './strategies/EthereumBridgeStrategy.js';
+export { type SolanaBridgeConfig, SolanaBridgeStrategy, } from './strategies/SolanaBridgeStrategy.js';
+export type { BaseTokenCrossRate, BridgeConfig, BridgeConfigurationToken, BridgeFeeEstimate, BridgeFeeResponse, BridgeInParams, BridgeLegResult, BridgeOutParams, BridgeRequestDto, BridgeStatus, BridgeStatusResponse, BridgeToken, BridgeTokenDescriptor, BridgeTokenInstance, BridgeTokenOutResponse, BridgeTransaction, BridgeTransactionRegistrationResponse, DestinationChainTxFee, EstimateBridgeFeeParams, EthereumTokenConfig, EthereumTransactionStatus, EthereumWalletBalanceResult, ExternalChainBalance, ExternalNetwork, ExternalTokenInfo, FetchBalancesResponse, GalaConnectConfig, GalaExchangeCrossRate, GalaExchangeRate, QuoteTokenCrossRate, RequestBridgeOutResponse, SolanaTokenConfig, SolanaTransactionStatus, SolanaWalletBalanceResult, TokenBalanceEntry, TokenRoundTripResult, WaitForBridgeOptions, } from './types/index.js';
+export { BridgeStatusCode } from './types/index.js';
+export { CROSS_RATE_TYPED_DATA_TYPES, GALA_BRIDGE_TYPED_DATA_DOMAIN, getGalaBridgeTypedDataTypes, LEGACY_TYPED_DATA_TYPES, } from './types/eip712.js';
+export { BRIDGE_CONTRACT_ABI, CHAIN_IDS, DEFAULT_ETHEREUM_BRIDGE_CONTRACT, DEFAULT_ETHEREUM_RPC_URL, DEFAULT_ETHEREUM_TOKENS, DEFAULT_POLL_INTERVAL_MS, DEFAULT_POLL_TIMEOUT_MS, DEFAULT_RATE_LIMIT_RPS, DEFAULT_SOLANA_BRIDGE_PROGRAM, DEFAULT_SOLANA_RPC_URL, DEFAULT_SOLANA_TOKENS, ERC20_ABI, ETHEREUM_BRIDGE_CONTRACT_SEPOLIA, ETHEREUM_TOKENS_PROD, ETHEREUM_TOKENS_STAGE, formatTokenDescriptor, GALACONNECT_PRODUCTION_URL, getEthereumBridgeContractByEnvironment, getEthereumTokenConfig, getEthereumTokensByEnvironment, getSolanaTokenConfig, getStaticTokenMetadata, SOLANA_COMPUTE, SOLANA_DISCRIMINATORS, STATIC_TOKEN_METADATA, } from './constants/index.js';
+export { stripHexPrefix } from './utils/address-formatter.js';
+export { RateLimiter } from './utils/RateLimiter.js';
+export { isTokenClassKey, type ParsedTokenId, parseTokenId, parseTokenString, stringifyTokenClassKey, } from './utils/tokenIdUtils.js';
+export { compareAmounts, formatTokenAmount, fromBaseUnits, toBaseUnits, } from './utils/tokenMath.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/bridge/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bridge/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EAAE,KAAK,iBAAiB,EAAC,aAAa,EAAE,KAAK,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAGpG,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAGjF,OAAO,EACL,kBAAkB,EAClB,KAAK,cAAc,EACnB,KAAK,WAAW,GACjB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,KAAK,oBAAoB,EACzB,sBAAsB,GACvB,MAAM,wCAAwC,CAAC;AAChD,OAAO,EACL,KAAK,kBAAkB,EACvB,oBAAoB,GACrB,MAAM,sCAAsC,CAAC;AAG9C,YAAY,EACV,kBAAkB,EAClB,YAAY,EACZ,wBAAwB,EACxB,iBAAiB,EACjB,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,eAAe,EACf,gBAAgB,EAChB,YAAY,EACZ,oBAAoB,EACpB,WAAW,EACX,qBAAqB,EACrB,mBAAmB,EACnB,sBAAsB,EACtB,iBAAiB,EACjB,qCAAqC,EACrC,qBAAqB,EACrB,uBAAuB,EACvB,mBAAmB,EAEnB,yBAAyB,EACzB,2BAA2B,EAE3B,oBAAoB,EACpB,eAAe,EACf,iBAAiB,EACjB,qBAAqB,EACrB,iBAAiB,EACjB,qBAAqB,EACrB,gBAAgB,EAChB,mBAAmB,EACnB,wBAAwB,EACxB,iBAAiB,EACjB,uBAAuB,EACvB,yBAAyB,EACzB,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAGpD,OAAO,EACL,2BAA2B,EAC3B,6BAA6B,EAC7B,2BAA2B,EAC3B,uBAAuB,GACxB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,mBAAmB,EACnB,SAAS,EACT,gCAAgC,EAChC,wBAAwB,EACxB,uBAAuB,EACvB,wBAAwB,EACxB,uBAAuB,EACvB,sBAAsB,EACtB,6BAA6B,EAC7B,sBAAsB,EACtB,qBAAqB,EACrB,SAAS,EACT,gCAAgC,EAEhC,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,EACrB,0BAA0B,EAC1B,sCAAsC,EACtC,sBAAsB,EACtB,8BAA8B,EAC9B,oBAAoB,EACpB,sBAAsB,EACtB,cAAc,EACd,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EACL,eAAe,EACf,KAAK,aAAa,EAClB,YAAY,EACZ,gBAAgB,EAChB,sBAAsB,GACvB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,cAAc,EACd,iBAAiB,EACjB,aAAa,EACb,WAAW,GACZ,MAAM,sBAAsB,CAAC"}

package/dist/bridge/strategies/BridgeStrategy.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Bridge Strategy Interface
+ *
+ * Defines the contract for chain-specific bridge implementations.
+ * Each external chain (Ethereum, Solana) implements this interface
+ * to handle its unique signing, transaction, and status tracking logic.
+ */
+import { type BridgeFeeEstimate, type BridgeInParams, type BridgeOutParams, type BridgeStatus, type BridgeTransaction, type ExternalNetwork } from '../types/index.js';
+/**
+ * Strategy interface for chain-specific bridge operations.
+ *
+ * The Bridge SDK uses the Strategy pattern to abstract chain-specific logic:
+ * - EthereumBridgeStrategy: Handles ERC-20 approvals, ethers.js signing
+ * - SolanaBridgeStrategy: Handles SPL token accounts, @solana/web3.js signing
+ *
+ * Each strategy encapsulates:
+ * - Fee estimation for the target chain
+ * - Outbound transfers (GalaChain → External)
+ * - Inbound transfers (External → GalaChain)
+ * - Status polling and transaction tracking
+ *
+ * @example
+ * ```typescript
+ * class EthereumBridgeStrategy implements BridgeStrategy {
+ *   readonly network: ExternalNetwork = 'Ethereum';
+ *
+ *   async estimateFee(tokenSymbol: string, amount: string): Promise<BridgeFeeEstimate> {
+ *     // Ethereum-specific fee calculation
+ *   }
+ * }
+ * ```
+ */
+export interface BridgeStrategy {
+    /**
+     * The external network this strategy handles.
+     */
+    readonly network: ExternalNetwork;
+    /**
+     * Estimate bridge fees for a transfer.
+     *
+     * Calculates the total cost including:
+     * - Bridge protocol fee (paid to GalaChain)
+     * - Network gas fee (estimated)
+     * - Any chain-specific fees
+     *
+     * @param tokenSymbol - Token symbol (e.g., 'GALA', 'GUSDC')
+     * @param amount - Amount in decimal format (e.g., '100.5')
+     * @returns Fee estimate with breakdown
+     */
+    estimateFee(tokenSymbol: string, amount: string): Promise<BridgeFeeEstimate>;
+    /**
+     * Bridge tokens OUT from GalaChain to external chain.
+     *
+     * Flow:
+     * 1. Lock tokens on GalaChain (via GalaConnect)
+     * 2. Wait for bridge confirmation
+     * 3. Receive wrapped tokens on external chain
+     *
+     * @param params - Bridge out parameters
+     * @returns Transaction details with tracking info
+     */
+    bridgeOut(params: BridgeOutParams): Promise<BridgeTransaction>;
+    /**
+     * Bridge tokens IN from external chain to GalaChain.
+     *
+     * Flow:
+     * 1. Approve bridge contract (if needed)
+     * 2. Deposit tokens to bridge contract
+     * 3. Wait for GalaChain confirmation
+     * 4. Receive native tokens on GalaChain
+     *
+     * @param params - Bridge in parameters
+     * @returns Transaction details with tracking info
+     */
+    bridgeIn(params: BridgeInParams): Promise<BridgeTransaction>;
+    /**
+     * Get the current status of a bridge transaction.
+     *
+     * Polls both the source and destination chains to determine
+     * the transaction's progress through the bridge.
+     *
+     * @param transactionHash - The bridge transaction hash
+     * @returns Current status with details
+     */
+    getStatus(transactionHash: string): Promise<BridgeStatus>;
+    /**
+     * Wait for a bridge transaction to complete.
+     *
+     * Polls the transaction status until it reaches a terminal state
+     * (completed or failed) or the timeout is reached.
+     *
+     * @param transactionHash - The bridge transaction hash
+     * @param options - Polling options
+     * @returns Final status when complete
+     * @throws Error if timeout reached or transaction fails
+     */
+    waitForCompletion(transactionHash: string, options?: WaitOptions): Promise<BridgeStatus>;
+    /**
+     * Get the list of supported tokens for this chain.
+     *
+     * @returns Array of token symbols supported by this bridge
+     */
+    getSupportedTokens(): string[];
+    /**
+     * Check if a specific token is supported for bridging.
+     *
+     * @param tokenSymbol - Token symbol to check
+     * @returns True if token can be bridged
+     */
+    isTokenSupported(tokenSymbol: string): boolean;
+    /**
+     * Validate a recipient address for the external chain.
+     *
+     * @param address - Address to validate
+     * @returns True if address is valid for this chain
+     */
+    isValidAddress(address: string): boolean;
+}
+/**
+ * Options for waiting on bridge completion.
+ */
+export interface WaitOptions {
+    /**
+     * Polling interval in milliseconds.
+     * @default 15000 (15 seconds)
+     */
+    pollInterval?: number;
+    /**
+     * Maximum time to wait in milliseconds.
+     * @default 2700000 (45 minutes)
+     */
+    timeout?: number;
+    /**
+     * Callback for status updates during polling.
+     */
+    onStatusUpdate?: (status: BridgeStatus) => void;
+}
+/**
+ * Base class providing common functionality for bridge strategies.
+ *
+ * Concrete strategies extend this class and implement chain-specific logic.
+ */
+export declare abstract class BaseBridgeStrategy implements BridgeStrategy {
+    abstract readonly network: ExternalNetwork;
+    abstract estimateFee(tokenSymbol: string, amount: string): Promise<BridgeFeeEstimate>;
+    abstract bridgeOut(params: BridgeOutParams): Promise<BridgeTransaction>;
+    abstract bridgeIn(params: BridgeInParams): Promise<BridgeTransaction>;
+    abstract getStatus(transactionHash: string): Promise<BridgeStatus>;
+    abstract getSupportedTokens(): string[];
+    abstract isTokenSupported(tokenSymbol: string): boolean;
+    abstract isValidAddress(address: string): boolean;
+    /**
+     * Default implementation of waitForCompletion with polling.
+     *
+     * Strategies can override this if they have chain-specific
+     * event subscription capabilities.
+     */
+    waitForCompletion(transactionHash: string, options?: WaitOptions): Promise<BridgeStatus>;
+}
+//# sourceMappingURL=BridgeStrategy.d.ts.map

package/dist/bridge/strategies/BridgeStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BridgeStrategy.d.ts","sourceRoot":"","sources":["../../../src/bridge/strategies/BridgeStrategy.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,YAAY,EAEjB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACrB,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAElC;;;;;;;;;;;OAWG;IACH,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAE7E;;;;;;;;;;OAUG;IACH,SAAS,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAE/D;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAE7D;;;;;;;;OAQG;IACH,SAAS,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IAE1D;;;;;;;;;;OAUG;IACH,iBAAiB,CACf,eAAe,EAAE,MAAM,EACvB,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,YAAY,CAAC,CAAC;IAEzB;;;;OAIG;IACH,kBAAkB,IAAI,MAAM,EAAE,CAAC;IAE/B;;;;;OAKG;IACH,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC;IAE/C;;;;;OAKG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;CAC1C;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAC;CACjD;AAED;;;;GAIG;AACH,8BAAsB,kBAAmB,YAAW,cAAc;IAChE,QAAQ,CAAC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAE3C,QAAQ,CAAC,WAAW,CAClB,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,iBAAiB,CAAC;IAC7B,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,iBAAiB,CAAC;IACvE,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,iBAAiB,CAAC;IACrE,QAAQ,CAAC,SAAS,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAClE,QAAQ,CAAC,kBAAkB,IAAI,MAAM,EAAE;IACvC,QAAQ,CAAC,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IACvD,QAAQ,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAEjD;;;;;OAKG;IACG,iBAAiB,CACrB,eAAe,EAAE,MAAM,EACvB,OAAO,GAAE,WAAgB,GACxB,OAAO,CAAC,YAAY,CAAC;CAuCzB"}

package/dist/bridge/strategies/EthereumBridgeStrategy.d.ts

@@ -0,0 +1,200 @@
+/**
+ * Ethereum Bridge Strategy
+ *
+ * Implements bridging between GalaChain and Ethereum networks.
+ * Handles ERC-20 approvals, EIP-712 signing, and bridge contract interactions.
+ */
+import type { GalaConnectClient } from '../GalaConnectClient.js';
+import type { BridgeFeeEstimate, BridgeInParams, BridgeOutParams, BridgeStatus, BridgeTransaction, EthereumTokenConfig, EthereumTransactionStatus, ExternalNetwork } from '../types/index.js';
+import { BaseBridgeStrategy } from './BridgeStrategy.js';
+/**
+ * Configuration for Ethereum bridge strategy.
+ */
+export interface EthereumBridgeConfig {
+    /** GalaConnect API client */
+    galaConnectClient: GalaConnectClient;
+    /** GalaChain wallet address (eth|0x...) */
+    galaChainWalletAddress: string;
+    /** Ethereum private key for signing */
+    ethereumPrivateKey: string;
+    /** Ethereum RPC URL */
+    ethereumRpcUrl?: string;
+    /** Ethereum bridge contract address */
+    ethereumBridgeContract?: string;
+    /** Ethereum wallet address (derived from private key if not provided) */
+    ethereumWalletAddress?: string;
+    /** Token configurations */
+    tokenConfigs?: EthereumTokenConfig[];
+}
+/**
+ * Bridge strategy for GalaChain ↔ Ethereum transfers.
+ *
+ * Supports 6 tokens: GALA, GWETH, GUSDC, GUSDT, GWTRX, GWBTC
+ *
+ * @example
+ * ```typescript
+ * const strategy = new EthereumBridgeStrategy({
+ *   galaConnectClient,
+ *   galaChainWalletAddress: 'eth|0x1234...',
+ *   ethereumPrivateKey: '0xabcd...',
+ * });
+ *
+ * // Bridge out (GalaChain → Ethereum)
+ * const tx = await strategy.bridgeOut({
+ *   tokenSymbol: 'GALA',
+ *   amount: '100',
+ *   destinationChain: 'Ethereum',
+ *   recipientAddress: '0x5678...',
+ * });
+ * ```
+ */
+export declare class EthereumBridgeStrategy extends BaseBridgeStrategy {
+    readonly network: ExternalNetwork;
+    /**
+     * Ethereum finality threshold (number of confirmations).
+     * 12+ confirmations is the practical finality threshold for Ethereum mainnet.
+     */
+    static readonly ETHEREUM_FINALITY_THRESHOLD = 12;
+    private readonly galaConnectClient;
+    private readonly galaChainWalletAddress;
+    private readonly ethereumProvider;
+    private readonly ethereumWallet;
+    private readonly ethereumBridgeContract;
+    private readonly ethereumWalletAddress;
+    private readonly tokenConfigs;
+    private readonly tokenMetadataResolver;
+    /**
+     * Creates a new Ethereum bridge strategy.
+     *
+     * @param config - Strategy configuration
+     * @throws Error if ethereumPrivateKey is invalid format
+     */
+    constructor(config: EthereumBridgeConfig);
+    /**
+     * Estimate bridge fees for a transfer to Ethereum.
+     *
+     * @param tokenSymbol - Token symbol (e.g., 'GALA', 'GWETH')
+     * @param amount - Amount in decimal format
+     * @returns Fee estimate with breakdown
+     */
+    estimateFee(tokenSymbol: string, _amount: string): Promise<BridgeFeeEstimate>;
+    /**
+     * Bridge tokens from GalaChain to Ethereum.
+     *
+     * @param params - Bridge out parameters
+     * @returns Transaction details
+     */
+    bridgeOut(params: BridgeOutParams): Promise<BridgeTransaction>;
+    /**
+     * Bridge tokens from Ethereum to GalaChain.
+     *
+     * @param params - Bridge in parameters
+     * @returns Transaction details
+     */
+    bridgeIn(params: BridgeInParams): Promise<BridgeTransaction>;
+    /**
+     * Get the current status of a bridge transaction.
+     *
+     * @param transactionHash - Transaction hash to check
+     * @returns Current status
+     */
+    getStatus(transactionHash: string): Promise<BridgeStatus>;
+    /**
+     * Get list of supported tokens for Ethereum bridging.
+     *
+     * @returns Array of token symbols
+     */
+    getSupportedTokens(): string[];
+    /**
+     * Check if a token is supported for Ethereum bridging.
+     *
+     * @param tokenSymbol - Token symbol to check
+     * @returns True if supported
+     */
+    isTokenSupported(tokenSymbol: string): boolean;
+    /**
+     * Validate an Ethereum address.
+     *
+     * @param address - Address to validate
+     * @returns True if valid Ethereum address
+     */
+    isValidAddress(address: string): boolean;
+    /**
+     * Get the configured Ethereum wallet address.
+     *
+     * @returns Ethereum wallet address (0x format)
+     *
+     * @example
+     * ```typescript
+     * const address = strategy.getWalletAddress();
+     * console.log(`Wallet: ${address}`);
+     * ```
+     */
+    getWalletAddress(): string;
+    /**
+     * Get ERC-20 token balance for an Ethereum address.
+     *
+     * @param tokenSymbol - Token symbol (e.g., 'GALA', 'GWETH', 'GUSDC')
+     * @param address - Optional Ethereum address (defaults to configured wallet)
+     * @returns Token balance as decimal string (e.g., "123.45678901")
+     * @throws Error if token not supported or address invalid
+     *
+     * @example
+     * ```typescript
+     * const balance = await strategy.getEthereumTokenBalance('GALA');
+     * console.log(`Balance: ${balance} GALA`);
+     *
+     * // Check another address
+     * const otherBalance = await strategy.getEthereumTokenBalance('GUSDC', '0x1234...');
+     * ```
+     */
+    getEthereumTokenBalance(tokenSymbol: string, address?: string): Promise<string>;
+    /**
+     * Get native ETH balance for an Ethereum address.
+     *
+     * @param address - Optional Ethereum address (defaults to configured wallet)
+     * @returns ETH balance as decimal string (18 decimals)
+     * @throws Error if address invalid
+     *
+     * @example
+     * ```typescript
+     * const ethBalance = await strategy.getEthereumNativeBalance();
+     * console.log(`ETH Balance: ${ethBalance} ETH`);
+     * ```
+     */
+    getEthereumNativeBalance(address?: string): Promise<string>;
+    /**
+     * Get the status of an Ethereum transaction by hash.
+     *
+     * Queries Ethereum RPC directly using `getTransactionReceipt()` and `getTransaction()`.
+     * Use this to verify if a bridge or any Ethereum transaction succeeded after submission.
+     *
+     * @param transactionHash - Ethereum transaction hash (0x-prefixed, 64 hex characters)
+     * @returns Transaction status with confirmation details
+     * @throws Error if hash format is invalid
+     *
+     * @example
+     * ```typescript
+     * const status = await strategy.getEthereumTransactionStatus('0x1234...');
+     * console.log(`Status: ${status.status}`);
+     * console.log(`Confirmations: ${status.confirmations}`);
+     * if (status.status === 'finalized') {
+     *   console.log('Transaction is final (12+ confirmations)');
+     * }
+     * ```
+     */
+    getEthereumTransactionStatus(transactionHash: string): Promise<EthereumTransactionStatus>;
+    /**
+     * Execute bridge deposit on Ethereum.
+     */
+    private executeBridgeDeposit;
+    /**
+     * Bridge using ERC-20 Permit for gas-less approval.
+     */
+    private bridgeWithPermit;
+    /**
+     * Bridge using traditional ERC-20 approval.
+     */
+    private bridgeWithApproval;
+}
+//# sourceMappingURL=EthereumBridgeStrategy.d.ts.map

package/dist/bridge/strategies/EthereumBridgeStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EthereumBridgeStrategy.d.ts","sourceRoot":"","sources":["../../../src/bridge/strategies/EthereumBridgeStrategy.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAyBH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EACV,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,YAAY,EAEZ,iBAAiB,EACjB,mBAAmB,EACnB,yBAAyB,EACzB,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAoB3B,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,6BAA6B;IAC7B,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,2CAA2C;IAC3C,sBAAsB,EAAE,MAAM,CAAC;IAC/B,uCAAuC;IACvC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,uBAAuB;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,uCAAuC;IACvC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,yEAAyE;IACzE,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,2BAA2B;IAC3B,YAAY,CAAC,EAAE,mBAAmB,EAAE,CAAC;CACtC;AAWD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,sBAAuB,SAAQ,kBAAkB;IAC5D,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAc;IAE/C;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,2BAA2B,MAAM;IAEjD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAoB;IACtD,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAS;IAChD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAkB;IACnD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAe;IAC9C,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAS;IAChD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAS;IAC/C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAmC;IAChE,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAwB;IAE9D;;;;;OAKG;gBACS,MAAM,EAAE,oBAAoB;IA8BxC;;;;;;OAMG;IACG,WAAW,CACf,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,iBAAiB,CAAC;IAW7B;;;;;OAKG;IACG,SAAS,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAWpE;;;;;OAKG;IACG,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,iBAAiB,CAAC;IA2ElE;;;;;OAKG;IACG,SAAS,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAK/D;;;;OAIG;IACH,kBAAkB,IAAI,MAAM,EAAE;IAI9B;;;;;OAKG;IACH,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IAI9C;;;;;OAKG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAQxC;;;;;;;;;;OAUG;IACH,gBAAgB,IAAI,MAAM;IAQ1B;;;;;;;;;;;;;;;;OAgBG;IACG,uBAAuB,CAC3B,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC;IAyBlB;;;;;;;;;;;;OAYG;IACG,wBAAwB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAkBjE;;;;;;;;;;;;;;;;;;;OAmBG;IACG,4BAA4B,CAChC,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,yBAAyB,CAAC;IAmFrC;;OAEG;YACW,oBAAoB;IAyElC;;OAEG;YACW,gBAAgB;IAqD9B;;OAEG;YACW,kBAAkB;CA8BjC"}