@varity-labs/client-js 2.0.0-alpha.1

package/dist/wallet/WalletManager.js

@@ -0,0 +1,355 @@
+"use strict";
+/**
+ * Wallet Manager - Handle wallet connections and operations
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletManager = void 0;
+const wallets_1 = require("thirdweb/wallets");
+const types_1 = require("../types");
+const formatting_1 = require("../utils/formatting");
+/**
+ * WalletManager - Manage wallet connections and operations
+ *
+ * @example
+ * ```typescript
+ * // Connect MetaMask
+ * const account = await walletManager.connect({ walletType: 'metamask' });
+ *
+ * // Get balance
+ * const balance = await walletManager.getBalance();
+ *
+ * // Disconnect
+ * walletManager.disconnect();
+ * ```
+ */
+class WalletManager {
+    constructor(client, chain) {
+        this.client = client;
+        this.chain = chain;
+        this.activeWallet = null;
+        this.activeAccount = null;
+    }
+    /**
+     * Connect wallet
+     * @param options Wallet connection options
+     * @returns Connected account
+     */
+    async connect(options) {
+        try {
+            let wallet;
+            switch (options.walletType) {
+                case 'metamask':
+                    wallet = (0, wallets_1.createWallet)('io.metamask');
+                    break;
+                case 'walletconnect':
+                    // WalletConnect v5 uses walletConnect() function
+                    wallet = (0, wallets_1.walletConnect)();
+                    break;
+                case 'coinbase':
+                    wallet = (0, wallets_1.createWallet)('com.coinbase.wallet');
+                    break;
+                case 'injected':
+                    // Use MetaMask as default injected wallet in v5
+                    wallet = (0, wallets_1.createWallet)('io.metamask');
+                    break;
+                case 'embedded':
+                    // In v5, use inAppWallet() function
+                    wallet = (0, wallets_1.inAppWallet)();
+                    break;
+                default:
+                    throw new types_1.WalletError(`Unsupported wallet type: ${options.walletType}`, { walletType: options.walletType });
+            }
+            // Connect wallet
+            const account = await wallet.connect({
+                client: this.client,
+                chain: this.chain,
+            });
+            this.activeWallet = wallet;
+            this.activeAccount = account;
+            return account;
+        }
+        catch (error) {
+            throw new types_1.WalletError(`Failed to connect wallet: ${error.message}`, { walletType: options.walletType, error });
+        }
+    }
+    /**
+     * Disconnect wallet
+     */
+    disconnect() {
+        if (this.activeWallet) {
+            this.activeWallet.disconnect();
+            this.activeWallet = null;
+            this.activeAccount = null;
+        }
+    }
+    /**
+     * Get connected account
+     * @returns Active account or null
+     */
+    getAccount() {
+        return this.activeAccount;
+    }
+    /**
+     * Check if wallet is connected
+     * @returns True if connected
+     */
+    isConnected() {
+        return this.activeAccount !== null;
+    }
+    /**
+     * Get wallet address
+     * @returns Wallet address or null
+     */
+    getAddress() {
+        return this.activeAccount?.address || null;
+    }
+    /**
+     * Get wallet balance (native currency)
+     * @returns Balance in wei/smallest unit
+     */
+    async getBalance() {
+        if (!this.activeAccount) {
+            throw new types_1.WalletError('No wallet connected');
+        }
+        try {
+            const balance = await (0, wallets_1.getWalletBalance)({
+                client: this.client,
+                chain: this.chain,
+                address: this.activeAccount.address,
+            });
+            return balance.value;
+        }
+        catch (error) {
+            throw new types_1.WalletError(`Failed to get balance: ${error.message}`, { error });
+        }
+    }
+    /**
+     * Get wallet info with balance
+     * @returns Wallet information
+     */
+    async getWalletInfo() {
+        if (!this.activeAccount) {
+            throw new types_1.WalletError('No wallet connected');
+        }
+        try {
+            const balance = await this.getBalance();
+            // Format based on native currency
+            const nativeCurrency = this.chain.nativeCurrency;
+            const isUSDC = nativeCurrency?.symbol === 'USDC' && nativeCurrency?.decimals === 6;
+            const balanceFormatted = isUSDC
+                ? (0, formatting_1.formatUSDC)(balance)
+                : this.formatBalance(balance, nativeCurrency?.decimals || 18);
+            return {
+                address: this.activeAccount.address,
+                balance: balance.toString(),
+                balanceFormatted,
+                chainId: this.chain.id,
+            };
+        }
+        catch (error) {
+            throw new types_1.WalletError(`Failed to get wallet info: ${error.message}`, { error });
+        }
+    }
+    /**
+     * Sign message
+     * @param message Message to sign
+     * @returns Signature
+     */
+    async signMessage(message) {
+        if (!this.activeAccount) {
+            throw new types_1.WalletError('No wallet connected');
+        }
+        try {
+            const signature = await this.activeAccount.signMessage({
+                message,
+            });
+            return signature;
+        }
+        catch (error) {
+            throw new types_1.WalletError(`Failed to sign message: ${error.message}`, { error });
+        }
+    }
+    /**
+     * Sign typed data (EIP-712)
+     * @param domain Domain data
+     * @param types Type definitions
+     * @param value Value to sign
+     * @returns Signature
+     */
+    async signTypedData(domain, types, value) {
+        if (!this.activeAccount) {
+            throw new types_1.WalletError('No wallet connected');
+        }
+        try {
+            const signature = await this.activeAccount.signTypedData({
+                domain,
+                types,
+                primaryType: Object.keys(types)[0],
+                message: value,
+            });
+            return signature;
+        }
+        catch (error) {
+            throw new types_1.WalletError(`Failed to sign typed data: ${error.message}`, { error });
+        }
+    }
+    /**
+     * Switch chain
+     * @param chainId Chain ID to switch to
+     */
+    async switchChain(chainId) {
+        if (!this.activeWallet) {
+            throw new types_1.WalletError('No wallet connected');
+        }
+        try {
+            // Import defineChain from thirdweb for runtime use
+            const { defineChain } = await Promise.resolve().then(() => __importStar(require('thirdweb')));
+            const targetChain = defineChain({ id: chainId });
+            await this.activeWallet.switchChain(targetChain);
+        }
+        catch (error) {
+            throw new types_1.WalletError(`Failed to switch chain: ${error.message}`, { chainId, error });
+        }
+    }
+    /**
+     * Get chain ID from wallet
+     * @returns Current chain ID
+     */
+    async getChainId() {
+        if (!this.activeAccount) {
+            throw new types_1.WalletError('No wallet connected');
+        }
+        return this.chain.id;
+    }
+    /**
+     * Send native currency transaction
+     * @param to Recipient address
+     * @param amount Amount to send (in wei/smallest unit)
+     * @returns Transaction hash
+     */
+    async sendTransaction(to, amount) {
+        if (!this.activeAccount) {
+            throw new types_1.WalletError('No wallet connected');
+        }
+        try {
+            // Create transaction
+            const transaction = await this.activeAccount.sendTransaction({
+                to,
+                value: amount,
+                chainId: this.chain.id,
+            });
+            return transaction.transactionHash;
+        }
+        catch (error) {
+            throw new types_1.WalletError(`Failed to send transaction: ${error.message}`, { to, amount: amount.toString(), error });
+        }
+    }
+    /**
+     * Get transaction count (nonce)
+     * @returns Transaction count
+     */
+    async getTransactionCount() {
+        if (!this.activeAccount) {
+            throw new types_1.WalletError('No wallet connected');
+        }
+        try {
+            // Get nonce
+            // This is a simplified version - in production, use proper nonce retrieval
+            return 0;
+        }
+        catch (error) {
+            throw new types_1.WalletError(`Failed to get transaction count: ${error.message}`, { error });
+        }
+    }
+    /**
+     * Format balance with decimals
+     * @param balance Balance in smallest unit
+     * @param decimals Number of decimals
+     * @returns Formatted balance string
+     */
+    formatBalance(balance, decimals) {
+        const divisor = BigInt(10 ** decimals);
+        const wholePart = balance / divisor;
+        const fractionalPart = balance % divisor;
+        const fractionalStr = fractionalPart.toString().padStart(decimals, '0');
+        return `${wholePart}.${fractionalStr}`;
+    }
+    /**
+     * Request wallet permissions
+     * @param permissions Permissions to request
+     */
+    async requestPermissions(permissions) {
+        if (!this.activeWallet) {
+            throw new types_1.WalletError('No wallet connected');
+        }
+        // Request permissions (implementation depends on wallet type)
+        console.log('Requesting permissions:', permissions);
+    }
+    /**
+     * Add custom token to wallet
+     * @param tokenAddress Token contract address
+     * @param symbol Token symbol
+     * @param decimals Token decimals
+     * @param image Token image URL
+     */
+    async addToken(tokenAddress, symbol, decimals, image) {
+        if (!this.activeWallet) {
+            throw new types_1.WalletError('No wallet connected');
+        }
+        try {
+            // Add token to wallet (MetaMask specific)
+            if (typeof window.ethereum !== 'undefined') {
+                await window.ethereum.request({
+                    method: 'wallet_watchAsset',
+                    params: {
+                        type: 'ERC20',
+                        options: {
+                            address: tokenAddress,
+                            symbol,
+                            decimals,
+                            image,
+                        },
+                    },
+                });
+            }
+        }
+        catch (error) {
+            throw new types_1.WalletError(`Failed to add token: ${error.message}`, { tokenAddress, error });
+        }
+    }
+}
+exports.WalletManager = WalletManager;
+exports.default = WalletManager;

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@varity-labs/client-js",
+  "version": "2.0.0-alpha.1",
+  "description": "Comprehensive JavaScript/TypeScript client library for Varity L3 blockchain - Powered by Thirdweb SDK",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "test": "jest --coverage",
+    "test:watch": "jest --watch",
+    "lint": "eslint src --ext .ts,.tsx",
+    "lint:fix": "eslint src --ext .ts,.tsx --fix",
+    "example": "ts-node examples/basic-usage.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "varity",
+    "blockchain",
+    "web3",
+    "thirdweb",
+    "arbitrum",
+    "l3",
+    "wallet",
+    "smart-contracts",
+    "ipfs",
+    "storage",
+    "siwe",
+    "usdc",
+    "depin",
+    "filecoin"
+  ],
+  "author": "Varity",
+  "license": "MIT",
+  "dependencies": {
+    "thirdweb": "^5.112.0",
+    "ethers": "^6.10.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.6",
+    "@types/jest": "^29.5.11",
+    "@types/react": "^18.2.48",
+    "typescript": "^5.3.3",
+    "ts-node": "^10.9.2",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
+    "eslint": "^8.56.0",
+    "@typescript-eslint/eslint-plugin": "^6.18.0",
+    "@typescript-eslint/parser": "^6.18.0",
+    "react": "^18.2.0"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/varity-labs/varity-sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/varity-labs/varity-sdk/issues"
+  },
+  "sideEffects": false
+}