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

package/dist/contracts/ContractManager.js

@@ -0,0 +1,306 @@
+"use strict";
+/**
+ * Contract Manager - Handle smart contract interactions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractManager = void 0;
+const thirdweb_1 = require("thirdweb");
+const deploys_1 = require("thirdweb/deploys");
+const types_1 = require("../types");
+/**
+ * ContractManager - Manage smart contract operations
+ *
+ * @example
+ * ```typescript
+ * // Read from contract
+ * const balance = await contractManager.read({
+ *   address: '0x...',
+ *   abi: ERC20_ABI,
+ *   functionName: 'balanceOf',
+ *   args: ['0x...']
+ * });
+ *
+ * // Write to contract
+ * const result = await contractManager.write({
+ *   address: '0x...',
+ *   abi: ERC20_ABI,
+ *   functionName: 'transfer',
+ *   args: ['0x...', 1000000n]
+ * }, account);
+ * ```
+ */
+class ContractManager {
+    constructor(client, chain) {
+        this.client = client;
+        this.chain = chain;
+    }
+    /**
+     * Get contract instance
+     * @param address Contract address
+     * @param abi Contract ABI
+     * @returns Contract instance
+     */
+    getContractInstance(address, abi) {
+        return (0, thirdweb_1.getContract)({
+            client: this.client,
+            chain: this.chain,
+            address,
+            abi,
+        });
+    }
+    /**
+     * Read from contract (no gas required)
+     * @param options Contract read options
+     * @returns Read result
+     */
+    async read(options) {
+        try {
+            const contract = this.getContractInstance(options.address, options.abi);
+            const result = await (0, thirdweb_1.readContract)({
+                contract,
+                method: options.functionName,
+                params: options.args || [],
+            });
+            return result;
+        }
+        catch (error) {
+            throw new types_1.ContractError(`Failed to read from contract: ${error.message}`, {
+                address: options.address,
+                functionName: options.functionName,
+                error,
+            });
+        }
+    }
+    /**
+     * Write to contract (requires gas and wallet signature)
+     * @param options Contract write options
+     * @param account Wallet account
+     * @returns Transaction result
+     */
+    async write(options, account) {
+        try {
+            const contract = this.getContractInstance(options.address, options.abi);
+            // Prepare contract call
+            const transaction = (0, thirdweb_1.prepareContractCall)({
+                contract,
+                method: options.functionName,
+                params: options.args || [],
+                value: options.value,
+            });
+            // Send transaction
+            const result = await (0, thirdweb_1.sendTransaction)({
+                transaction,
+                account,
+            });
+            return {
+                transactionHash: result.transactionHash,
+                blockNumber: 0, // Will be filled after confirmation
+                from: account.address,
+                to: options.address,
+                gasUsed: BigInt(0), // Will be filled after confirmation
+                status: 'success',
+            };
+        }
+        catch (error) {
+            throw new types_1.ContractError(`Failed to write to contract: ${error.message}`, {
+                address: options.address,
+                functionName: options.functionName,
+                error,
+            });
+        }
+    }
+    /**
+     * Deploy new contract
+     * @param options Deployment options
+     * @param account Deployer account
+     * @returns Deployed contract address and transaction
+     */
+    async deploy(options, account) {
+        try {
+            // deployContract in v5 returns the contract address as a string
+            const contractAddress = await (0, deploys_1.deployContract)({
+                client: this.client,
+                chain: this.chain,
+                account,
+                abi: options.abi || [],
+                bytecode: options.bytecode,
+                constructorParams: {}, // v5 expects params as object
+            });
+            return {
+                address: contractAddress,
+                transactionHash: '', // v5 doesn't return transactionHash directly
+            };
+        }
+        catch (error) {
+            throw new types_1.ContractError(`Failed to deploy contract: ${error.message}`, {
+                error,
+            });
+        }
+    }
+    /**
+     * Get contract events
+     * @param filter Event filter options
+     * @returns Array of events
+     */
+    async getEvents(filter) {
+        try {
+            const contract = this.getContractInstance(filter.address, filter.abi);
+            // Prepare event using prepareEvent with proper event signature format
+            const preparedEvent = (0, thirdweb_1.prepareEvent)({
+                signature: filter.eventName,
+            });
+            const events = await (0, thirdweb_1.getContractEvents)({
+                contract,
+                events: [preparedEvent],
+                fromBlock: BigInt(filter.fromBlock || 0),
+                toBlock: filter.toBlock ? BigInt(filter.toBlock) : undefined,
+            });
+            return events.map((event) => ({
+                eventName: filter.eventName,
+                args: event.args,
+                blockNumber: Number(event.blockNumber),
+                transactionHash: event.transactionHash,
+                logIndex: event.logIndex,
+            }));
+        }
+        catch (error) {
+            throw new types_1.ContractError(`Failed to get contract events: ${error.message}`, {
+                address: filter.address,
+                eventName: filter.eventName,
+                error,
+            });
+        }
+    }
+    /**
+     * Listen to contract events (real-time)
+     * @param filter Event filter options
+     * @param callback Event callback
+     * @returns Cleanup function
+     */
+    watchEvents(filter, callback) {
+        const contract = this.getContractInstance(filter.address, filter.abi);
+        let isActive = true;
+        // Poll for new events
+        const pollInterval = setInterval(async () => {
+            if (!isActive)
+                return;
+            try {
+                const latestBlock = filter.toBlock || 'latest';
+                const events = await this.getEvents({
+                    ...filter,
+                    fromBlock: filter.fromBlock,
+                    toBlock: typeof latestBlock === 'string' ? undefined : latestBlock,
+                });
+                events.forEach(callback);
+            }
+            catch (error) {
+                console.error('Error watching events:', error);
+            }
+        }, 5000); // Poll every 5 seconds
+        // Return cleanup function
+        return () => {
+            isActive = false;
+            clearInterval(pollInterval);
+        };
+    }
+    /**
+     * Estimate gas for contract call
+     * @param options Contract write options
+     * @param account Wallet account
+     * @returns Estimated gas
+     */
+    async estimateGas(options, account) {
+        try {
+            const contract = this.getContractInstance(options.address, options.abi);
+            const transaction = (0, thirdweb_1.prepareContractCall)({
+                contract,
+                method: options.functionName,
+                params: options.args || [],
+                value: options.value,
+            });
+            // Estimate gas (this is a simplified version)
+            // In production, use proper gas estimation
+            return BigInt(200000); // Default gas limit
+        }
+        catch (error) {
+            throw new types_1.ContractError(`Failed to estimate gas: ${error.message}`, {
+                address: options.address,
+                functionName: options.functionName,
+                error,
+            });
+        }
+    }
+    /**
+     * Batch read multiple contract calls
+     * @param calls Array of read options
+     * @returns Array of results
+     */
+    async batchRead(calls) {
+        try {
+            const results = await Promise.all(calls.map((call) => this.read(call)));
+            return results;
+        }
+        catch (error) {
+            throw new types_1.ContractError(`Failed to batch read: ${error.message}`, {
+                error,
+            });
+        }
+    }
+    /**
+     * Batch write multiple contract calls (in sequence)
+     * @param calls Array of write options
+     * @param account Wallet account
+     * @returns Array of transaction results
+     */
+    async batchWrite(calls, account) {
+        const results = [];
+        for (const call of calls) {
+            try {
+                const result = await this.write(call, account);
+                results.push(result);
+            }
+            catch (error) {
+                throw new types_1.ContractError(`Failed to execute batch write at index ${results.length}: ${error.message}`, {
+                    completedCalls: results.length,
+                    error,
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Check if contract exists at address
+     * @param address Contract address
+     * @returns True if contract exists
+     */
+    async contractExists(address) {
+        try {
+            // Try to get contract code
+            // This is a simplified check
+            return true; // In production, check for bytecode
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get contract bytecode
+     * @param address Contract address
+     * @returns Contract bytecode
+     */
+    async getBytecode(address) {
+        try {
+            // Get contract bytecode
+            // This requires additional Thirdweb SDK methods
+            return '0x'; // Placeholder
+        }
+        catch (error) {
+            throw new types_1.ContractError(`Failed to get bytecode: ${error.message}`, {
+                address,
+                error,
+            });
+        }
+    }
+}
+exports.ContractManager = ContractManager;
+exports.default = ContractManager;

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Varity JavaScript/TypeScript Client Library
+ *
+ * Comprehensive SDK for Varity L3 blockchain interactions powered by Thirdweb.
+ *
+ * @packageDocumentation
+ */
+export { VarityClient, VARITY_L3_CHAIN, ARBITRUM_SEPOLIA_CHAIN, ARBITRUM_ONE_CHAIN } from './VarityClient';
+export { default as VarityClientClass } from './VarityClient';
+export { ContractManager } from './contracts/ContractManager';
+export { WalletManager } from './wallet/WalletManager';
+export { SIWEAuth } from './auth/SIWEAuth';
+export { StorageManager } from './storage/StorageManager';
+export type { VarityClientConfig, ChainConfig, WalletConnectionOptions, WalletInfo, ContractDeployOptions, ContractReadOptions, ContractWriteOptions, ContractEventFilter, ContractEvent, SIWEMessage, SIWESignatureResult, SIWEVerifyResult, SIWESession, StorageUploadOptions, StorageUploadResult, StorageDownloadOptions, TransactionOptions, TransactionResult, TransactionReceipt, USDCAmount, } from './types';
+export { VarityError, WalletError, ContractError, TransactionError, StorageError, AuthenticationError, } from './types';
+export { formatUSDC, parseUSDC, getUSDCAmount, USDC_DECIMALS, USDC_MULTIPLIER, isValidAddress, formatAddress, shortenAddress, shortenTxHash, getTxUrl, getAddressUrl, formatEther, parseEther, formatGas, formatPercentage, formatNumber, formatTimestamp, getChainName, getBlockExplorerUrl, } from './utils/formatting';
+export { useVarityClient, useVarityWallet, useVarityBalance, useVarityContract, useVarityAuth, useVarityStorage, useVarityChain, } from './react/hooks';
+export { default } from './VarityClient';

package/dist/index.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Varity JavaScript/TypeScript Client Library
+ *
+ * Comprehensive SDK for Varity L3 blockchain interactions powered by Thirdweb.
+ *
+ * @packageDocumentation
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.useVarityChain = exports.useVarityStorage = exports.useVarityAuth = exports.useVarityContract = exports.useVarityBalance = exports.useVarityWallet = exports.useVarityClient = exports.getBlockExplorerUrl = exports.getChainName = exports.formatTimestamp = exports.formatNumber = exports.formatPercentage = exports.formatGas = exports.parseEther = exports.formatEther = exports.getAddressUrl = exports.getTxUrl = exports.shortenTxHash = exports.shortenAddress = exports.formatAddress = exports.isValidAddress = exports.USDC_MULTIPLIER = exports.USDC_DECIMALS = exports.getUSDCAmount = exports.parseUSDC = exports.formatUSDC = exports.AuthenticationError = exports.StorageError = exports.TransactionError = exports.ContractError = exports.WalletError = exports.VarityError = exports.StorageManager = exports.SIWEAuth = exports.WalletManager = exports.ContractManager = exports.VarityClientClass = exports.ARBITRUM_ONE_CHAIN = exports.ARBITRUM_SEPOLIA_CHAIN = exports.VARITY_L3_CHAIN = exports.VarityClient = void 0;
+// Main client
+var VarityClient_1 = require("./VarityClient");
+Object.defineProperty(exports, "VarityClient", { enumerable: true, get: function () { return VarityClient_1.VarityClient; } });
+Object.defineProperty(exports, "VARITY_L3_CHAIN", { enumerable: true, get: function () { return VarityClient_1.VARITY_L3_CHAIN; } });
+Object.defineProperty(exports, "ARBITRUM_SEPOLIA_CHAIN", { enumerable: true, get: function () { return VarityClient_1.ARBITRUM_SEPOLIA_CHAIN; } });
+Object.defineProperty(exports, "ARBITRUM_ONE_CHAIN", { enumerable: true, get: function () { return VarityClient_1.ARBITRUM_ONE_CHAIN; } });
+var VarityClient_2 = require("./VarityClient");
+Object.defineProperty(exports, "VarityClientClass", { enumerable: true, get: function () { return __importDefault(VarityClient_2).default; } });
+// Managers
+var ContractManager_1 = require("./contracts/ContractManager");
+Object.defineProperty(exports, "ContractManager", { enumerable: true, get: function () { return ContractManager_1.ContractManager; } });
+var WalletManager_1 = require("./wallet/WalletManager");
+Object.defineProperty(exports, "WalletManager", { enumerable: true, get: function () { return WalletManager_1.WalletManager; } });
+var SIWEAuth_1 = require("./auth/SIWEAuth");
+Object.defineProperty(exports, "SIWEAuth", { enumerable: true, get: function () { return SIWEAuth_1.SIWEAuth; } });
+var StorageManager_1 = require("./storage/StorageManager");
+Object.defineProperty(exports, "StorageManager", { enumerable: true, get: function () { return StorageManager_1.StorageManager; } });
+// Error types
+var types_1 = require("./types");
+Object.defineProperty(exports, "VarityError", { enumerable: true, get: function () { return types_1.VarityError; } });
+Object.defineProperty(exports, "WalletError", { enumerable: true, get: function () { return types_1.WalletError; } });
+Object.defineProperty(exports, "ContractError", { enumerable: true, get: function () { return types_1.ContractError; } });
+Object.defineProperty(exports, "TransactionError", { enumerable: true, get: function () { return types_1.TransactionError; } });
+Object.defineProperty(exports, "StorageError", { enumerable: true, get: function () { return types_1.StorageError; } });
+Object.defineProperty(exports, "AuthenticationError", { enumerable: true, get: function () { return types_1.AuthenticationError; } });
+// Utility functions
+var formatting_1 = require("./utils/formatting");
+// USDC utilities
+Object.defineProperty(exports, "formatUSDC", { enumerable: true, get: function () { return formatting_1.formatUSDC; } });
+Object.defineProperty(exports, "parseUSDC", { enumerable: true, get: function () { return formatting_1.parseUSDC; } });
+Object.defineProperty(exports, "getUSDCAmount", { enumerable: true, get: function () { return formatting_1.getUSDCAmount; } });
+Object.defineProperty(exports, "USDC_DECIMALS", { enumerable: true, get: function () { return formatting_1.USDC_DECIMALS; } });
+Object.defineProperty(exports, "USDC_MULTIPLIER", { enumerable: true, get: function () { return formatting_1.USDC_MULTIPLIER; } });
+// Address utilities
+Object.defineProperty(exports, "isValidAddress", { enumerable: true, get: function () { return formatting_1.isValidAddress; } });
+Object.defineProperty(exports, "formatAddress", { enumerable: true, get: function () { return formatting_1.formatAddress; } });
+Object.defineProperty(exports, "shortenAddress", { enumerable: true, get: function () { return formatting_1.shortenAddress; } });
+// Transaction utilities
+Object.defineProperty(exports, "shortenTxHash", { enumerable: true, get: function () { return formatting_1.shortenTxHash; } });
+Object.defineProperty(exports, "getTxUrl", { enumerable: true, get: function () { return formatting_1.getTxUrl; } });
+Object.defineProperty(exports, "getAddressUrl", { enumerable: true, get: function () { return formatting_1.getAddressUrl; } });
+// Formatting utilities
+Object.defineProperty(exports, "formatEther", { enumerable: true, get: function () { return formatting_1.formatEther; } });
+Object.defineProperty(exports, "parseEther", { enumerable: true, get: function () { return formatting_1.parseEther; } });
+Object.defineProperty(exports, "formatGas", { enumerable: true, get: function () { return formatting_1.formatGas; } });
+Object.defineProperty(exports, "formatPercentage", { enumerable: true, get: function () { return formatting_1.formatPercentage; } });
+Object.defineProperty(exports, "formatNumber", { enumerable: true, get: function () { return formatting_1.formatNumber; } });
+Object.defineProperty(exports, "formatTimestamp", { enumerable: true, get: function () { return formatting_1.formatTimestamp; } });
+// Chain utilities
+Object.defineProperty(exports, "getChainName", { enumerable: true, get: function () { return formatting_1.getChainName; } });
+Object.defineProperty(exports, "getBlockExplorerUrl", { enumerable: true, get: function () { return formatting_1.getBlockExplorerUrl; } });
+// React hooks (optional)
+var hooks_1 = require("./react/hooks");
+Object.defineProperty(exports, "useVarityClient", { enumerable: true, get: function () { return hooks_1.useVarityClient; } });
+Object.defineProperty(exports, "useVarityWallet", { enumerable: true, get: function () { return hooks_1.useVarityWallet; } });
+Object.defineProperty(exports, "useVarityBalance", { enumerable: true, get: function () { return hooks_1.useVarityBalance; } });
+Object.defineProperty(exports, "useVarityContract", { enumerable: true, get: function () { return hooks_1.useVarityContract; } });
+Object.defineProperty(exports, "useVarityAuth", { enumerable: true, get: function () { return hooks_1.useVarityAuth; } });
+Object.defineProperty(exports, "useVarityStorage", { enumerable: true, get: function () { return hooks_1.useVarityStorage; } });
+Object.defineProperty(exports, "useVarityChain", { enumerable: true, get: function () { return hooks_1.useVarityChain; } });
+// Default export
+var VarityClient_3 = require("./VarityClient");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(VarityClient_3).default; } });

package/dist/react/hooks.d.ts

@@ -0,0 +1,170 @@
+/**
+ * React Hooks for Varity Client
+ *
+ * Provides easy-to-use React hooks for blockchain interactions
+ */
+import { VarityClient } from '../VarityClient';
+import type { VarityClientConfig, WalletConnectionOptions, WalletInfo, ContractReadOptions, ContractWriteOptions, SIWESession, StorageUploadOptions, StorageUploadResult } from '../types';
+import type { Account } from 'thirdweb/wallets';
+/**
+ * useVarityClient - Create and manage Varity client instance
+ *
+ * @example
+ * ```typescript
+ * function App() {
+ *   const client = useVarityClient({ chain: 'varity-l3' });
+ *
+ *   return <div>Chain: {client.getChainName()}</div>;
+ * }
+ * ```
+ */
+export declare function useVarityClient(config?: VarityClientConfig): VarityClient;
+/**
+ * useVarityWallet - Manage wallet connection and state
+ *
+ * @example
+ * ```typescript
+ * function WalletButton() {
+ *   const { connect, disconnect, isConnected, account, balance } = useVarityWallet(client);
+ *
+ *   if (isConnected) {
+ *     return <button onClick={disconnect}>Disconnect ({balance})</button>;
+ *   }
+ *
+ *   return <button onClick={() => connect({ walletType: 'metamask' })}>Connect</button>;
+ * }
+ * ```
+ */
+export declare function useVarityWallet(client: VarityClient): {
+    connect: (options: WalletConnectionOptions) => Promise<void>;
+    disconnect: () => void;
+    isConnected: boolean;
+    isConnecting: boolean;
+    account: Account | null;
+    walletInfo: WalletInfo | null;
+    address: string | null;
+    balance: string;
+    chainId: number | null;
+    refreshBalance: () => Promise<void>;
+    error: Error | null;
+};
+/**
+ * useVarityBalance - Track wallet balance with auto-refresh
+ *
+ * @example
+ * ```typescript
+ * function BalanceDisplay() {
+ *   const { balance, isLoading, refresh } = useVarityBalance(client);
+ *
+ *   return (
+ *     <div>
+ *       Balance: {balance}
+ *       <button onClick={refresh}>Refresh</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useVarityBalance(client: VarityClient, autoRefresh?: boolean, refreshInterval?: number): {
+    balance: string;
+    isLoading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+};
+/**
+ * useVarityContract - Interact with smart contracts
+ *
+ * @example
+ * ```typescript
+ * function TokenBalance() {
+ *   const { read, write, isLoading } = useVarityContract(client, account);
+ *
+ *   const balance = read({
+ *     address: '0x...',
+ *     abi: ERC20_ABI,
+ *     functionName: 'balanceOf',
+ *     args: ['0x...']
+ *   });
+ *
+ *   return <div>Balance: {balance}</div>;
+ * }
+ * ```
+ */
+export declare function useVarityContract(client: VarityClient, account: Account | null): {
+    read: (options: ContractReadOptions) => Promise<any>;
+    write: (options: ContractWriteOptions) => Promise<import("../types").TransactionResult>;
+    isLoading: boolean;
+    error: Error | null;
+};
+/**
+ * useVarityAuth - Manage SIWE authentication
+ *
+ * @example
+ * ```typescript
+ * function AuthButton() {
+ *   const { signIn, signOut, isAuthenticated, session } = useVarityAuth(client, account);
+ *
+ *   if (isAuthenticated) {
+ *     return <button onClick={signOut}>Sign Out</button>;
+ *   }
+ *
+ *   return <button onClick={signIn}>Sign In with Ethereum</button>;
+ * }
+ * ```
+ */
+export declare function useVarityAuth(client: VarityClient, account: Account | null): {
+    signIn: (statement?: string) => Promise<SIWESession>;
+    signOut: () => void;
+    isAuthenticated: boolean;
+    session: SIWESession | null;
+    isLoading: boolean;
+    error: Error | null;
+};
+/**
+ * useVarityStorage - Upload and download from IPFS
+ *
+ * @example
+ * ```typescript
+ * function FileUpload() {
+ *   const { upload, isUploading, uploadProgress } = useVarityStorage(client);
+ *
+ *   const handleUpload = async (file: File) => {
+ *     const result = await upload(file);
+ *     console.log('Uploaded to:', result.gateway);
+ *   };
+ *
+ *   return <input type="file" onChange={(e) => handleUpload(e.target.files[0])} />;
+ * }
+ * ```
+ */
+export declare function useVarityStorage(client: VarityClient): {
+    upload: (file: File | Blob | Buffer | string, options?: StorageUploadOptions) => Promise<StorageUploadResult>;
+    download: (cid: string) => Promise<any>;
+    uploadJSON: (data: any, options?: StorageUploadOptions) => Promise<StorageUploadResult>;
+    isUploading: boolean;
+    uploadProgress: number;
+    error: Error | null;
+};
+/**
+ * useVarityChain - Monitor chain information
+ *
+ * @example
+ * ```typescript
+ * function ChainInfo() {
+ *   const { chainId, chainName, isVarityL3 } = useVarityChain(client);
+ *
+ *   return <div>Connected to: {chainName} (ID: {chainId})</div>;
+ * }
+ * ```
+ */
+export declare function useVarityChain(client: VarityClient): {
+    chainId: number;
+    chainName: string;
+    rpcUrl: string;
+    nativeCurrency: {
+        name?: string;
+        symbol?: string;
+        decimals?: number;
+    };
+    isVarityL3: boolean;
+};