Feat/verification

libs/bridge-core/dist/api.js

@@ -48,9 +48,8 @@ async function callApi(request) {
         return {
             success: false,
             error: {
-                isTransient: err.isTransient !== false, // Assume transient unless specified
+                code: err.code || 'UNKNOWN_ERROR',
                 message: err.message || 'Circuit breaker opened',
-                details: err,
             },
         };
     }
@@ -61,10 +60,10 @@ async function callApi(request) {
  */
 async function mockApiCall(request) {
     console.log(`Calling API for provider: ${request.provider.name}`);
-    if (request.provider.name === 'Stellar') {
+    if (request.provider.name === 'stellar') {
         // Consistently fail for Stellar to test circuit breaker
         const err = new Error('Transient failure');
-        err.isTransient = true;
+        err.code = 'TRANSIENT_ERROR';
         throw err;
     }
     // LayerZero will have random failures

libs/bridge-core/dist/index.d.ts

@@ -1,2 +1,55 @@
+/**
+ * @bridgewise/bridge-core
+ *
+ * Central aggregation logic for multi-chain bridge route discovery.
+ * Provides a unified interface to query routes from multiple bridge providers
+ * including Stellar/Soroban, LayerZero, and Hop Protocol.
+ */
+import { BridgeAggregator } from './aggregator';
+import type { RouteRequest } from './types';
 export * from './types';
-export * from './api';
+export type { BridgeAdapter } from './adapters/base';
+export { BaseBridgeAdapter } from './adapters/base';
+export { HopAdapter } from './adapters/hop';
+export { LayerZeroAdapter } from './adapters/layerzero';
+export { StellarAdapter } from './adapters/stellar';
+export * from './fee-estimation';
+export * from './error-codes';
+export { BridgeAggregator } from './aggregator';
+export type { AggregatorConfig } from './aggregator';
+export { BridgeValidator } from './validator';
+export type { ValidationError, ValidationResult, BridgeExecutionRequest, } from './validator';
+/**
+ * Main function to get aggregated bridge routes
+ *
+ * @example
+ * ```typescript
+ * import { getBridgeRoutes } from '@bridgewise/bridge-core';
+ *
+ * const routes = await getBridgeRoutes({
+ *   sourceChain: 'ethereum',
+ *   targetChain: 'polygon',
+ *   assetAmount: '1000000000000000000', // 1 ETH in wei
+ *   slippageTolerance: 0.5
+ * });
+ *
+ * console.log(`Found ${routes.routes.length} routes`);
+ * routes.routes.forEach(route => {
+ *   console.log(`${route.provider}: ${route.feePercentage}% fee, ${route.estimatedTime}s`);
+ * });
+ * ```
+ */
+export declare function getBridgeRoutes(request: RouteRequest, config?: {
+    providers?: {
+        hop?: boolean;
+        layerzero?: boolean;
+        stellar?: boolean;
+    };
+    layerZeroApiKey?: string;
+    timeout?: number;
+}): Promise<import("./types").AggregatedRoutes>;
+declare const _default: {
+    BridgeAggregator: typeof BridgeAggregator;
+    getBridgeRoutes: typeof getBridgeRoutes;
+};
+export default _default;

libs/bridge-core/dist/index.js

@@ -1,4 +1,11 @@
 "use strict";
+/**
+ * @bridgewise/bridge-core
+ *
+ * Central aggregation logic for multi-chain bridge route discovery.
+ * Provides a unified interface to query routes from multiple bridge providers
+ * including Stellar/Soroban, LayerZero, and Hop Protocol.
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -14,5 +21,55 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BridgeValidator = exports.BridgeAggregator = exports.StellarAdapter = exports.LayerZeroAdapter = exports.HopAdapter = exports.BaseBridgeAdapter = void 0;
+exports.getBridgeRoutes = getBridgeRoutes;
+const aggregator_1 = require("./aggregator");
+// Types
 __exportStar(require("./types"), exports);
-__exportStar(require("./api"), exports);
+var base_1 = require("./adapters/base");
+Object.defineProperty(exports, "BaseBridgeAdapter", { enumerable: true, get: function () { return base_1.BaseBridgeAdapter; } });
+var hop_1 = require("./adapters/hop");
+Object.defineProperty(exports, "HopAdapter", { enumerable: true, get: function () { return hop_1.HopAdapter; } });
+var layerzero_1 = require("./adapters/layerzero");
+Object.defineProperty(exports, "LayerZeroAdapter", { enumerable: true, get: function () { return layerzero_1.LayerZeroAdapter; } });
+var stellar_1 = require("./adapters/stellar");
+Object.defineProperty(exports, "StellarAdapter", { enumerable: true, get: function () { return stellar_1.StellarAdapter; } });
+// Fee Estimation
+__exportStar(require("./fee-estimation"), exports);
+// Error Codes and Mapping
+__exportStar(require("./error-codes"), exports);
+// Aggregator
+var aggregator_2 = require("./aggregator");
+Object.defineProperty(exports, "BridgeAggregator", { enumerable: true, get: function () { return aggregator_2.BridgeAggregator; } });
+// Validator
+var validator_1 = require("./validator");
+Object.defineProperty(exports, "BridgeValidator", { enumerable: true, get: function () { return validator_1.BridgeValidator; } });
+/**
+ * Main function to get aggregated bridge routes
+ *
+ * @example
+ * ```typescript
+ * import { getBridgeRoutes } from '@bridgewise/bridge-core';
+ *
+ * const routes = await getBridgeRoutes({
+ *   sourceChain: 'ethereum',
+ *   targetChain: 'polygon',
+ *   assetAmount: '1000000000000000000', // 1 ETH in wei
+ *   slippageTolerance: 0.5
+ * });
+ *
+ * console.log(`Found ${routes.routes.length} routes`);
+ * routes.routes.forEach(route => {
+ *   console.log(`${route.provider}: ${route.feePercentage}% fee, ${route.estimatedTime}s`);
+ * });
+ * ```
+ */
+async function getBridgeRoutes(request, config) {
+    const aggregator = new aggregator_1.BridgeAggregator(config);
+    return aggregator.getRoutes(request);
+}
+// Default export
+exports.default = {
+    BridgeAggregator: aggregator_1.BridgeAggregator,
+    getBridgeRoutes,
+};

libs/bridge-core/dist/types.d.ts

@@ -1,18 +1,128 @@
-export interface BridgeProvider {
-    name: string;
-    apiUrl: string;
+/**
+ * Supported chain identifiers
+ */
+export type ChainId = 'ethereum' | 'stellar' | 'polygon' | 'arbitrum' | 'optimism' | 'base' | 'gnosis' | 'nova' | 'bsc' | 'avalanche';
+/**
+ * Bridge provider identifiers
+ */
+export type BridgeProvider = 'stellar' | 'layerzero' | 'hop';
+/**
+ * Fee breakdown components
+ */
+export interface FeeBreakdown {
+    /** Network fee (in smallest unit) */
+    networkFee: string;
+    /** Bridge protocol fee (in smallest unit) */
+    bridgeFee: string;
+    /** Slippage fee (in smallest unit) */
+    slippageFee?: string;
 }
-export interface ApiRequest {
+/**
+ * Unified bridge route response
+ */
+export interface BridgeRoute {
+    /** Unique identifier for this route */
+    id: string;
+    /** Bridge provider name */
+    provider: BridgeProvider;
+    /** Source chain identifier */
+    sourceChain: ChainId;
+    /** Target chain identifier */
+    targetChain: ChainId;
+    /** Input amount (in smallest unit, e.g., wei) */
+    inputAmount: string;
+    /** Output amount after fees (in smallest unit) */
+    outputAmount: string;
+    /** Total fees charged (in smallest unit) */
+    fee: string;
+    /** Fee percentage (0-100) */
+    feePercentage: number;
+    /** Estimated time to complete bridge (in seconds) */
+    estimatedTime: number;
+    /** Minimum amount out (for slippage protection) */
+    minAmountOut: string;
+    /** Maximum amount out */
+    maxAmountOut: string;
+    /** Transaction deadline timestamp (Unix epoch in seconds) */
+    deadline?: number;
+    /** Bridge-specific transaction data */
+    transactionData?: {
+        /** Contract address to interact with */
+        contractAddress?: string;
+        /** Encoded calldata */
+        calldata?: string;
+        /** Value to send with transaction */
+        value?: string;
+        /** Gas estimate */
+        gasEstimate?: string;
+    };
+    /** Additional metadata */
+    metadata?: {
+        /** Route description */
+        description?: string;
+        /** Risk level (1-5, 1 being safest) */
+        riskLevel?: number;
+        /** Fee breakdown */
+        feeBreakdown?: FeeBreakdown;
+        /** Bridge-specific data */
+        [key: string]: unknown;
+    };
+}
+/**
+ * Request parameters for route discovery
+ */
+export interface RouteRequest {
+    /** Source chain identifier */
+    sourceChain: ChainId;
+    /** Target chain identifier */
+    targetChain: ChainId;
+    /** Amount to bridge (in smallest unit, e.g., wei) */
+    assetAmount: string;
+    /** Optional: Token contract address on source chain */
+    tokenAddress?: string;
+    /** Optional: Slippage tolerance (0-100, default: 0.5) */
+    slippageTolerance?: number;
+    /** Optional: Recipient address */
+    recipientAddress?: string;
+}
+/**
+ * Aggregated routes response
+ */
+export interface AggregatedRoutes {
+    /** Array of available routes, sorted by best option first */
+    routes: BridgeRoute[];
+    /** Timestamp when routes were fetched */
+    timestamp: number;
+    /** Total number of providers queried */
+    providersQueried: number;
+    /** Number of successful responses */
+    providersResponded: number;
+}
+/**
+ * Error response from a bridge provider
+ */
+export interface BridgeError {
     provider: BridgeProvider;
-    payload: unknown;
+    error: string;
+    code?: string;
+}
+/**
+ * API request for bridge provider
+ */
+export interface ApiRequest {
+    provider: {
+        name: BridgeProvider;
+    };
+    [key: string]: unknown;
 }
+/**
+ * API response from bridge provider
+ */
 export interface ApiResponse {
     success: boolean;
     data?: unknown;
-    error?: ApiError;
-}
-export interface ApiError {
-    isTransient: boolean;
-    message: string;
-    details?: unknown;
+    error?: {
+        code: string;
+        message: string;
+    };
 }