voidai-sdk 0.1.2 → 0.2.0

package/README.md

@@ -42,7 +42,7 @@ import { BridgeSDK } from 'voidai-sdk';
 
 const sdk = new BridgeSDK({
   apiKey: process.env.VOIDAI_API_KEY!,
-  environment: 'staging', // 'development' | 'staging' | 'production'
+  environment: 'testnet', // 'devnet' | 'testnet' | 'mainnet'
 });
 
 // Wait for authentication & API key validation

package/dist/api/client.d.ts

@@ -1,5 +1,5 @@
 import { BridgeConfig } from '../config';
-import { Chain, Asset, ApiKeyValidationData, BridgeSwapRequest, BridgeSwapResponse, RouteTransactionRequest, RouteTransactionResponse, BridgeFeeEstimateRequest, BridgeFeeEstimateResponse, RouterSwapFeeEstimateRequest, RouterSwapFeeEstimateResponse } from '../types';
+import { Chain, Asset, ApiKeyValidationData, BridgeSwapRequest, BridgeSwapResponse, RouteTransactionRequest, RouteTransactionResponse, BridgeFeeEstimateRequest, BridgeFeeEstimateResponse, RouterSwapFeeEstimateRequest, RouterSwapFeeEstimateResponse, CancelCcipRequest, CancelRouterSwapRequest, CancelBridgeSwapRequest, CancelOperationResponse, ApiTransactionsResponse, ValidateBurnRequest, ValidateBurnResponse, CcipTxConfirmationRequest, CcipTxConfirmationResponse } from '../types';
 export declare class VoidAIBridgeClient {
     private config;
     private client;
@@ -47,6 +47,8 @@ export declare class VoidAIBridgeClient {
     private getUrl;
     get<T>(path: string, params?: any, retryAttempted?: boolean): Promise<T>;
     post<T>(path: string, data?: any, retryAttempted?: boolean): Promise<T>;
+    delete<T>(path: string, params?: any, retryAttempted?: boolean): Promise<T>;
+    patch<T>(path: string, data?: any, retryAttempted?: boolean): Promise<T>;
     /**
      * Bridge swap operation
      */
@@ -55,6 +57,33 @@ export declare class VoidAIBridgeClient {
      * Route transaction operation (SWAP / BRIDGE / CCIP)
      */
     routeTransaction(payload: RouteTransactionRequest): Promise<RouteTransactionResponse>;
+    /**
+     * Cancel a CCIP route transaction
+     */
+    cancelCcip(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 (tenant-level)
+     *
+     * Maps to:
+     * POST /api/v1/bridge/api-transactions?page={page}&limit={limit}
+     */
+    getApiTransactions(page?: number, limit?: number): Promise<ApiTransactionsResponse>;
+    /**
+     * Manually validate a bridge burn transaction (EVM burn completion)
+     */
+    validateBurn(params: ValidateBurnRequest): Promise<ValidateBurnResponse>;
+    /**
+     * Manually confirm a CCIP transaction
+     */
+    confirmCcipTransaction(params: CcipTxConfirmationRequest): Promise<CcipTxConfirmationResponse>;
     /**
      * Get list of supported chains
      * @param options - Optional query parameters

package/dist/api/client.js

@@ -14,7 +14,6 @@ class VoidAIBridgeClient {
             timeout: 10000,
             headers: {
                 'Content-Type': 'application/json',
-                'api-key': this.config.apiKey,
             },
         });
         // Start auth immediately. Requests will await this promise.
@@ -235,6 +234,48 @@ class VoidAIBridgeClient {
             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
      */
@@ -245,7 +286,68 @@ class VoidAIBridgeClient {
      * Route transaction operation (SWAP / BRIDGE / CCIP)
      */
     async routeTransaction(payload) {
-        return this.post('api/v1/bridge/route-transaction', 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

package/dist/config.js

@@ -8,11 +8,11 @@ class BridgeConfig {
         }
         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'];
+        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 = 'production';
+            this.environment = 'mainnet';
         }
         const defaults = BridgeConfig.DEFAULTS[this.environment];
         // Base URL & bridge contract address are derived from environment;
@@ -26,17 +26,16 @@ class BridgeConfig {
 }
 exports.BridgeConfig = BridgeConfig;
 BridgeConfig.DEFAULTS = {
-    development: {
-        // Local/dev backend
+    devnet: {
         baseUrl: 'https://api-sdk-dev.voidai.envistudios.com/',
         bridgeContractAddress: '0x6266ce15aC4f32F096Ff91881dd887a0F4bBa569',
     },
-    staging: {
+    testnet: {
         baseUrl: 'https://api-sdk-stage.voidai.envistudios.com/',
-        bridgeContractAddress: '0x6266ce15aC4f32F096Ff91881dd887a0F4bBa569',
+        bridgeContractAddress: '0x4aA4396BfD6F268b427077079800F420dF947b63',
     },
-    production: {
+    mainnet: {
         baseUrl: 'https://api-sdk.voidai.envistudios.com/',
-        bridgeContractAddress: '0x6266ce15aC4f32F096Ff91881dd887a0F4bBa569',
+        bridgeContractAddress: '0x604e8Ef901C0E69E79463D997ba7D0724A909b84',
     },
 };

package/dist/core/bridge.d.ts

@@ -1,5 +1,5 @@
 import { VoidAIBridgeClient } from '../api/client';
-import { BridgeSwapRequest, BridgeSwapResponse, RouteSwapRequest, RouteBridgeRequest, RouteCcipRequest, RouteTransactionResponse, BridgeFeeEstimateRequest, BridgeFeeEstimateResponse, RouterSwapFeeEstimateRequest, RouterSwapFeeEstimateResponse } from '../types';
+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
@@ -43,4 +43,28 @@ export declare class Bridge {
      * 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>;
 }

package/dist/core/bridge.js

@@ -137,5 +137,77 @@ class Bridge {
             throw new Error(message);
         }
     }
+    /**
+     * Cancel a CCIP route transaction
+     */
+    async cancelCcipRoute(params) {
+        try {
+            return await this.apiClient.cancelCcip(params);
+        }
+        catch (error) {
+            const message = error?.message || 'Failed to cancel CCIP transaction';
+            throw new Error(message);
+        }
+    }
+    /**
+     * Cancel a router swap transaction
+     */
+    async cancelRouterSwap(params) {
+        try {
+            return await this.apiClient.cancelRouterSwap(params);
+        }
+        catch (error) {
+            const message = error?.message || 'Failed to cancel router swap transaction';
+            throw new Error(message);
+        }
+    }
+    /**
+     * Cancel a bridge swap transaction
+     */
+    async cancelBridgeSwap(params) {
+        try {
+            return await this.apiClient.cancelBridgeSwap(params);
+        }
+        catch (error) {
+            const message = error?.message || 'Failed to cancel bridge transaction';
+            throw new Error(message);
+        }
+    }
+    /**
+     * Get recent API transactions for the current tenant
+     */
+    async getRecentTransactions(page = 1, limit = 20) {
+        try {
+            return await this.apiClient.getApiTransactions(page, limit);
+        }
+        catch (error) {
+            const message = error?.message || 'Failed to fetch recent transactions';
+            throw new Error(message);
+        }
+    }
+    /**
+     * Manually validate a bridge burn transaction
+     */
+    async validateBurnTransaction(params) {
+        try {
+            return await this.apiClient.validateBurn(params);
+        }
+        catch (error) {
+            const message = error?.message || 'Failed to validate burn transaction';
+            throw new Error(message);
+        }
+    }
+    /**
+     * Manually confirm a CCIP transaction
+     */
+    async confirmCcipTransaction(params) {
+        try {
+            return await this.apiClient.confirmCcipTransaction(params);
+        }
+        catch (error) {
+            const message = error?.message || 'Failed to confirm CCIP transaction';
+            throw new Error(message);
+        }
+    }
 }
 exports.Bridge = Bridge;

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-export type Environment = 'development' | 'production' | 'staging';
+export type Environment = 'devnet' | 'testnet' | 'mainnet';
 /**
  * Options for BridgeSDK (frontend usage).
  * Use apiKey only; secretKey is not supported for frontend.
@@ -125,6 +125,12 @@ export interface BridgeSwapRequest {
 }
 export interface BridgeSwapResponseBase {
     identifier: string;
+    /**
+     * Destination address that must receive the bridged funds.
+     * For BITTENSOR -> EVM/TAO flows, this is the hot wallet /
+     * recipient address returned by the backend.
+     */
+    toAddress?: string;
 }
 export interface BridgeSwapResponseWithEncodedData extends BridgeSwapResponseBase {
     encodedData: string;
@@ -215,3 +221,60 @@ export interface RouterSwapFeeEstimateResponse {
     ccipFee: string;
     tenantFee: string;
 }
+export interface CancelCcipRequest {
+    operationType: 'CCIP';
+    fromToken: string;
+    toToken: string;
+    uuid: string;
+}
+export interface CancelRouterSwapRequest {
+    uuid: string;
+}
+export interface CancelBridgeSwapRequest {
+    fromToken: string;
+    toToken: string;
+    uuid: string;
+}
+export interface CancelOperationResponse {
+    success: boolean;
+    message: string;
+}
+export interface ValidateBurnRequest {
+    transactionHash: string;
+    identifier: string;
+}
+export interface ValidateBurnResponse {
+    success: boolean;
+    message: string;
+    identifier: string;
+    burnDetails: Record<string, any>;
+}
+export interface CcipTxConfirmationRequest {
+    transactionId: string;
+    txnHash: string;
+    operationType: string;
+    txnStatus: string;
+}
+export interface CcipTxConfirmationResponse {
+    success: boolean;
+    message?: string;
+}
+export interface ApiTransactionItem {
+    id: string;
+    transactionUuid: string;
+    functionName: string;
+    feeAmount: string;
+    status: string;
+    transactionHash: {
+        chain_hash?: string;
+        completion_hash?: string;
+    };
+    createdAt: string;
+}
+export interface ApiTransactionsResponse {
+    items: ApiTransactionItem[];
+    page: number;
+    limit: number;
+    totalItems: number;
+    totalPages: number;
+}