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

package/dist/storage/StorageManager.js

@@ -0,0 +1,296 @@
+"use strict";
+/**
+ * Storage Manager - Handle IPFS storage operations via Thirdweb
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageManager = void 0;
+const storage_1 = require("thirdweb/storage");
+const types_1 = require("../types");
+/**
+ * StorageManager - Manage IPFS storage operations
+ *
+ * @example
+ * ```typescript
+ * // Upload file
+ * const result = await storageManager.upload(file);
+ * console.log('IPFS CID:', result.cid);
+ *
+ * // Download file
+ * const data = await storageManager.download(result.cid);
+ * ```
+ */
+class StorageManager {
+    constructor(client) {
+        this.client = client;
+        this.defaultGateway = 'https://ipfs.io/ipfs/';
+    }
+    /**
+     * Upload file to IPFS
+     * @param file File to upload (File, Blob, or Buffer)
+     * @param options Upload options
+     * @returns Upload result with CID and URL
+     */
+    async upload(file, options = {}) {
+        try {
+            let uploadData;
+            // Handle different file types
+            if (typeof file === 'string') {
+                // String data
+                uploadData = new Blob([file], { type: 'text/plain' });
+            }
+            else if (Buffer.isBuffer(file)) {
+                // Node.js Buffer - convert to Uint8Array for Blob compatibility
+                uploadData = new Blob([new Uint8Array(file)]);
+            }
+            else {
+                // File or Blob
+                uploadData = file;
+            }
+            // Upload to IPFS via Thirdweb
+            const uri = await (0, storage_1.upload)({
+                client: this.client,
+                files: [uploadData],
+            });
+            // Extract CID from URI (format: ipfs://CID)
+            const cid = uri.replace('ipfs://', '');
+            return {
+                cid,
+                url: uri,
+                gateway: `${this.defaultGateway}${cid}`,
+            };
+        }
+        catch (error) {
+            throw new types_1.StorageError(`Failed to upload to IPFS: ${error.message}`, { error });
+        }
+    }
+    /**
+     * Upload multiple files to IPFS
+     * @param files Array of files to upload
+     * @param options Upload options
+     * @returns Array of upload results
+     */
+    async uploadBatch(files, options = {}) {
+        try {
+            const uploadData = files.map((file) => {
+                if (typeof file === 'string') {
+                    // Convert string to File object
+                    return new File([file], 'file.txt', { type: 'text/plain' });
+                }
+                else if (Buffer.isBuffer(file)) {
+                    // Convert Buffer to File object
+                    return new File([new Uint8Array(file)], 'file.bin', { type: 'application/octet-stream' });
+                }
+                else {
+                    return file;
+                }
+            });
+            // Upload all files
+            const uris = await (0, storage_1.upload)({
+                client: this.client,
+                files: uploadData,
+            });
+            // Convert URI to CID format
+            const results = [];
+            const uriArray = Array.isArray(uris) ? uris : [uris];
+            for (const uri of uriArray) {
+                const cid = uri.replace('ipfs://', '');
+                results.push({
+                    cid,
+                    url: uri,
+                    gateway: `${this.defaultGateway}${cid}`,
+                });
+            }
+            return results;
+        }
+        catch (error) {
+            throw new types_1.StorageError(`Failed to batch upload to IPFS: ${error.message}`, { error });
+        }
+    }
+    /**
+     * Upload JSON data to IPFS
+     * @param data JSON data to upload
+     * @param options Upload options
+     * @returns Upload result
+     */
+    async uploadJSON(data, options = {}) {
+        try {
+            const jsonString = JSON.stringify(data, null, 2);
+            const blob = new Blob([jsonString], { type: 'application/json' });
+            return await this.upload(blob, options);
+        }
+        catch (error) {
+            throw new types_1.StorageError(`Failed to upload JSON to IPFS: ${error.message}`, { error });
+        }
+    }
+    /**
+     * Download file from IPFS
+     * @param cid IPFS CID or full URI
+     * @param options Download options
+     * @returns Downloaded data
+     */
+    async download(cid, options = {}) {
+        try {
+            // Normalize CID (remove ipfs:// prefix if present)
+            const normalizedCid = cid.replace('ipfs://', '');
+            const uri = `ipfs://${normalizedCid}`;
+            // Download from IPFS via Thirdweb
+            const data = await (0, storage_1.download)({
+                client: this.client,
+                uri,
+            });
+            return data;
+        }
+        catch (error) {
+            throw new types_1.StorageError(`Failed to download from IPFS: ${error.message}`, { cid, error });
+        }
+    }
+    /**
+     * Download JSON from IPFS
+     * @param cid IPFS CID or full URI
+     * @param options Download options
+     * @returns Parsed JSON data
+     */
+    async downloadJSON(cid, options = {}) {
+        try {
+            const data = await this.download(cid, options);
+            // If data is already parsed JSON, return it
+            if (typeof data === 'object') {
+                return data;
+            }
+            // If data is a Response object
+            if (data instanceof Response) {
+                return await data.json();
+            }
+            // If data is a string, parse it
+            if (typeof data === 'string') {
+                return JSON.parse(data);
+            }
+            // If data is a Blob, read and parse it
+            if (data instanceof Blob) {
+                const text = await data.text();
+                return JSON.parse(text);
+            }
+            return data;
+        }
+        catch (error) {
+            throw new types_1.StorageError(`Failed to download JSON from IPFS: ${error.message}`, { cid, error });
+        }
+    }
+    /**
+     * Get IPFS gateway URL for CID
+     * @param cid IPFS CID
+     * @param gateway Custom gateway URL (optional)
+     * @returns Gateway URL
+     */
+    getGatewayUrl(cid, gateway) {
+        const normalizedCid = cid.replace('ipfs://', '');
+        const baseGateway = gateway || this.defaultGateway;
+        return `${baseGateway}${normalizedCid}`;
+    }
+    /**
+     * Get IPFS URI from CID
+     * @param cid IPFS CID
+     * @returns IPFS URI
+     */
+    getIPFSUri(cid) {
+        const normalizedCid = cid.replace('ipfs://', '');
+        return `ipfs://${normalizedCid}`;
+    }
+    /**
+     * Upload metadata for NFT
+     * @param metadata NFT metadata object
+     * @returns Upload result with metadata URI
+     */
+    async uploadNFTMetadata(metadata) {
+        try {
+            return await this.uploadJSON(metadata);
+        }
+        catch (error) {
+            throw new types_1.StorageError(`Failed to upload NFT metadata: ${error.message}`, { error });
+        }
+    }
+    /**
+     * Upload directory to IPFS
+     * @param files Array of files with names
+     * @returns Upload result with directory CID
+     */
+    async uploadDirectory(files) {
+        try {
+            const uploadFiles = files.map((file) => {
+                let content;
+                if (typeof file.content === 'string') {
+                    content = new Blob([file.content], { type: 'text/plain' });
+                }
+                else if (Buffer.isBuffer(file.content)) {
+                    content = new Blob([new Uint8Array(file.content)]);
+                }
+                else {
+                    content = file.content;
+                }
+                // Add name property to the blob
+                return new File([content], file.name);
+            });
+            const uris = await (0, storage_1.upload)({
+                client: this.client,
+                files: uploadFiles,
+            });
+            // upload returns string or string[], handle both cases
+            const uri = Array.isArray(uris) ? uris[0] : uris;
+            const cid = uri.replace('ipfs://', '');
+            return {
+                cid,
+                url: uri,
+                gateway: `${this.defaultGateway}${cid}`,
+            };
+        }
+        catch (error) {
+            throw new types_1.StorageError(`Failed to upload directory to IPFS: ${error.message}`, { error });
+        }
+    }
+    /**
+     * Check if CID is valid
+     * @param cid CID to validate
+     * @returns True if valid
+     */
+    isValidCID(cid) {
+        const normalizedCid = cid.replace('ipfs://', '');
+        // Basic CID validation (checks for valid characters and length)
+        // CIDv0: Qm followed by 44 base58 characters
+        // CIDv1: starts with 'b' or 'z' followed by base32/base58 characters
+        const cidv0Regex = /^Qm[1-9A-HJ-NP-Za-km-z]{44}$/;
+        const cidv1Regex = /^[bz][a-z2-7]{58,}$/;
+        return cidv0Regex.test(normalizedCid) || cidv1Regex.test(normalizedCid);
+    }
+    /**
+     * Pin CID to ensure persistence
+     * Note: This requires a pinning service integration
+     * @param cid CID to pin
+     */
+    async pin(cid) {
+        // Thirdweb storage handles pinning automatically
+        // This is a placeholder for custom pinning service integration
+        console.log(`CID ${cid} is automatically pinned by Thirdweb`);
+    }
+    /**
+     * Unpin CID
+     * Note: This requires a pinning service integration
+     * @param cid CID to unpin
+     */
+    async unpin(cid) {
+        // Placeholder for custom pinning service integration
+        console.log(`Unpinning CID ${cid}`);
+    }
+    /**
+     * Get storage statistics
+     * @returns Storage statistics
+     */
+    async getStats() {
+        // Placeholder - implement actual statistics tracking
+        return {
+            totalUploads: 0,
+            totalSize: 0,
+        };
+    }
+}
+exports.StorageManager = StorageManager;
+exports.default = StorageManager;

package/dist/types.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Type definitions for Varity Client
+ */
+import type { Chain } from 'thirdweb';
+export interface ChainConfig {
+    chainId: number;
+    name: string;
+    rpcUrl: string;
+    nativeCurrency: {
+        name: string;
+        symbol: string;
+        decimals: number;
+    };
+    blockExplorer?: string;
+}
+export interface VarityClientConfig {
+    clientId?: string;
+    secretKey?: string;
+    chain?: 'varity-l3' | 'arbitrum-sepolia' | 'arbitrum-one' | Chain;
+    customChain?: ChainConfig;
+}
+export interface WalletConnectionOptions {
+    walletType: 'metamask' | 'walletconnect' | 'coinbase' | 'injected' | 'embedded';
+    walletConnectProjectId?: string;
+}
+export interface WalletInfo {
+    address: string;
+    balance: string;
+    balanceFormatted: string;
+    chainId: number;
+}
+export interface ContractDeployOptions {
+    abi: any[];
+    bytecode: string;
+    constructorArgs?: any[];
+}
+export interface ContractReadOptions {
+    address: string;
+    abi: any[];
+    functionName: string;
+    args?: any[];
+}
+export interface ContractWriteOptions {
+    address: string;
+    abi: any[];
+    functionName: string;
+    args?: any[];
+    value?: bigint;
+}
+export interface ContractEventFilter {
+    address: string;
+    abi: any[];
+    eventName: string;
+    fromBlock?: number;
+    toBlock?: number;
+}
+export interface ContractEvent {
+    eventName: string;
+    args: any;
+    blockNumber: number;
+    transactionHash: string;
+    logIndex: number;
+}
+export interface SIWEMessage {
+    domain: string;
+    address: string;
+    statement: string;
+    uri: string;
+    version: string;
+    chainId: number;
+    nonce: string;
+    issuedAt: string;
+    expirationTime?: string;
+    notBefore?: string;
+    requestId?: string;
+    resources?: string[];
+}
+export interface SIWESignatureResult {
+    message: string;
+    signature: string;
+}
+export interface SIWEVerifyResult {
+    success: boolean;
+    address?: string;
+    error?: string;
+}
+export interface SIWESession {
+    address: string;
+    chainId: number;
+    issuedAt: Date;
+    expiresAt: Date;
+    signature: string;
+}
+export interface StorageUploadOptions {
+    metadata?: Record<string, any>;
+    onProgress?: (progress: number) => void;
+}
+export interface StorageUploadResult {
+    cid: string;
+    url: string;
+    gateway: string;
+}
+export interface StorageDownloadOptions {
+    gateway?: string;
+}
+export interface TransactionOptions {
+    value?: bigint;
+    gasLimit?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+}
+export interface TransactionResult {
+    transactionHash: string;
+    blockNumber: number;
+    from: string;
+    to?: string;
+    gasUsed: bigint;
+    status: 'success' | 'failed';
+}
+export interface TransactionReceipt {
+    transactionHash: string;
+    blockNumber: number;
+    blockHash: string;
+    from: string;
+    to?: string;
+    gasUsed: bigint;
+    cumulativeGasUsed: bigint;
+    contractAddress?: string;
+    logs: any[];
+    status: 'success' | 'failed';
+}
+export interface USDCAmount {
+    raw: bigint;
+    formatted: string;
+    decimals: number;
+}
+export declare class VarityError extends Error {
+    code: string;
+    details?: any | undefined;
+    constructor(message: string, code: string, details?: any | undefined);
+}
+export declare class WalletError extends VarityError {
+    constructor(message: string, details?: any);
+}
+export declare class ContractError extends VarityError {
+    constructor(message: string, details?: any);
+}
+export declare class TransactionError extends VarityError {
+    constructor(message: string, details?: any);
+}
+export declare class StorageError extends VarityError {
+    constructor(message: string, details?: any);
+}
+export declare class AuthenticationError extends VarityError {
+    constructor(message: string, details?: any);
+}

package/dist/types.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Type definitions for Varity Client
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthenticationError = exports.StorageError = exports.TransactionError = exports.ContractError = exports.WalletError = exports.VarityError = void 0;
+// Error types
+class VarityError extends Error {
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'VarityError';
+    }
+}
+exports.VarityError = VarityError;
+class WalletError extends VarityError {
+    constructor(message, details) {
+        super(message, 'WALLET_ERROR', details);
+        this.name = 'WalletError';
+    }
+}
+exports.WalletError = WalletError;
+class ContractError extends VarityError {
+    constructor(message, details) {
+        super(message, 'CONTRACT_ERROR', details);
+        this.name = 'ContractError';
+    }
+}
+exports.ContractError = ContractError;
+class TransactionError extends VarityError {
+    constructor(message, details) {
+        super(message, 'TRANSACTION_ERROR', details);
+        this.name = 'TransactionError';
+    }
+}
+exports.TransactionError = TransactionError;
+class StorageError extends VarityError {
+    constructor(message, details) {
+        super(message, 'STORAGE_ERROR', details);
+        this.name = 'StorageError';
+    }
+}
+exports.StorageError = StorageError;
+class AuthenticationError extends VarityError {
+    constructor(message, details) {
+        super(message, 'AUTHENTICATION_ERROR', details);
+        this.name = 'AuthenticationError';
+    }
+}
+exports.AuthenticationError = AuthenticationError;

package/dist/utils/formatting.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Utility functions for formatting addresses, amounts, and other data
+ */
+import type { USDCAmount } from '../types';
+export declare const USDC_DECIMALS = 6;
+export declare const USDC_MULTIPLIER: bigint;
+/**
+ * Format USDC amount from raw value (6 decimals)
+ * @param amount Raw USDC amount in smallest unit
+ * @returns Formatted USDC string
+ * @example
+ * formatUSDC(1000000n) // "1.000000"
+ * formatUSDC(1500000n) // "1.500000"
+ */
+export declare function formatUSDC(amount: bigint): string;
+/**
+ * Parse USDC amount from string to raw value
+ * @param amount USDC amount as string (e.g., "1.5", "10", "0.000001")
+ * @returns Raw USDC amount in smallest unit
+ * @example
+ * parseUSDC("1.5") // 1500000n
+ * parseUSDC("10") // 10000000n
+ */
+export declare function parseUSDC(amount: string): bigint;
+/**
+ * Get USDC amount with both raw and formatted values
+ * @param amount Raw USDC amount or string
+ * @returns USDCAmount object
+ */
+export declare function getUSDCAmount(amount: bigint | string): USDCAmount;
+/**
+ * Validate Ethereum address
+ * @param address Address to validate
+ * @returns True if valid
+ */
+export declare function isValidAddress(address: string): boolean;
+/**
+ * Format Ethereum address (checksum)
+ * @param address Address to format
+ * @returns Checksummed address
+ */
+export declare function formatAddress(address: string): string;
+/**
+ * Shorten address for display
+ * @param address Full address
+ * @param chars Number of characters to show on each side
+ * @returns Shortened address
+ * @example
+ * shortenAddress("0x1234567890123456789012345678901234567890") // "0x1234...7890"
+ */
+export declare function shortenAddress(address: string, chars?: number): string;
+/**
+ * Format transaction hash for display
+ * @param hash Transaction hash
+ * @param chars Number of characters to show on each side
+ * @returns Shortened hash
+ */
+export declare function shortenTxHash(hash: string, chars?: number): string;
+/**
+ * Convert Wei to Ether
+ * @param wei Amount in Wei
+ * @returns Amount in Ether as string
+ */
+export declare function formatEther(wei: bigint): string;
+/**
+ * Parse Ether to Wei
+ * @param ether Amount in Ether as string
+ * @returns Amount in Wei
+ */
+export declare function parseEther(ether: string): bigint;
+/**
+ * Get chain name from chain ID
+ * @param chainId Chain ID
+ * @returns Chain name
+ */
+export declare function getChainName(chainId: number): string;
+/**
+ * Get block explorer URL
+ * @param chainId Chain ID
+ * @returns Block explorer URL
+ */
+export declare function getBlockExplorerUrl(chainId: number): string;
+/**
+ * Get transaction URL in block explorer
+ * @param chainId Chain ID
+ * @param txHash Transaction hash
+ * @returns Transaction URL
+ */
+export declare function getTxUrl(chainId: number, txHash: string): string;
+/**
+ * Get address URL in block explorer
+ * @param chainId Chain ID
+ * @param address Address
+ * @returns Address URL
+ */
+export declare function getAddressUrl(chainId: number, address: string): string;
+/**
+ * Format timestamp to date string
+ * @param timestamp Unix timestamp in seconds
+ * @returns Formatted date string
+ */
+export declare function formatTimestamp(timestamp: number): string;
+/**
+ * Format gas amount for display
+ * @param gas Gas amount in wei
+ * @returns Formatted gas string
+ */
+export declare function formatGas(gas: bigint): string;
+/**
+ * Calculate percentage
+ * @param value Current value
+ * @param total Total value
+ * @param decimals Number of decimal places
+ * @returns Percentage string
+ */
+export declare function formatPercentage(value: number, total: number, decimals?: number): string;
+/**
+ * Format large numbers with K, M, B suffixes
+ * @param num Number to format
+ * @param decimals Number of decimal places
+ * @returns Formatted number string
+ */
+export declare function formatNumber(num: number, decimals?: number): string;