@voidaisdk/bridge-sdk 0.0.1

package/dist/core/bridge.js

@@ -0,0 +1,213 @@
+"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
+ */
+class Bridge {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    /**
+     * Get transaction status
+     */
+    async getTransactionStatus(txId) {
+        const { status } = await this.apiClient.get(`/transactions/${txId}/status`);
+        return status;
+    }
+    /**
+     * Get transaction history for an address
+     */
+    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);
+        }
+    }
+    /**
+     * 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/index.d.ts

@@ -0,0 +1,55 @@
+import { BridgeConfig } from './config';
+import { VoidAIBridgeClient } from './api/client';
+import { BittensorWallet } from './wallet/bittensor';
+import { EthereumWallet } from './wallet/ethereum';
+import { SolanaWallet } from './wallet/solana';
+import { Bridge } from './core/bridge';
+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;
+    readonly wallets: {
+        bittensor: BittensorWallet;
+        ethereum: EthereumWallet;
+        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);
+    /**
+     * 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)
+     */
+    getValidatedApiKeyData(): ApiKeyValidationData | null;
+}

package/dist/index.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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.BridgeSDKServer = exports.BridgeSDK = void 0;
+const config_1 = require("./config");
+const client_1 = require("./api/client");
+const bittensor_1 = require("./wallet/bittensor");
+const ethereum_1 = require("./wallet/ethereum");
+const solana_1 = require("./wallet/solana");
+const bridge_1 = require("./core/bridge");
+__exportStar(require("./types"), exports);
+__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(),
+            solana: new solana_1.SolanaWallet()
+        };
+        this.bridge = new bridge_1.Bridge(this.api);
+    }
+    /**
+     * Get validated API key data (available after successful validation)
+     */
+    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;

package/dist/types/index.d.ts

@@ -0,0 +1,280 @@
+export type Environment = 'devnet' | 'testnet' | 'mainnet';
+/**
+ * Options for BridgeSDK (frontend usage).
+ * Use apiKey only; secretKey is not supported for frontend.
+ */
+export interface BridgeSDKOptions {
+    apiKey: string;
+    environment?: Environment;
+}
+/**
+ * Options for BridgeSDKServer (backend usage).
+ * Requires both apiKey and secretKey for JWT authentication.
+ */
+export interface BridgeSDKServerOptions {
+    apiKey: string;
+    secretKey: string;
+    environment?: Environment;
+}
+export interface Chain {
+    id: number;
+    name: string;
+    chainId: string;
+    network: string;
+    isActive: boolean;
+    logoUri: string;
+    isCcipSupported: boolean;
+    ccipBridgeConfigurationStatus: string;
+    ccipChainSelector: string | null;
+    ccipRouterAddress: string | null;
+    ccipAdminRegistryContract: string | null;
+    ccipSupportedInBounds: string[];
+    ccipSupportedOutBounds: string[];
+    voidAiRouterAddress: string | null;
+    ccipRmnProxy?: string | null;
+    ccipRegistryModuleOwnerCustom?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface AssetBalance {
+    tokenAddress: string;
+    balance: string;
+    decimals: number;
+    formatted: string;
+}
+export interface Asset {
+    id: number;
+    chainId: string;
+    tokenName: string;
+    symbol: string;
+    decimal: number;
+    type: string | null;
+    tokenPoolAddress: string;
+    tokenPoolType: string;
+    tokenAddress: string;
+    isActive: boolean;
+    metadata: Record<string, any>;
+    subnetId: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface Pagination {
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}
+export interface ChainsApiResponse {
+    success: boolean;
+    message: string;
+    data: {
+        chains: Chain[];
+    };
+}
+export interface AssetsApiResponse {
+    success: boolean;
+    message: string;
+    data: {
+        assets: Asset[];
+        pagination: Pagination;
+    };
+}
+export interface ApiKeyValidationData {
+    keyId: string;
+    tenantId: string;
+    name: string;
+}
+export interface ApiKeyValidationSuccessResponse {
+    success: true;
+    data: ApiKeyValidationData;
+}
+export interface ApiKeyValidationErrorResponse {
+    success: false;
+    error: {
+        code: string;
+        message: string;
+    };
+}
+export type ApiKeyValidationResponse = ApiKeyValidationSuccessResponse | ApiKeyValidationErrorResponse;
+export interface AuthLoginRequest {
+    apiKey: string;
+    secretKey?: string;
+}
+export interface AuthLoginSuccessResponse {
+    success: true;
+    accessToken: string;
+}
+export interface AuthLoginErrorResponse {
+    success: false;
+    error?: {
+        code?: string;
+        message?: string;
+    };
+    message?: string;
+}
+export type AuthLoginResponse = AuthLoginSuccessResponse | AuthLoginErrorResponse;
+export interface BridgeSwapRequest {
+    fromWallet: string;
+    toWallet: string;
+    fromToken: string;
+    toToken: string;
+    fromChain: string;
+    toChain: string;
+    amount: number;
+    subnetId?: number;
+}
+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;
+    signature: string;
+    /**
+     * Optional helper payload prepared by the SDK for
+     * EVM burn transactions (wTAO/wALPHA -> TAO/ALPHA).
+     * Frontends can pass this directly to wallet providers.
+     */
+    evmTransaction?: {
+        to: string;
+        data: string;
+        value: string;
+    };
+}
+export interface BridgeSwapResponseWithSubnet extends BridgeSwapResponseBase {
+    subnetDestinationHotkey: string;
+}
+export type BridgeSwapResponse = BridgeSwapResponseWithEncodedData | BridgeSwapResponseWithSubnet | BridgeSwapResponseBase;
+export type RouteOperationType = 'SWAP' | 'BRIDGE' | 'CCIP';
+export interface RouteSwapRequest {
+    operationType: 'SWAP';
+    originAssetId: number;
+    destinationAssetId: number;
+    fromAddress: string;
+    toAddress: string;
+    amount: number;
+}
+export interface RouteBridgeRequest {
+    operationType: 'BRIDGE';
+    fromChain: string;
+    toChain: string;
+    fromToken: string;
+    toToken: string;
+    fromWallet: string;
+    toWallet: string;
+    amount: number;
+    subnetId?: number;
+}
+export interface RouteCcipRequest {
+    operationType: 'CCIP';
+    originAssetId: number;
+    destinationAssetId: number;
+    fromAddress: string;
+    toAddress: string;
+    amount: number;
+}
+export type RouteTransactionRequest = RouteSwapRequest | RouteBridgeRequest | RouteCcipRequest;
+export interface RouteTransactionResponseData {
+    to: string;
+    data: string;
+    value: string;
+    chainId: number;
+}
+export interface RouteTransactionResponse {
+    operationType: RouteOperationType;
+    identifier: string;
+    success: boolean;
+    message: string;
+    data?: RouteTransactionResponseData;
+    ccipFee?: string;
+}
+export interface BridgeFeeEstimateRequest {
+    fromToken: string;
+    toToken: string;
+    amount: number;
+}
+export interface BridgeFeeEstimateResponse {
+    success: boolean;
+    message: string;
+    data: {
+        fee: string;
+        recipientAmount: string;
+        tenantFee: string;
+    };
+}
+export interface RouterSwapFeeEstimateRequest {
+    originAssetId: number;
+    destinationAssetId: number;
+    amount: number;
+    operationType: RouteOperationType;
+    toAddress: string;
+}
+export interface RouterSwapFeeEstimateResponse {
+    swapAmount: string;
+    totalFee: string;
+    platformFee: string;
+    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;
+}

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/validation.d.ts

@@ -0,0 +1,2 @@
+export declare const isValidAddress: (address: string) => boolean;
+export declare const isValidHash: (hash: string) => boolean;

package/dist/utils/validation.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidHash = exports.isValidAddress = void 0;
+const isValidAddress = (address) => {
+    // Basic hex validation for generic blockchain address
+    return /^0x[a-fA-F0-9]{40,}$/.test(address);
+};
+exports.isValidAddress = isValidAddress;
+const isValidHash = (hash) => {
+    return /^0x[a-fA-F0-9]{64}$/.test(hash);
+};
+exports.isValidHash = isValidHash;

package/dist/wallet/bittensor.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Bittensor Wallet Connection
+ * Handles connection to Bittensor-compatible wallets (Talisman, Subwallet, Polkadot.js)
+ */
+export interface BittensorAccount {
+    address: string;
+    name?: string;
+    source: string;
+}
+export interface BittensorWalletExtension {
+    accounts: {
+        get: () => Promise<BittensorAccount[]>;
+    };
+    signer?: {
+        signRaw?: (options: {
+            address: string;
+            data: string;
+        }) => Promise<{
+            signature: string;
+        }>;
+    };
+}
+export declare class BittensorWallet {
+    private extension;
+    private account;
+    private extensionName;
+    /**
+     * Connect to a Bittensor-compatible wallet
+     * @param extensionName - Optional: specific extension name ('talisman', 'subwallet-js', 'polkadot-js')
+     * @returns Connected account information
+     */
+    connect(extensionName?: string): Promise<BittensorAccount>;
+    /**
+     * Get currently connected account
+     */
+    getAccount(): BittensorAccount | null;
+    /**
+     * Get extension name
+     */
+    getExtensionName(): string | null;
+    /**
+     * Check if wallet is connected
+     */
+    isConnected(): boolean;
+    /**
+     * Disconnect wallet
+     * Note: This only disconnects from the SDK. To fully disconnect from the extension,
+     * users need to disconnect accounts in their wallet extension settings.
+     */
+    disconnect(): void;
+    /**
+     * Check if wallet extension is available
+     */
+    static isExtensionAvailable(extensionName?: string): boolean;
+    /**
+     * Get the wallet extension instance (for advanced usage)
+     */
+    getExtension(): BittensorWalletExtension | null;
+}