@varity-labs/sdk 2.0.0-alpha.1

package/dist/thirdweb/EngineClient.js

@@ -0,0 +1,386 @@
+/**
+ * thirdweb Engine Client
+ *
+ * Production-grade transaction management infrastructure
+ * Replaces custom transaction queues with thirdweb's managed service
+ *
+ * Features:
+ * - Automatic transaction queueing and execution
+ * - Gas price optimization
+ * - Automatic retry with exponential backoff
+ * - Webhook notifications for transaction events
+ * - Multi-chain support
+ * - Production-ready scalability
+ */
+/**
+ * thirdweb Engine Client
+ *
+ * Manages blockchain transactions through thirdweb's production infrastructure
+ */
+export class EngineClient {
+    constructor(config) {
+        this.url = config.url.replace(/\/$/, ''); // Remove trailing slash
+        this.accessToken = config.accessToken;
+        this.backendWalletAddress = config.backendWalletAddress;
+    }
+    /**
+     * Send a transaction through Engine
+     *
+     * Automatically queues, optimizes gas, and retries failed transactions.
+     *
+     * @param params - Transaction parameters
+     * @returns Transaction result with queue ID
+     *
+     * @example Basic transaction
+     * ```typescript
+     * import { EngineClient, varityL3Testnet } from '@varity-labs/sdk';
+     * import { prepareContractCall } from 'thirdweb';
+     *
+     * const engine = new EngineClient({
+     *   url: 'https://engine.varity.so',
+     *   accessToken: process.env.ENGINE_ACCESS_TOKEN,
+     *   backendWalletAddress: '0x...'
+     * });
+     *
+     * // Prepare transaction
+     * const tx = prepareContractCall({
+     *   contract,
+     *   method: 'function transfer(address to, uint256 amount)',
+     *   params: [recipientAddress, amount]
+     * });
+     *
+     * // Send through Engine
+     * const result = await engine.sendTransaction({
+     *   chain: varityL3Testnet,
+     *   to: contract.address,
+     *   data: tx.data,
+     *   value: '0'
+     * });
+     *
+     * console.log('Queue ID:', result.queueId);
+     * ```
+     *
+     * @example With webhook notifications
+     * ```typescript
+     * const result = await engine.sendTransaction({
+     *   chain: varityL3Testnet,
+     *   to: contractAddress,
+     *   data: encodedData,
+     *   webhookUrl: 'https://myapp.com/api/webhook/engine'
+     * });
+     *
+     * // Your webhook will receive status updates:
+     * // { queueId, status: 'mined', transactionHash, blockNumber }
+     * ```
+     *
+     * @example With gas limit
+     * ```typescript
+     * const result = await engine.sendTransaction({
+     *   chain: varityL3Testnet,
+     *   to: contractAddress,
+     *   data: encodedData,
+     *   gasLimit: '500000' // Override estimated gas
+     * });
+     * ```
+     */
+    async sendTransaction(params) {
+        const response = await this.request('/transaction/write', {
+            method: 'POST',
+            body: JSON.stringify({
+                chainId: params.chain.id,
+                toAddress: params.to,
+                data: params.data,
+                value: params.value || '0',
+                gasLimit: params.gasLimit,
+                backendWalletAddress: this.backendWalletAddress,
+                webhookUrl: params.webhookUrl,
+            }),
+        });
+        return {
+            queueId: response.result.queueId,
+            status: 'queued',
+            timestamp: new Date(),
+        };
+    }
+    /**
+     * Deploy a contract through Engine
+     *
+     * Deploys smart contracts with automatic gas optimization and retry logic.
+     *
+     * @param params - Deployment parameters
+     * @returns Deployment result with queue ID
+     *
+     * @example Deploy ERC-721 NFT contract
+     * ```typescript
+     * import { EngineClient, varityL3Testnet } from '@varity-labs/sdk';
+     * import NFTContractABI from './abis/NFTContract.json';
+     * import NFTContractBytecode from './bytecode/NFTContract.json';
+     *
+     * const engine = new EngineClient({
+     *   url: 'https://engine.varity.so',
+     *   accessToken: process.env.ENGINE_ACCESS_TOKEN
+     * });
+     *
+     * const result = await engine.deployContract({
+     *   chain: varityL3Testnet,
+     *   abi: NFTContractABI,
+     *   bytecode: NFTContractBytecode.bytecode,
+     *   constructorArgs: [
+     *     'My NFT Collection',  // name
+     *     'MNFT',               // symbol
+     *     '0x...'               // owner address
+     *   ]
+     * });
+     *
+     * console.log('Deploying contract, Queue ID:', result.queueId);
+     * ```
+     *
+     * @example Deploy ERC-20 token
+     * ```typescript
+     * const result = await engine.deployContract({
+     *   chain: varityL3Testnet,
+     *   abi: ERC20ABI,
+     *   bytecode: ERC20Bytecode.bytecode,
+     *   constructorArgs: [
+     *     'My Token',           // name
+     *     'MTK',                // symbol
+     *     ethers.utils.parseEther('1000000')  // initial supply
+     *   ],
+     *   webhookUrl: 'https://myapp.com/api/webhook/deployment'
+     * });
+     * ```
+     *
+     * @example Deploy and wait for completion
+     * ```typescript
+     * const deployment = await engine.deployContract({
+     *   chain: varityL3Testnet,
+     *   abi: ContractABI,
+     *   bytecode: ContractBytecode.bytecode,
+     *   constructorArgs: []
+     * });
+     *
+     * // Wait for deployment to complete
+     * const completed = await engine.waitForTransaction(deployment.queueId);
+     * console.log('Contract deployed at:', completed.transactionHash);
+     * ```
+     */
+    async deployContract(params) {
+        const response = await this.request('/contract/deploy', {
+            method: 'POST',
+            body: JSON.stringify({
+                chainId: params.chain.id,
+                abi: params.abi,
+                bytecode: params.bytecode,
+                constructorArgs: params.constructorArgs || [],
+                backendWalletAddress: this.backendWalletAddress,
+                webhookUrl: params.webhookUrl,
+            }),
+        });
+        return {
+            queueId: response.result.queueId,
+            status: 'queued',
+            timestamp: new Date(),
+        };
+    }
+    /**
+     * Get transaction status
+     */
+    async getTransactionStatus(queueId) {
+        const response = await this.request(`/transaction/status/${queueId}`);
+        return {
+            queueId,
+            transactionHash: response.result.transactionHash,
+            status: response.result.status,
+            blockNumber: response.result.blockNumber,
+            errorMessage: response.result.errorMessage,
+            timestamp: new Date(response.result.timestamp),
+        };
+    }
+    /**
+     * Wait for transaction to be mined
+     *
+     * Polls Engine API until transaction is confirmed or fails.
+     *
+     * @param queueId - Engine queue ID from sendTransaction or deployContract
+     * @param options - Optional polling configuration
+     * @returns Completed transaction result
+     *
+     * @example Basic usage
+     * ```typescript
+     * import { EngineClient } from '@varity-labs/sdk';
+     *
+     * const engine = new EngineClient({ url, accessToken });
+     *
+     * // Send transaction
+     * const tx = await engine.sendTransaction({ ... });
+     *
+     * // Wait for confirmation (default: poll every 2s, timeout 5min)
+     * const result = await engine.waitForTransaction(tx.queueId);
+     * console.log('Transaction mined:', result.transactionHash);
+     * console.log('Block number:', result.blockNumber);
+     * ```
+     *
+     * @example With custom polling interval
+     * ```typescript
+     * // Poll every 5 seconds instead of default 2 seconds
+     * const result = await engine.waitForTransaction(queueId, {
+     *   pollInterval: 5000,  // 5 seconds
+     *   timeout: 600000      // 10 minutes
+     * });
+     * ```
+     *
+     * @example With error handling
+     * ```typescript
+     * try {
+     *   const result = await engine.waitForTransaction(queueId);
+     *   console.log('Success:', result.transactionHash);
+     * } catch (error) {
+     *   if (error.message.includes('timed out')) {
+     *     console.error('Transaction took too long');
+     *   } else if (error.message.includes('errored')) {
+     *     console.error('Transaction failed:', error.message);
+     *   }
+     * }
+     * ```
+     */
+    async waitForTransaction(queueId, options) {
+        const pollInterval = options?.pollInterval || 2000;
+        const timeout = options?.timeout || 300000;
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            const status = await this.getTransactionStatus(queueId);
+            if (status.status === 'mined') {
+                return status;
+            }
+            if (status.status === 'errored' || status.status === 'cancelled') {
+                throw new Error(`Transaction ${queueId} ${status.status}: ${status.errorMessage || 'Unknown error'}`);
+            }
+            // Wait before polling again
+            await new Promise(resolve => setTimeout(resolve, pollInterval));
+        }
+        throw new Error(`Transaction ${queueId} timed out after ${timeout}ms`);
+    }
+    /**
+     * Cancel a queued transaction
+     */
+    async cancelTransaction(queueId) {
+        await this.request(`/transaction/cancel/${queueId}`, {
+            method: 'POST',
+        });
+    }
+    /**
+     * Get backend wallet balance
+     */
+    async getWalletBalance(chainId, walletAddress) {
+        const address = walletAddress || this.backendWalletAddress;
+        if (!address) {
+            throw new Error('Wallet address required');
+        }
+        const response = await this.request(`/backend-wallet/${chainId}/get-balance?walletAddress=${address}`);
+        return response.result.balance;
+    }
+    /**
+     * Get all backend wallets
+     */
+    async getBackendWallets() {
+        const response = await this.request('/backend-wallet/get-all');
+        return response.result.wallets;
+    }
+    /**
+     * Get transaction nonce for a wallet
+     */
+    async getNonce(chainId, walletAddress) {
+        const address = walletAddress || this.backendWalletAddress;
+        if (!address) {
+            throw new Error('Wallet address required');
+        }
+        const response = await this.request(`/backend-wallet/${chainId}/get-nonce?walletAddress=${address}`);
+        return response.result.nonce;
+    }
+    /**
+     * Make HTTP request to Engine API
+     */
+    async request(endpoint, options) {
+        const url = `${this.url}${endpoint}`;
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.accessToken}`,
+                ...options?.headers,
+            },
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: response.statusText }));
+            throw new Error(`Engine request failed: ${error.error || error.message || 'Unknown error'}`);
+        }
+        return response.json();
+    }
+}
+/**
+ * Create Engine client instance
+ *
+ * Factory function for creating EngineClient instances.
+ *
+ * @param config - Engine configuration
+ * @returns Configured Engine client
+ *
+ * @example Basic setup
+ * ```typescript
+ * import { createEngineClient } from '@varity-labs/sdk';
+ *
+ * const engine = createEngineClient({
+ *   url: 'https://engine.varity.so',
+ *   accessToken: process.env.ENGINE_ACCESS_TOKEN
+ * });
+ *
+ * // Now use engine client
+ * const result = await engine.sendTransaction({ ... });
+ * ```
+ *
+ * @example With backend wallet
+ * ```typescript
+ * const engine = createEngineClient({
+ *   url: 'https://engine.varity.so',
+ *   accessToken: process.env.ENGINE_ACCESS_TOKEN,
+ *   backendWalletAddress: '0x...' // Default wallet for all transactions
+ * });
+ * ```
+ *
+ * @example Self-hosted Engine
+ * ```typescript
+ * const engine = createEngineClient({
+ *   url: 'https://my-engine.example.com',
+ *   accessToken: process.env.MY_ENGINE_TOKEN
+ * });
+ * ```
+ */
+export function createEngineClient(config) {
+    return new EngineClient(config);
+}
+/**
+ * Webhook handler helper
+ *
+ * Use this to handle Engine webhook notifications in your backend
+ */
+export function parseEngineWebhook(payload) {
+    return {
+        queueId: payload.queueId,
+        status: payload.status,
+        transactionHash: payload.transactionHash,
+        blockNumber: payload.blockNumber,
+        errorMessage: payload.errorMessage,
+        timestamp: payload.timestamp,
+    };
+}
+/**
+ * Verify Engine webhook signature (if configured)
+ */
+export function verifyEngineWebhook(payload, signature, secret) {
+    // Implement HMAC verification
+    // This is a placeholder - actual implementation would use crypto.subtle or similar
+    // to verify HMAC-SHA256 signature
+    // For now, return true (webhook verification can be implemented based on Engine's spec)
+    console.warn('Engine webhook verification not implemented - please implement HMAC verification');
+    return true;
+}

package/dist/thirdweb/GatewayClient.d.ts

@@ -0,0 +1,190 @@
+/**
+ * thirdweb Gateway Client
+ *
+ * Production-grade RPC infrastructure powered by thirdweb
+ * Provides reliable, fast, and scalable blockchain node access
+ *
+ * Features:
+ * - High-performance RPC endpoints
+ * - Automatic failover and load balancing
+ * - Request rate limiting and throttling
+ * - Chain-specific optimizations
+ * - Analytics and monitoring
+ * - WebSocket support for real-time data
+ */
+import type { Chain } from 'thirdweb';
+/**
+ * Gateway configuration
+ */
+export interface GatewayConfig {
+    /**
+     * API key for authenticated requests (optional)
+     */
+    apiKey?: string;
+    /**
+     * Custom gateway URL (optional)
+     */
+    gatewayUrl?: string;
+    /**
+     * Request timeout in milliseconds
+     */
+    timeout?: number;
+    /**
+     * Enable request retries
+     */
+    enableRetries?: boolean;
+    /**
+     * Maximum number of retries
+     */
+    maxRetries?: number;
+}
+/**
+ * RPC request options
+ */
+export interface RPCRequestOptions {
+    /**
+     * RPC method
+     */
+    method: string;
+    /**
+     * Method parameters
+     */
+    params?: any[];
+    /**
+     * Request timeout (overrides global setting)
+     */
+    timeout?: number;
+}
+/**
+ * RPC response
+ */
+export interface RPCResponse<T = any> {
+    /**
+     * Result data
+     */
+    result: T;
+    /**
+     * Request ID
+     */
+    id: number;
+    /**
+     * JSON-RPC version
+     */
+    jsonrpc: string;
+}
+/**
+ * Gateway statistics
+ */
+export interface GatewayStats {
+    /**
+     * Total requests made
+     */
+    totalRequests: number;
+    /**
+     * Successful requests
+     */
+    successfulRequests: number;
+    /**
+     * Failed requests
+     */
+    failedRequests: number;
+    /**
+     * Average response time (ms)
+     */
+    averageResponseTime: number;
+    /**
+     * Requests per minute
+     */
+    requestsPerMinute: number;
+    /**
+     * Error rate (percentage)
+     */
+    errorRate: number;
+}
+/**
+ * WebSocket connection options
+ */
+export interface WebSocketOptions {
+    /**
+     * Chain to connect to
+     */
+    chain: Chain;
+    /**
+     * Event handlers
+     */
+    onMessage?: (data: any) => void;
+    onError?: (error: Error) => void;
+    onConnect?: () => void;
+    onDisconnect?: () => void;
+    /**
+     * Auto-reconnect on disconnect
+     */
+    autoReconnect?: boolean;
+}
+/**
+ * thirdweb Gateway Client
+ *
+ * Production RPC infrastructure for blockchain applications
+ */
+export declare class GatewayClient {
+    private apiKey?;
+    private gatewayUrl;
+    private timeout;
+    private enableRetries;
+    private maxRetries;
+    private stats;
+    private requestId;
+    constructor(config?: GatewayConfig);
+    /**
+     * Get RPC URL for a specific chain
+     */
+    getRpcUrl(chain: Chain | number): string;
+    /**
+     * Get WebSocket URL for a specific chain
+     */
+    getWebSocketUrl(chain: Chain | number): string;
+    /**
+     * Make an RPC request
+     */
+    request<T = any>(chain: Chain | number, options: RPCRequestOptions): Promise<RPCResponse<T>>;
+    /**
+     * Batch multiple RPC requests
+     */
+    batchRequest<T = any>(chain: Chain | number, requests: RPCRequestOptions[]): Promise<RPCResponse<T>[]>;
+    /**
+     * Create a WebSocket connection
+     */
+    connectWebSocket(options: WebSocketOptions): WebSocket;
+    /**
+     * Subscribe to new blocks
+     */
+    subscribeToBlocks(chain: Chain | number, callback: (block: any) => void): Promise<() => void>;
+    /**
+     * Subscribe to contract events
+     */
+    subscribeToLogs(chain: Chain | number, filter: {
+        address?: string;
+        topics?: string[];
+    }, callback: (log: any) => void): Promise<() => void>;
+    /**
+     * Get gateway statistics
+     */
+    getStats(): GatewayStats;
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+    /**
+     * Make HTTP request with retry logic
+     */
+    private makeRequest;
+    /**
+     * Update statistics
+     */
+    private updateStats;
+}
+/**
+ * Create Gateway client instance
+ */
+export declare function createGatewayClient(config?: GatewayConfig): GatewayClient;
+//# sourceMappingURL=GatewayClient.d.ts.map

package/dist/thirdweb/GatewayClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GatewayClient.d.ts","sourceRoot":"","sources":["../../src/thirdweb/GatewayClient.ts"],"names":[],"mappings":"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"}