@voidaisdk/bridge-sdk 0.0.1

package/dist/api/client.js

@@ -0,0 +1,449 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoidAIBridgeClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+class VoidAIBridgeClient {
+    constructor(config) {
+        this.validatedApiKeyData = null;
+        this.accessToken = null;
+        this.config = config;
+        this.client = axios_1.default.create({
+            timeout: 10000,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        // Start auth immediately. Requests will await this promise.
+        // New flow: POST /auth/login to get JWT. Fallback to validate-api-key for backward compatibility.
+        this.ready = this.authenticate().then(() => undefined);
+    }
+    /**
+     * Authenticate and set Authorization header for subsequent requests.
+     * New flow: POST /api/v1/auth/login
+     * Fallback: GET /api/v1/auth/validate-api-key (legacy)
+     */
+    async authenticate() {
+        try {
+            const token = await this.login();
+            this.setAccessToken(token);
+            // Populate validatedApiKeyData from JWT payload (best-effort) so existing getters keep working.
+            this.validatedApiKeyData = this.tryDecodeTokenToValidationData(token);
+        }
+        catch (error) {
+            // If login isn't available or fails unexpectedly, fallback to legacy validation
+            // (do not break current working functionality).
+            try {
+                await this.validateApiKey();
+            }
+            catch (fallbackError) {
+                throw error;
+            }
+        }
+    }
+    setAccessToken(token) {
+        this.accessToken = token;
+        this.client.defaults.headers.common['Authorization'] = `Bearer ${token}`;
+    }
+    /**
+     * Get access token (available after successful auth)
+     */
+    getAccessToken() {
+        return this.accessToken;
+    }
+    getLoginUrl() {
+        const baseUrl = this.config.getBaseUrl();
+        const cleanBase = baseUrl.replace(/\/$/, '');
+        return `${cleanBase}/api/v1/auth/login`;
+    }
+    /**
+     * Get EVM bridge contract address for burn operations.
+     */
+    getBridgeContractAddress() {
+        return this.config.bridgeContractAddress;
+    }
+    /**
+     * Login to obtain JWT access token.
+     * Frontend usage: { apiKey }
+     * Backend usage: { apiKey, secretKey }
+     */
+    async login() {
+        const loginUrl = this.getLoginUrl();
+        const body = {
+            apiKey: this.config.apiKey,
+            ...(this.config.secretKey ? { secretKey: this.config.secretKey } : {}),
+        };
+        try {
+            const response = await axios_1.default.post(loginUrl, body, {
+                headers: { 'Content-Type': 'application/json' },
+                timeout: 10000,
+            });
+            if (response.data && response.data.success && response.data.accessToken) {
+                return response.data.accessToken;
+            }
+            const errorData = response.data;
+            throw new Error(errorData?.error?.message || errorData?.message || 'Failed to login');
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error)) {
+                // If backend returns 401/403 or structured error, surface message.
+                const data = error.response?.data;
+                const msg = data?.error?.message || data?.message || error.message || 'Failed to login';
+                throw new Error(msg);
+            }
+            throw error;
+        }
+    }
+    tryDecodeTokenToValidationData(token) {
+        try {
+            const parts = token.split('.');
+            if (parts.length < 2)
+                return null;
+            const payload = parts[1];
+            const json = this.base64UrlDecode(payload);
+            const parsed = JSON.parse(json);
+            // backend token contains: keyId, name, sub/id, apiKey, etc.
+            if (!parsed?.keyId || !parsed?.name)
+                return null;
+            return {
+                keyId: String(parsed.keyId),
+                tenantId: String(parsed.sub || parsed.id || ''),
+                name: String(parsed.name),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    base64UrlDecode(input) {
+        const base64 = input.replace(/-/g, '+').replace(/_/g, '/');
+        const pad = base64.length % 4;
+        const padded = pad ? base64 + '='.repeat(4 - pad) : base64;
+        // Node (backend) vs Browser
+        if (typeof Buffer !== 'undefined') {
+            return Buffer.from(padded, 'base64').toString('utf8');
+        }
+        // @ts-ignore
+        return atob(padded);
+    }
+    /**
+     * Validate API key with the backend
+     * @throws Error if API key is invalid
+     */
+    async validateApiKey() {
+        try {
+            // Use a temporary axios instance for validation since baseUrl might be different
+            const validationUrl = this.getValidationUrl();
+            const response = await axios_1.default.get(validationUrl, {
+                headers: {
+                    'api-key': this.config.apiKey,
+                },
+                timeout: 10000,
+            });
+            if (response.data.success) {
+                this.validatedApiKeyData = response.data.data;
+                return response.data.data;
+            }
+            else {
+                const error = new Error(response.data.error.message);
+                error.code = response.data.error.code;
+                throw error;
+            }
+        }
+        catch (error) {
+            // If validation fails, ensure we don't keep stale validated data around.
+            this.validatedApiKeyData = null;
+            if (axios_1.default.isAxiosError(error)) {
+                if (error.response?.status === 401) {
+                    const errorData = error.response.data;
+                    const apiError = new Error(errorData.error?.message || 'API key is invalid or inactive');
+                    apiError.code = errorData.error?.code || 'INVALID_API_KEY';
+                    throw apiError;
+                }
+                throw new Error(`Failed to validate API key: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Get validation URL - uses baseUrl from config
+     */
+    getValidationUrl() {
+        const baseUrl = this.config.getBaseUrl();
+        const cleanBase = baseUrl.replace(/\/$/, '');
+        return `${cleanBase}/api/v1/auth/validate-api-key`;
+    }
+    /**
+     * Get validated API key data
+     */
+    getValidatedApiKeyData() {
+        return this.validatedApiKeyData;
+    }
+    getUrl(path) {
+        const baseUrl = this.config.getBaseUrl();
+        // Remove trailing slash from base and leading slash from path to avoid doubles
+        const cleanBase = baseUrl.replace(/\/$/, '');
+        const cleanPath = path.replace(/^\//, '');
+        return `${cleanBase}/${cleanPath}`;
+    }
+    async get(path, params, retryAttempted = false) {
+        await this.ready;
+        const url = this.getUrl(path);
+        try {
+            const response = await this.client.get(url, { params });
+            return response.data;
+        }
+        catch (error) {
+            // If token is expired or unauthorized, transparently re-authenticate once and retry.
+            const status = error?.response?.status ?? error?.statusCode;
+            if (status === 401 && !retryAttempted) {
+                try {
+                    await this.authenticate();
+                    // Retry the original request once with fresh credentials.
+                    return await this.get(path, params, true);
+                }
+                catch (retryError) {
+                    this.handleError(retryError);
+                }
+            }
+            this.handleError(error);
+        }
+    }
+    async post(path, data, retryAttempted = false) {
+        await this.ready;
+        const url = this.getUrl(path);
+        try {
+            const response = await this.client.post(url, data);
+            return response.data;
+        }
+        catch (error) {
+            // If token is expired or unauthorized, transparently re-authenticate once and retry.
+            const status = error?.response?.status ?? error?.statusCode;
+            if (status === 401 && !retryAttempted) {
+                try {
+                    await this.authenticate();
+                    // Retry the original request once with fresh credentials.
+                    return await this.post(path, data, true);
+                }
+                catch (retryError) {
+                    this.handleError(retryError);
+                }
+            }
+            this.handleError(error);
+        }
+    }
+    async delete(path, params, retryAttempted = false) {
+        await this.ready;
+        const url = this.getUrl(path);
+        try {
+            const response = await this.client.delete(url, { params });
+            return response.data;
+        }
+        catch (error) {
+            const status = error?.response?.status ?? error?.statusCode;
+            if (status === 401 && !retryAttempted) {
+                try {
+                    await this.authenticate();
+                    return await this.delete(path, params, true);
+                }
+                catch (retryError) {
+                    this.handleError(retryError);
+                }
+            }
+            this.handleError(error);
+        }
+    }
+    async patch(path, data, retryAttempted = false) {
+        await this.ready;
+        const url = this.getUrl(path);
+        try {
+            const response = await this.client.patch(url, data);
+            return response.data;
+        }
+        catch (error) {
+            const status = error?.response?.status ?? error?.statusCode;
+            if (status === 401 && !retryAttempted) {
+                try {
+                    await this.authenticate();
+                    return await this.patch(path, data, true);
+                }
+                catch (retryError) {
+                    this.handleError(retryError);
+                }
+            }
+            this.handleError(error);
+        }
+    }
+    /**
+     * Bridge swap operation
+     */
+    async bridgeSwap(payload) {
+        return this.post('api/v1/bridge/swap', payload);
+    }
+    /**
+     * Route transaction operation (SWAP / BRIDGE / CCIP)
+     */
+    async routeTransaction(payload) {
+        // Backend expects amount as a string, but our types use number.
+        // Normalize here so callers can continue passing numbers.
+        const normalizedPayload = {
+            ...payload,
+            amount: String(payload.amount),
+        };
+        return this.post('api/v1/bridge/route-transaction', normalizedPayload);
+    }
+    /**
+     * Cancel a CCIP route transaction
+     */
+    async cancelCcip(params) {
+        const queryParams = {
+            operationType: params.operationType,
+            fromToken: params.fromToken,
+            toToken: params.toToken,
+            uuid: params.uuid,
+        };
+        return this.delete('api/v1/bridge/cancel-ccip', queryParams);
+    }
+    /**
+     * Cancel a router swap transaction
+     */
+    async cancelRouterSwap(params) {
+        const queryParams = {
+            uuid: params.uuid,
+        };
+        return this.delete('api/v1/bridge/cancel-router-swap', queryParams);
+    }
+    /**
+     * Cancel a bridge swap transaction
+     */
+    async cancelBridgeSwap(params) {
+        return this.patch('api/v1/bridge/swap/cancel', params);
+    }
+    /**
+     * Get recent API transactions (tenant-level)
+     *
+     * Maps to:
+     * POST /api/v1/bridge/api-transactions?page={page}&limit={limit}
+     */
+    async getApiTransactions(page = 1, limit = 20) {
+        const path = `api/v1/bridge/api-transactions?page=${encodeURIComponent(String(page))}&limit=${encodeURIComponent(String(limit))}`;
+        return this.post(path, undefined);
+    }
+    /**
+     * Manually validate a bridge burn transaction (EVM burn completion)
+     */
+    async validateBurn(params) {
+        return this.post('api/v1/bridge/validate-burn', params);
+    }
+    /**
+     * Manually confirm a CCIP transaction
+     */
+    async confirmCcipTransaction(params) {
+        const path = `api/v1/bridge/transactions/${encodeURIComponent(params.transactionId)}/tx`;
+        const body = {
+            txnHash: params.txnHash,
+            operationType: params.operationType,
+            txnStatus: params.txnStatus,
+        };
+        return this.patch(path, body);
+    }
+    /**
+     * Get list of supported chains
+     * @param options - Optional query parameters
+     * @param options.isActive - Filter by active status
+     * @param options.isCcipSupported - Filter by CCIP support
+     * @param options.chainId - Filter by specific chain ID
+     */
+    async getSupportedChains(options) {
+        const params = {};
+        if (options?.isActive !== undefined) {
+            params.is_active = String(options.isActive);
+        }
+        if (options?.isCcipSupported !== undefined) {
+            params.is_ccip_supported = String(options.isCcipSupported);
+        }
+        if (options?.chainId !== undefined) {
+            params.chain_id = options.chainId;
+        }
+        const response = await this.get('api/v1/chain/chains', params);
+        if (!response.success || !response.data) {
+            throw new Error(response.message || 'Failed to fetch chains');
+        }
+        return response.data.chains;
+    }
+    /**
+     * Get list of supported assets
+     */
+    async getAssetList(chainId) {
+        const response = await this.get('api/v1/asset/assets');
+        if (!response.success || !response.data) {
+            throw new Error(response.message || 'Failed to fetch assets');
+        }
+        let assets = response.data.assets;
+        // Filter by chainId if provided
+        if (chainId !== undefined) {
+            assets = assets.filter(asset => asset.chainId === chainId);
+        }
+        return assets;
+    }
+    /**
+     * Get bridge fee estimate
+     * @param params - Fee estimation parameters
+     */
+    async getBridgeFeeEstimate(params) {
+        const queryParams = {
+            fromToken: params.fromToken,
+            toToken: params.toToken,
+            amount: String(params.amount),
+        };
+        return this.get('api/v1/bridge/call-fee', queryParams);
+    }
+    /**
+     * Get router swap fee estimate
+     * @param params - Fee estimation parameters
+     */
+    async getRouterSwapFeeEstimate(params) {
+        const queryParams = {
+            originAssetId: String(params.originAssetId),
+            destinationAssetId: String(params.destinationAssetId),
+            amount: String(params.amount),
+            operationType: params.operationType,
+            toAddress: params.toAddress,
+        };
+        return this.get('api/v1/router-swap/call-fee', queryParams);
+    }
+    /**
+     * Normalize and rethrow errors with backend message (if available) so
+     * integrators can surface meaningful reasons to their users.
+     */
+    handleError(error) {
+        if (axios_1.default.isAxiosError(error)) {
+            const status = error.response?.status;
+            const data = error.response?.data;
+            // Try to extract a human friendly message from common backend shapes
+            let backendMessage = data?.error?.message ||
+                data?.message ||
+                (typeof data?.error === 'string' ? data.error : undefined) ||
+                (data?.success === false && data?.message ? data.message : undefined);
+            // For auth failures, avoid leaking raw backend JSON and give a clearer hint.
+            if (status === 401 &&
+                (backendMessage === 'Unauthorized' ||
+                    data?.statusCode === 401 ||
+                    data?.message === 'Unauthorized')) {
+                backendMessage =
+                    'Session expired or unauthorized. Please verify your API key/secret and try again.';
+            }
+            const message = backendMessage ||
+                error.message ||
+                (status ? `Request failed with status ${status}` : 'Request failed');
+            throw new Error(message);
+        }
+        else {
+            const message = error?.message || 'Unexpected error';
+            throw new Error(message);
+        }
+    }
+}
+exports.VoidAIBridgeClient = VoidAIBridgeClient;

package/dist/config.d.ts

@@ -0,0 +1,19 @@
+import { BridgeSDKOptions, BridgeSDKServerOptions, Environment } from './types';
+/** Internal: options accepted by BridgeConfig (frontend or server) */
+type BridgeConfigOptions = BridgeSDKOptions | BridgeSDKServerOptions;
+export declare class BridgeConfig {
+    readonly apiKey: string;
+    readonly secretKey?: string;
+    readonly environment: Environment;
+    readonly baseUrl: string;
+    /**
+     * EVM bridge contract address used for burn operations
+     * (wTAO/wALPHA -> TAO/ALPHA). Network-specific values can be
+     * configured here per environment.
+     */
+    readonly bridgeContractAddress: string;
+    private static readonly DEFAULTS;
+    constructor(options: BridgeConfigOptions);
+    getBaseUrl(): string;
+}
+export {};

package/dist/config.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BridgeConfig = void 0;
+class BridgeConfig {
+    constructor(options) {
+        if (!options.apiKey) {
+            throw new Error('BridgeSDK: apiKey is required');
+        }
+        this.apiKey = options.apiKey;
+        this.secretKey = 'secretKey' in options ? options.secretKey : undefined;
+        this.environment = options.environment || 'mainnet';
+        // Ensure environment is valid, default to mainnet if invalid
+        const validEnvironments = ['devnet', 'testnet', 'mainnet'];
+        if (!validEnvironments.includes(this.environment)) {
+            this.environment = 'mainnet';
+        }
+        const defaults = BridgeConfig.DEFAULTS[this.environment];
+        // Base URL & bridge contract address are derived from environment;
+        // consumers should not override these at runtime.
+        this.baseUrl = defaults.baseUrl;
+        this.bridgeContractAddress = defaults.bridgeContractAddress;
+    }
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+}
+exports.BridgeConfig = BridgeConfig;
+BridgeConfig.DEFAULTS = {
+    devnet: {
+        baseUrl: 'https://api-sdk-dev.voidai.envistudios.com/',
+        bridgeContractAddress: '0x6266ce15aC4f32F096Ff91881dd887a0F4bBa569',
+    },
+    testnet: {
+        baseUrl: 'https://api-sdk-stage.voidai.envistudios.com/',
+        bridgeContractAddress: '0x4aA4396BfD6F268b427077079800F420dF947b63',
+    },
+    mainnet: {
+        baseUrl: 'https://api-sdk.voidai.envistudios.com/',
+        bridgeContractAddress: '0x604e8Ef901C0E69E79463D997ba7D0724A909b84',
+    },
+};

package/dist/core/bridge.d.ts

@@ -0,0 +1,70 @@
+import { VoidAIBridgeClient } from '../api/client';
+import { BridgeSwapRequest, BridgeSwapResponse, RouteSwapRequest, RouteBridgeRequest, RouteCcipRequest, RouteTransactionResponse, BridgeFeeEstimateRequest, BridgeFeeEstimateResponse, RouterSwapFeeEstimateRequest, RouterSwapFeeEstimateResponse, CancelCcipRequest, CancelRouterSwapRequest, CancelBridgeSwapRequest, CancelOperationResponse, ApiTransactionsResponse, ValidateBurnRequest, ValidateBurnResponse, CcipTxConfirmationRequest, CcipTxConfirmationResponse } from '../types';
+/**
+ * Bridge API Methods
+ * Provides read-only API methods for bridge operations
+ */
+export declare class Bridge {
+    private apiClient;
+    constructor(apiClient: VoidAIBridgeClient);
+    /**
+     * Get transaction status
+     */
+    getTransactionStatus(txId: string): Promise<string>;
+    /**
+     * Get transaction history for an address
+     */
+    getHistory(address: string): Promise<any[]>;
+    /**
+     * Initiate a bridge operation (formerly swap).
+     */
+    bridge(payload: BridgeSwapRequest): Promise<BridgeSwapResponse>;
+    /**
+     * Alias for backward compatibility.
+     */
+    swap(payload: BridgeSwapRequest): Promise<BridgeSwapResponse>;
+    /**
+     * Route a SWAP operation through the unified route-transaction API.
+     */
+    routeSwap(payload: RouteSwapRequest): Promise<RouteTransactionResponse>;
+    /**
+     * Route a BRIDGE operation through the unified route-transaction API.
+     */
+    routeBridge(payload: RouteBridgeRequest): Promise<RouteTransactionResponse>;
+    /**
+     * Route a CCIP operation through the unified route-transaction API.
+     */
+    routeCcip(payload: RouteCcipRequest): Promise<RouteTransactionResponse>;
+    /**
+     * Get bridge fee estimate
+     */
+    getBridgeFeeEstimate(params: BridgeFeeEstimateRequest): Promise<BridgeFeeEstimateResponse>;
+    /**
+     * Get router swap fee estimate
+     */
+    getRouterSwapFeeEstimate(params: RouterSwapFeeEstimateRequest): Promise<RouterSwapFeeEstimateResponse>;
+    /**
+     * Cancel a CCIP route transaction
+     */
+    cancelCcipRoute(params: CancelCcipRequest): Promise<CancelOperationResponse>;
+    /**
+     * Cancel a router swap transaction
+     */
+    cancelRouterSwap(params: CancelRouterSwapRequest): Promise<CancelOperationResponse>;
+    /**
+     * Cancel a bridge swap transaction
+     */
+    cancelBridgeSwap(params: CancelBridgeSwapRequest): Promise<CancelOperationResponse>;
+    /**
+     * Get recent API transactions for the current tenant
+     */
+    getRecentTransactions(page?: number, limit?: number): Promise<ApiTransactionsResponse>;
+    /**
+     * Manually validate a bridge burn transaction
+     */
+    validateBurnTransaction(params: ValidateBurnRequest): Promise<ValidateBurnResponse>;
+    /**
+     * Manually confirm a CCIP transaction
+     */
+    confirmCcipTransaction(params: CcipTxConfirmationRequest): Promise<CcipTxConfirmationResponse>;
+}