@voidaisdk/bridge-sdk 0.0.1

package/dist/wallet/bittensor.js

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * Bittensor Wallet Connection
+ * Handles connection to Bittensor-compatible wallets (Talisman, Subwallet, Polkadot.js)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BittensorWallet = void 0;
+class BittensorWallet {
+    constructor() {
+        this.extension = null;
+        this.account = null;
+        this.extensionName = null;
+    }
+    /**
+     * Connect to a Bittensor-compatible wallet
+     * @param extensionName - Optional: specific extension name ('talisman', 'subwallet-js', 'polkadot-js')
+     * @returns Connected account information
+     */
+    async connect(extensionName) {
+        // Check if running in browser environment
+        if (typeof window === 'undefined') {
+            throw new Error('BittensorWallet: Browser environment required for wallet connection');
+        }
+        // Check if any compatible extension is available
+        if (typeof window.injectedWeb3 === 'undefined') {
+            throw new Error('No compatible wallet extension found. Please install Talisman, Subwallet, or Polkadot.js extension.');
+        }
+        const injectedWeb3 = window.injectedWeb3;
+        const supportedExtensions = ['talisman', 'subwallet-js', 'polkadot-js'];
+        let targetExtension = null;
+        let selectedExtensionName = '';
+        // If specific extension requested, use it
+        if (extensionName && injectedWeb3[extensionName]) {
+            targetExtension = injectedWeb3[extensionName];
+            selectedExtensionName = extensionName;
+        }
+        else {
+            // Find the first available supported extension
+            for (const name of supportedExtensions) {
+                if (injectedWeb3[name]) {
+                    targetExtension = injectedWeb3[name];
+                    selectedExtensionName = name;
+                    break;
+                }
+            }
+            // Fallback: try to pick the first one available
+            if (!targetExtension) {
+                const available = Object.keys(injectedWeb3);
+                if (available.length > 0) {
+                    selectedExtensionName = available[0];
+                    targetExtension = injectedWeb3[selectedExtensionName];
+                }
+                else {
+                    throw new Error('No compatible wallet extension found.');
+                }
+            }
+        }
+        // Request access to extension - this will trigger a popup for account authorization
+        let extension;
+        try {
+            extension = await targetExtension.enable('VoidAI Bridge SDK');
+        }
+        catch (error) {
+            // Handle case where user rejects authorization or no accounts are authorized
+            if (error.message && error.message.includes('authorised')) {
+                throw new Error('No accounts are authorized. Please authorize accounts in your wallet extension and try again.');
+            }
+            throw new Error(`Failed to enable wallet extension: ${error.message || error}`);
+        }
+        if (!extension) {
+            throw new Error('Failed to enable wallet extension. Please try again.');
+        }
+        // Get all authorized accounts
+        let allAccounts;
+        try {
+            allAccounts = await extension.accounts.get();
+        }
+        catch (error) {
+            throw new Error(`Failed to get accounts: ${error.message || error}`);
+        }
+        if (allAccounts.length === 0) {
+            throw new Error('No accounts found. Please authorize at least one account in your wallet extension and try again.');
+        }
+        // Store extension and use first account
+        this.extension = extension;
+        const account = allAccounts[0];
+        this.account = account;
+        this.extensionName = selectedExtensionName;
+        return account;
+    }
+    /**
+     * Get currently connected account
+     */
+    getAccount() {
+        return this.account;
+    }
+    /**
+     * Get extension name
+     */
+    getExtensionName() {
+        return this.extensionName;
+    }
+    /**
+     * Check if wallet is connected
+     */
+    isConnected() {
+        return this.account !== null && this.extension !== null;
+    }
+    /**
+     * 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() {
+        this.extension = null;
+        this.account = null;
+        this.extensionName = null;
+    }
+    /**
+     * Check if wallet extension is available
+     */
+    static isExtensionAvailable(extensionName) {
+        if (typeof window === 'undefined') {
+            return false;
+        }
+        const injectedWeb3 = window.injectedWeb3;
+        if (!injectedWeb3) {
+            return false;
+        }
+        if (extensionName) {
+            return !!injectedWeb3[extensionName];
+        }
+        const supportedExtensions = ['talisman', 'subwallet-js', 'polkadot-js'];
+        return supportedExtensions.some(name => !!injectedWeb3[name]) || Object.keys(injectedWeb3).length > 0;
+    }
+    /**
+     * Get the wallet extension instance (for advanced usage)
+     */
+    getExtension() {
+        return this.extension;
+    }
+}
+exports.BittensorWallet = BittensorWallet;

package/dist/wallet/ethereum.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Ethereum Wallet Connection (MetaMask)
+ */
+export interface EthereumAccount {
+    address: string;
+    chainId?: string;
+}
+export declare class EthereumWallet {
+    private account;
+    private chainId;
+    /**
+     * Check if MetaMask is installed
+     */
+    static isMetaMaskInstalled(): boolean;
+    /**
+     * Connect to MetaMask wallet
+     * @returns Connected account information
+     */
+    connect(): Promise<EthereumAccount>;
+    /**
+     * Get currently connected account
+     */
+    getAccount(): EthereumAccount | null;
+    /**
+     * Get current chain ID
+     */
+    getChainId(): string | null;
+    /**
+     * Check if wallet is connected
+     */
+    isConnected(): boolean;
+    /**
+     * Disconnect wallet
+     */
+    disconnect(): void;
+    /**
+     * Get the ethereum provider (for advanced usage)
+     */
+    getProvider(): any;
+    private handleAccountsChanged;
+    private handleChainChanged;
+}

package/dist/wallet/ethereum.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * Ethereum Wallet Connection (MetaMask)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EthereumWallet = void 0;
+class EthereumWallet {
+    constructor() {
+        this.account = null;
+        this.chainId = null;
+    }
+    /**
+     * Check if MetaMask is installed
+     */
+    static isMetaMaskInstalled() {
+        if (typeof window === 'undefined') {
+            return false;
+        }
+        return typeof window.ethereum !== 'undefined' && window.ethereum.isMetaMask;
+    }
+    /**
+     * Connect to MetaMask wallet
+     * @returns Connected account information
+     */
+    async connect() {
+        if (typeof window === 'undefined') {
+            throw new Error('EthereumWallet: Browser environment required');
+        }
+        if (!EthereumWallet.isMetaMaskInstalled()) {
+            throw new Error('MetaMask is not installed. Please install MetaMask extension from https://metamask.io/');
+        }
+        const ethereum = window.ethereum;
+        try {
+            // Request account access - this will trigger MetaMask popup
+            const accounts = await ethereum.request({ method: 'eth_requestAccounts' });
+            if (!accounts || accounts.length === 0) {
+                throw new Error('No accounts found. Please unlock MetaMask and try again.');
+            }
+            // Get chain ID
+            const chainId = await ethereum.request({ method: 'eth_chainId' });
+            this.account = {
+                address: accounts[0],
+                chainId: chainId
+            };
+            this.chainId = chainId;
+            // Listen for account changes
+            ethereum.on('accountsChanged', this.handleAccountsChanged.bind(this));
+            ethereum.on('chainChanged', this.handleChainChanged.bind(this));
+            return this.account;
+        }
+        catch (error) {
+            if (error.code === 4001) {
+                throw new Error('User rejected the connection request');
+            }
+            throw new Error(`Failed to connect to MetaMask: ${error.message || error}`);
+        }
+    }
+    /**
+     * Get currently connected account
+     */
+    getAccount() {
+        return this.account;
+    }
+    /**
+     * Get current chain ID
+     */
+    getChainId() {
+        return this.chainId;
+    }
+    /**
+     * Check if wallet is connected
+     */
+    isConnected() {
+        return this.account !== null;
+    }
+    /**
+     * Disconnect wallet
+     */
+    disconnect() {
+        this.account = null;
+        this.chainId = null;
+    }
+    /**
+     * Get the ethereum provider (for advanced usage)
+     */
+    getProvider() {
+        if (typeof window === 'undefined') {
+            return null;
+        }
+        return window.ethereum;
+    }
+    handleAccountsChanged(accounts) {
+        if (accounts.length === 0) {
+            this.disconnect();
+        }
+        else if (this.account && accounts[0] !== this.account.address) {
+            this.account.address = accounts[0];
+        }
+    }
+    handleChainChanged(chainId) {
+        this.chainId = chainId;
+        if (this.account) {
+            this.account.chainId = chainId;
+        }
+    }
+}
+exports.EthereumWallet = EthereumWallet;

package/dist/wallet/solana.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Solana Wallet Connection (Phantom)
+ */
+export interface SolanaAccount {
+    address: string;
+    publicKey: string;
+}
+export declare class SolanaWallet {
+    private account;
+    /**
+     * Check if Phantom is installed
+     */
+    static isPhantomInstalled(): boolean;
+    /**
+     * Connect to Phantom wallet
+     * @returns Connected account information
+     */
+    connect(): Promise<SolanaAccount>;
+    /**
+     * Get currently connected account
+     */
+    getAccount(): SolanaAccount | null;
+    /**
+     * Check if wallet is connected
+     */
+    isConnected(): boolean;
+    /**
+     * Disconnect wallet
+     */
+    disconnect(): void;
+    /**
+     * Get the Solana provider (for advanced usage)
+     */
+    getProvider(): any;
+    private handleDisconnect;
+}

package/dist/wallet/solana.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Solana Wallet Connection (Phantom)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaWallet = void 0;
+class SolanaWallet {
+    constructor() {
+        this.account = null;
+    }
+    /**
+     * Check if Phantom is installed
+     */
+    static isPhantomInstalled() {
+        if (typeof window === 'undefined') {
+            return false;
+        }
+        return typeof window.solana !== 'undefined' && window.solana.isPhantom;
+    }
+    /**
+     * Connect to Phantom wallet
+     * @returns Connected account information
+     */
+    async connect() {
+        if (typeof window === 'undefined') {
+            throw new Error('SolanaWallet: Browser environment required');
+        }
+        if (!SolanaWallet.isPhantomInstalled()) {
+            throw new Error('Phantom is not installed. Please install Phantom extension from https://phantom.app/');
+        }
+        const solana = window.solana;
+        try {
+            // Request connection - this will trigger Phantom popup
+            const response = await solana.connect();
+            if (!response || !response.publicKey) {
+                throw new Error('Failed to connect to Phantom wallet');
+            }
+            this.account = {
+                address: response.publicKey.toString(),
+                publicKey: response.publicKey.toString()
+            };
+            // Listen for disconnect
+            solana.on('disconnect', this.handleDisconnect.bind(this));
+            return this.account;
+        }
+        catch (error) {
+            if (error.code === 4001) {
+                throw new Error('User rejected the connection request');
+            }
+            throw new Error(`Failed to connect to Phantom: ${error.message || error}`);
+        }
+    }
+    /**
+     * Get currently connected account
+     */
+    getAccount() {
+        return this.account;
+    }
+    /**
+     * Check if wallet is connected
+     */
+    isConnected() {
+        return this.account !== null;
+    }
+    /**
+     * Disconnect wallet
+     */
+    disconnect() {
+        if (this.account && typeof window !== 'undefined') {
+            const solana = window.solana;
+            if (solana && solana.disconnect && typeof solana.disconnect === 'function') {
+                try {
+                    const disconnectResult = solana.disconnect();
+                    if (disconnectResult && typeof disconnectResult.catch === 'function') {
+                        disconnectResult.catch(() => {
+                            // Ignore disconnect errors
+                        });
+                    }
+                }
+                catch (error) {
+                    // Ignore disconnect errors
+                }
+            }
+        }
+        this.account = null;
+    }
+    /**
+     * Get the Solana provider (for advanced usage)
+     */
+    getProvider() {
+        if (typeof window === 'undefined') {
+            return null;
+        }
+        return window.solana;
+    }
+    handleDisconnect() {
+        this.disconnect();
+    }
+}
+exports.SolanaWallet = SolanaWallet;