voidai-sdk 0.1.0 → 0.1.2

package/dist/api/client.js

@@ -7,14 +7,180 @@ 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',
-                'x-api-key': this.config.apiKey,
+                'api-key': this.config.apiKey,
             },
         });
+        // 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();
@@ -23,28 +189,64 @@ class VoidAIBridgeClient {
         const cleanPath = path.replace(/^\//, '');
         return `${cleanBase}/${cleanPath}`;
     }
-    async get(path, params) {
+    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);
-            throw error;
         }
     }
-    async post(path, data) {
+    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);
-            throw error;
         }
     }
+    /**
+     * Bridge swap operation
+     */
+    async bridgeSwap(payload) {
+        return this.post('api/v1/bridge/swap', payload);
+    }
+    /**
+     * Route transaction operation (SWAP / BRIDGE / CCIP)
+     */
+    async routeTransaction(payload) {
+        return this.post('api/v1/bridge/route-transaction', payload);
+    }
     /**
      * Get list of supported chains
      * @param options - Optional query parameters
@@ -63,26 +265,82 @@ class VoidAIBridgeClient {
         if (options?.chainId !== undefined) {
             params.chain_id = options.chainId;
         }
-        const response = await this.get('api/chains', params);
-        return response.chains;
+        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/asset');
+        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) {
-            return response.assets.filter(asset => asset.chainId === chainId);
+            assets = assets.filter(asset => asset.chainId === chainId);
         }
-        return response.assets;
+        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)) {
-            console.error('Bridge API Error:', error.response?.data || error.message);
+            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 {
-            console.error('Unexpected Error:', error);
+            const message = error?.message || 'Unexpected error';
+            throw new Error(message);
         }
     }
 }

package/dist/config.d.ts

@@ -1,9 +1,19 @@
-import { BridgeSDKOptions, Environment } from './types';
+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: BridgeSDKOptions);
+    constructor(options: BridgeConfigOptions);
     getBaseUrl(): string;
 }
+export {};

package/dist/config.js

@@ -7,6 +7,7 @@ class BridgeConfig {
             throw new Error('BridgeSDK: apiKey is required');
         }
         this.apiKey = options.apiKey;
+        this.secretKey = 'secretKey' in options ? options.secretKey : undefined;
         this.environment = options.environment || 'production';
         // Ensure environment is valid, default to production if invalid
         const validEnvironments = ['development', 'staging', 'production'];
@@ -14,8 +15,10 @@ class BridgeConfig {
             this.environment = 'production';
         }
         const defaults = BridgeConfig.DEFAULTS[this.environment];
-        // Allow custom base URL override
-        this.baseUrl = options.baseUrl || defaults.baseUrl;
+        // 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;
@@ -24,12 +27,16 @@ class BridgeConfig {
 exports.BridgeConfig = BridgeConfig;
 BridgeConfig.DEFAULTS = {
     development: {
-        baseUrl: 'https://api-dev.voidai.envistudios.com',
+        // Local/dev backend
+        baseUrl: 'https://api-sdk-dev.voidai.envistudios.com/',
+        bridgeContractAddress: '0x6266ce15aC4f32F096Ff91881dd887a0F4bBa569',
     },
     staging: {
-        baseUrl: 'https://api-staging.voidai.envistudios.com',
+        baseUrl: 'https://api-sdk-stage.voidai.envistudios.com/',
+        bridgeContractAddress: '0x6266ce15aC4f32F096Ff91881dd887a0F4bBa569',
     },
     production: {
-        baseUrl: 'https://api.voidai.envistudios.com',
+        baseUrl: 'https://api-sdk.voidai.envistudios.com/',
+        bridgeContractAddress: '0x6266ce15aC4f32F096Ff91881dd887a0F4bBa569',
     },
 };

package/dist/core/bridge.d.ts

@@ -1,4 +1,5 @@
 import { VoidAIBridgeClient } from '../api/client';
+import { BridgeSwapRequest, BridgeSwapResponse, RouteSwapRequest, RouteBridgeRequest, RouteCcipRequest, RouteTransactionResponse, BridgeFeeEstimateRequest, BridgeFeeEstimateResponse, RouterSwapFeeEstimateRequest, RouterSwapFeeEstimateResponse } from '../types';
 /**
  * Bridge API Methods
  * Provides read-only API methods for bridge operations
@@ -14,4 +15,32 @@ export declare class Bridge {
      * 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>;
 }

package/dist/core/bridge.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Bridge = void 0;
+const viem_1 = require("viem");
 /**
  * Bridge API Methods
  * Provides read-only API methods for bridge operations
@@ -22,5 +23,119 @@ class Bridge {
     async getHistory(address) {
         return this.apiClient.get(`/transactions/history/${address}`);
     }
+    /**
+     * Initiate a bridge operation (formerly swap).
+     */
+    async bridge(payload) {
+        try {
+            const response = await this.apiClient.bridgeSwap(payload);
+            // For EVM flows that return encodedData + signature, prepare
+            // a ready-to-send Ethereum transaction for the bridge contract.
+            const maybeWithEncoded = response;
+            if (maybeWithEncoded.encodedData && maybeWithEncoded.signature) {
+                // IMPORTANT:
+                // - The bridge contract address is configured per environment
+                //   in BridgeConfig (config.ts). The encodedData & signature are
+                //   already validated/constructed by the backend.
+                // - We simply ABI-encode the function call so frontend integrators
+                //   can pass it directly to MetaMask / wallet providers.
+                const bridgeContractAddress = this.apiClient.getBridgeContractAddress();
+                const calldata = (0, viem_1.encodeFunctionData)({
+                    abi: [
+                        {
+                            type: 'function',
+                            name: 'burn',
+                            stateMutability: 'nonpayable',
+                            inputs: [
+                                { name: 'encodedData', type: 'bytes' },
+                                { name: 'signature', type: 'bytes' },
+                            ],
+                            outputs: [],
+                        },
+                    ],
+                    functionName: 'burn',
+                    args: [maybeWithEncoded.encodedData, maybeWithEncoded.signature],
+                });
+                // Attach the prepared transaction payload in a non-breaking way.
+                maybeWithEncoded.evmTransaction = {
+                    to: bridgeContractAddress,
+                    data: calldata,
+                    value: '0x0',
+                };
+            }
+            return response;
+        }
+        catch (error) {
+            // Surface a clean error message while preserving the original error for debugging.
+            const message = error?.message || 'Failed to execute bridge swap';
+            throw new Error(message);
+        }
+    }
+    /**
+     * Alias for backward compatibility.
+     */
+    async swap(payload) {
+        return this.bridge(payload);
+    }
+    /**
+     * Route a SWAP operation through the unified route-transaction API.
+     */
+    async routeSwap(payload) {
+        try {
+            return await this.apiClient.routeTransaction(payload);
+        }
+        catch (error) {
+            const message = error?.message || 'Failed to route SWAP transaction';
+            throw new Error(message);
+        }
+    }
+    /**
+     * Route a BRIDGE operation through the unified route-transaction API.
+     */
+    async routeBridge(payload) {
+        try {
+            return await this.apiClient.routeTransaction(payload);
+        }
+        catch (error) {
+            const message = error?.message || 'Failed to route BRIDGE transaction';
+            throw new Error(message);
+        }
+    }
+    /**
+     * Route a CCIP operation through the unified route-transaction API.
+     */
+    async routeCcip(payload) {
+        try {
+            return await this.apiClient.routeTransaction(payload);
+        }
+        catch (error) {
+            const message = error?.message || 'Failed to route CCIP transaction';
+            throw new Error(message);
+        }
+    }
+    /**
+     * Get bridge fee estimate
+     */
+    async getBridgeFeeEstimate(params) {
+        try {
+            return await this.apiClient.getBridgeFeeEstimate(params);
+        }
+        catch (error) {
+            const message = error?.message || 'Failed to get bridge fee estimate';
+            throw new Error(message);
+        }
+    }
+    /**
+     * Get router swap fee estimate
+     */
+    async getRouterSwapFeeEstimate(params) {
+        try {
+            return await this.apiClient.getRouterSwapFeeEstimate(params);
+        }
+        catch (error) {
+            const message = error?.message || 'Failed to get router swap fee estimate';
+            throw new Error(message);
+        }
+    }
 }
 exports.Bridge = Bridge;

package/dist/index.d.ts

@@ -4,12 +4,16 @@ import { BittensorWallet } from './wallet/bittensor';
 import { EthereumWallet } from './wallet/ethereum';
 import { SolanaWallet } from './wallet/solana';
 import { Bridge } from './core/bridge';
-import { BridgeSDKOptions } from './types';
+import { BridgeSDKOptions, BridgeSDKServerOptions, ApiKeyValidationData } from './types';
 export * from './types';
 export * from './config';
 export * from './wallet/bittensor';
 export * from './wallet/ethereum';
 export * from './wallet/solana';
+/**
+ * BridgeSDK – for frontend/browser usage.
+ * Use apiKey only; do not pass secretKey in frontend.
+ */
 export declare class BridgeSDK {
     readonly config: BridgeConfig;
     readonly api: VoidAIBridgeClient;
@@ -19,9 +23,33 @@ export declare class BridgeSDK {
         solana: SolanaWallet;
     };
     readonly bridge: Bridge;
+    /**
+     * Resolves once the SDK has validated the API key (or rejects if invalid).
+     * Consumers can await this if they want to gate UI on readiness.
+     */
+    readonly ready: Promise<void>;
     constructor(options: BridgeSDKOptions);
     /**
-     * Initialize the SDK
+     * Get validated API key data (available after successful validation)
+     */
+    getValidatedApiKeyData(): ApiKeyValidationData | null;
+}
+/**
+ * BridgeSDKServer – for backend/server usage.
+ * Requires apiKey + secretKey for JWT authentication.
+ * No wallet integrations (use BridgeSDK in frontend for that).
+ */
+export declare class BridgeSDKServer {
+    readonly config: BridgeConfig;
+    readonly api: VoidAIBridgeClient;
+    readonly bridge: Bridge;
+    /**
+     * Resolves once the SDK has validated the API key (or rejects if invalid).
+     */
+    readonly ready: Promise<void>;
+    constructor(options: BridgeSDKServerOptions);
+    /**
+     * Get validated API key data (available after successful validation)
      */
-    init(): Promise<void>;
+    getValidatedApiKeyData(): ApiKeyValidationData | null;
 }

package/dist/index.js

@@ -14,7 +14,7 @@ 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.BridgeSDK = void 0;
+exports.BridgeSDKServer = exports.BridgeSDK = void 0;
 const config_1 = require("./config");
 const client_1 = require("./api/client");
 const bittensor_1 = require("./wallet/bittensor");
@@ -26,10 +26,15 @@ __exportStar(require("./config"), exports);
 __exportStar(require("./wallet/bittensor"), exports);
 __exportStar(require("./wallet/ethereum"), exports);
 __exportStar(require("./wallet/solana"), exports);
+/**
+ * BridgeSDK – for frontend/browser usage.
+ * Use apiKey only; do not pass secretKey in frontend.
+ */
 class BridgeSDK {
     constructor(options) {
         this.config = new config_1.BridgeConfig(options);
         this.api = new client_1.VoidAIBridgeClient(this.config);
+        this.ready = this.api.ready;
         this.wallets = {
             bittensor: new bittensor_1.BittensorWallet(),
             ethereum: new ethereum_1.EthereumWallet(),
@@ -38,10 +43,30 @@ class BridgeSDK {
         this.bridge = new bridge_1.Bridge(this.api);
     }
     /**
-     * Initialize the SDK
+     * Get validated API key data (available after successful validation)
      */
-    async init() {
-        console.log('BridgeSDK initialized');
+    getValidatedApiKeyData() {
+        return this.api.getValidatedApiKeyData();
     }
 }
 exports.BridgeSDK = BridgeSDK;
+/**
+ * BridgeSDKServer – for backend/server usage.
+ * Requires apiKey + secretKey for JWT authentication.
+ * No wallet integrations (use BridgeSDK in frontend for that).
+ */
+class BridgeSDKServer {
+    constructor(options) {
+        this.config = new config_1.BridgeConfig(options);
+        this.api = new client_1.VoidAIBridgeClient(this.config);
+        this.ready = this.api.ready;
+        this.bridge = new bridge_1.Bridge(this.api);
+    }
+    /**
+     * Get validated API key data (available after successful validation)
+     */
+    getValidatedApiKeyData() {
+        return this.api.getValidatedApiKeyData();
+    }
+}
+exports.BridgeSDKServer = BridgeSDKServer;