riskmarket-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,746 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var axios = require('axios');
+var ethers = require('ethers');
+
+/**
+ * Error types
+ */
+exports.ErrorType = void 0;
+(function (ErrorType) {
+    ErrorType["API_ERROR"] = "API_ERROR";
+    ErrorType["TRANSACTION_ERROR"] = "TRANSACTION_ERROR";
+    ErrorType["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+    ErrorType["NETWORK_ERROR"] = "NETWORK_ERROR";
+})(exports.ErrorType || (exports.ErrorType = {}));
+/**
+ * Custom SDK Error
+ */
+class SDKError extends Error {
+    constructor(message, type, details) {
+        super(message);
+        this.name = 'SDKError';
+        this.type = type;
+        this.details = details;
+    }
+}
+
+/**
+ * APIClient class for interacting with backend APIs
+ */
+class APIClient {
+    /**
+     * Initialize API client
+     * @param baseURL - Base URL for API endpoints
+     * @param apiKey - Optional API key for authentication
+     */
+    constructor(baseURL, apiKey) {
+        this.baseURL = baseURL;
+        this.apiKey = apiKey;
+        this.client = axios.create({
+            baseURL,
+            timeout: 30000,
+            headers: {
+                "Content-Type": "application/json",
+                ...(apiKey && { Authorization: `Bearer ${apiKey}` }),
+            },
+        });
+        // Add response interceptor for error handling
+        this.client.interceptors.response.use((response) => response, (error) => {
+            throw this.handleAPIError(error);
+        });
+    }
+    /**
+     * Handle API errors
+     * @private
+     */
+    handleAPIError(error) {
+        if (error.response) {
+            // Server responded with error status
+            const message = error.response.data?.message || error.message;
+            return new SDKError(`API Error: ${message}`, exports.ErrorType.API_ERROR, {
+                status: error.response.status,
+                data: error.response.data,
+            });
+        }
+        else if (error.request) {
+            // Request was made but no response
+            return new SDKError("No response from server", exports.ErrorType.NETWORK_ERROR, {
+                originalError: error,
+            });
+        }
+        else {
+            // Something else happened
+            return new SDKError(`Request failed: ${error.message}`, exports.ErrorType.API_ERROR);
+        }
+    }
+    // ============================================
+    // ADD YOUR API METHODS HERE
+    // ============================================
+    /**
+     * Example method - Replace with your actual API calls
+     *
+     * Template for a GET request:
+     *
+     * async getYourData(id: string): Promise<YourDataType> {
+     *   try {
+     *     const response = await this.client.get<APIResponse<YourDataType>>(
+     *       `/your-endpoint/${id}`
+     *     );
+     *
+     *     if (!response.data.success) {
+     *       throw new SDKError(
+     *         response.data.error || 'Failed to fetch data',
+     *         ErrorType.API_ERROR
+     *       );
+     *     }
+     *
+     *     return response.data.data;
+     *   } catch (error) {
+     *     if (error instanceof SDKError) throw error;
+     *     throw new SDKError(
+     *       `Failed to fetch data: ${error}`,
+     *       ErrorType.API_ERROR
+     *     );
+     *   }
+     * }
+     *
+     * Template for a POST request:
+     *
+     * async createYourData(data: YourInputType): Promise<YourDataType> {
+     *   try {
+     *     const response = await this.client.post<APIResponse<YourDataType>>(
+     *       '/your-endpoint',
+     *       data
+     *     );
+     *
+     *     if (!response.data.success) {
+     *       throw new SDKError(
+     *         response.data.error || 'Failed to create data',
+     *         ErrorType.API_ERROR
+     *       );
+     *     }
+     *
+     *     return response.data.data;
+     *   } catch (error) {
+     *     if (error instanceof SDKError) throw error;
+     *     throw new SDKError(
+     *       `Failed to create data: ${error}`,
+     *       ErrorType.API_ERROR
+     *     );
+     *   }
+     * }
+     */
+    // ============================================
+    // GENERIC REQUEST METHODS (Keep these - they're useful!)
+    // ============================================
+    /**
+     * Generic GET request
+     * @param endpoint - API endpoint (relative to baseURL)
+     * @param params - Query parameters
+     */
+    async get(endpoint, params) {
+        try {
+            const response = await this.client.get(endpoint, {
+                params,
+            });
+            if (!response.data.success) {
+                throw new SDKError(response.data.error || "Request failed", exports.ErrorType.API_ERROR);
+            }
+            return response.data.data;
+        }
+        catch (error) {
+            if (error instanceof SDKError)
+                throw error;
+            throw new SDKError(`GET request failed: ${error}`, exports.ErrorType.API_ERROR);
+        }
+    }
+    /**
+     * Generic POST request
+     * @param endpoint - API endpoint (relative to baseURL)
+     * @param data - Request body data
+     */
+    async post(endpoint, data) {
+        try {
+            const response = await this.client.post(endpoint, data);
+            if (!response.data.success) {
+                throw new SDKError(response.data.error || "Request failed", exports.ErrorType.API_ERROR);
+            }
+            return response.data.data;
+        }
+        catch (error) {
+            if (error instanceof SDKError)
+                throw error;
+            throw new SDKError(`POST request failed: ${error}`, exports.ErrorType.API_ERROR);
+        }
+    }
+    /**
+     * Generic PUT request
+     * @param endpoint - API endpoint (relative to baseURL)
+     * @param data - Request body data
+     */
+    async put(endpoint, data) {
+        try {
+            const response = await this.client.put(endpoint, data);
+            if (!response.data.success) {
+                throw new SDKError(response.data.error || "Request failed", exports.ErrorType.API_ERROR);
+            }
+            return response.data.data;
+        }
+        catch (error) {
+            if (error instanceof SDKError)
+                throw error;
+            throw new SDKError(`PUT request failed: ${error}`, exports.ErrorType.API_ERROR);
+        }
+    }
+    /**
+     * Generic DELETE request
+     * @param endpoint - API endpoint (relative to baseURL)
+     */
+    async delete(endpoint) {
+        try {
+            const response = await this.client.delete(endpoint);
+            if (!response.data.success) {
+                throw new SDKError(response.data.error || "Request failed", exports.ErrorType.API_ERROR);
+            }
+            return response.data.data;
+        }
+        catch (error) {
+            if (error instanceof SDKError)
+                throw error;
+            throw new SDKError(`DELETE request failed: ${error}`, exports.ErrorType.API_ERROR);
+        }
+    }
+    /**
+     * Get the base URL
+     */
+    getBaseURL() {
+        return this.baseURL;
+    }
+    /**
+     * Get the axios instance for advanced usage
+     */
+    getClient() {
+        return this.client;
+    }
+}
+
+/**
+ * Utility class with helper functions
+ */
+class Utils {
+    /**
+     * Validate Ethereum address
+     */
+    static isValidAddress(address) {
+        try {
+            return ethers.ethers.isAddress(address);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Validate and checksum an address
+     */
+    static validateAddress(address) {
+        if (!this.isValidAddress(address)) {
+            throw new SDKError(`Invalid Ethereum address: ${address}`, exports.ErrorType.VALIDATION_ERROR);
+        }
+        return ethers.ethers.getAddress(address);
+    }
+    /**
+     * Format token amount from wei to human-readable format
+     */
+    static formatAmount(amount, decimals = 18) {
+        try {
+            return ethers.ethers.formatUnits(amount, decimals);
+        }
+        catch (error) {
+            throw new SDKError(`Failed to format amount: ${error}`, exports.ErrorType.VALIDATION_ERROR);
+        }
+    }
+    /**
+     * Parse human-readable amount to wei
+     */
+    static parseAmount(amount, decimals = 18) {
+        try {
+            return ethers.ethers.parseUnits(amount, decimals).toString();
+        }
+        catch (error) {
+            throw new SDKError(`Failed to parse amount: ${error}`, exports.ErrorType.VALIDATION_ERROR);
+        }
+    }
+    /**
+     * Validate amount is positive and not zero
+     */
+    static validateAmount(amount) {
+        const amountBN = BigInt(amount);
+        if (amountBN <= 0n) {
+            throw new SDKError('Amount must be greater than zero', exports.ErrorType.VALIDATION_ERROR);
+        }
+    }
+    /**
+     * Calculate deadline timestamp (current time + minutes)
+     */
+    static getDeadline(minutes = 20) {
+        return Math.floor(Date.now() / 1000) + minutes * 60;
+    }
+    /**
+     * Calculate percentage difference
+     */
+    static calculatePercentageChange(oldValue, newValue) {
+        const old = parseFloat(oldValue);
+        const newVal = parseFloat(newValue);
+        if (old === 0)
+            return '0';
+        const change = ((newVal - old) / old) * 100;
+        return change.toFixed(2);
+    }
+    /**
+     * Estimate gas with buffer (adds 20% buffer)
+     */
+    static addGasBuffer(gasEstimate, bufferPercent = 20) {
+        const estimate = BigInt(gasEstimate);
+        const buffer = estimate * BigInt(bufferPercent) / 100n;
+        return (estimate + buffer).toString();
+    }
+    /**
+     * Parse error message from contract call
+     */
+    static parseContractError(error) {
+        // Check for common error patterns
+        if (error.reason) {
+            return error.reason;
+        }
+        if (error.message) {
+            // Extract revert reason if present
+            const revertMatch = error.message.match(/reason="([^"]*)"/);
+            if (revertMatch) {
+                return revertMatch[1];
+            }
+            return error.message;
+        }
+        if (error.data?.message) {
+            return error.data.message;
+        }
+        return 'Unknown error occurred';
+    }
+    /**
+     * Wait for transaction confirmation
+     */
+    static async waitForTransaction(txHash, provider, confirmations = 1) {
+        try {
+            const receipt = await provider.waitForTransaction(txHash, confirmations);
+            return receipt;
+        }
+        catch (error) {
+            throw new SDKError(`Transaction failed: ${this.parseContractError(error)}`, exports.ErrorType.TRANSACTION_ERROR, { txHash });
+        }
+    }
+    /**
+     * Get current gas prices
+     */
+    static async getGasPrices(provider) {
+        try {
+            const feeData = await provider.getFeeData();
+            return {
+                gasPrice: feeData.gasPrice || undefined,
+                maxFeePerGas: feeData.maxFeePerGas || undefined,
+                maxPriorityFeePerGas: feeData.maxPriorityFeePerGas || undefined,
+            };
+        }
+        catch (error) {
+            throw new SDKError(`Failed to fetch gas prices: ${error}`, exports.ErrorType.NETWORK_ERROR);
+        }
+    }
+    /**
+     * Convert chain ID to network name
+     */
+    static getNetworkName(chainId) {
+        const networks = {
+            1: 'Ethereum Mainnet',
+            5: 'Goerli',
+            11155111: 'Sepolia',
+            137: 'Polygon',
+            42161: 'Arbitrum One',
+            10: 'Optimism',
+        };
+        return networks[chainId] || `Unknown Network (${chainId})`;
+    }
+    /**
+     * Sleep/delay utility
+     */
+    static sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Retry logic for API calls
+     */
+    static async retry(fn, maxRetries = 3, delayMs = 1000) {
+        let lastError;
+        for (let i = 0; i < maxRetries; i++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                lastError = error;
+                if (i < maxRetries - 1) {
+                    await this.sleep(delayMs * (i + 1));
+                }
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * Format transaction hash with ellipsis
+     */
+    static shortenHash(hash, startLength = 6, endLength = 4) {
+        if (hash.length <= startLength + endLength) {
+            return hash;
+        }
+        return `${hash.slice(0, startLength)}...${hash.slice(-endLength)}`;
+    }
+    /**
+     * Check if a transaction was successful
+     */
+    static isTransactionSuccessful(receipt) {
+        return receipt?.status === 1;
+    }
+}
+
+/**
+ * TransactionBuilder class for creating blockchain transactions
+ * Returns unsigned transaction data that can be signed and sent by the frontend
+ *
+ * This is a TEMPLATE - add your own transaction methods based on your contract functions
+ */
+class TransactionBuilder {
+    /**
+     * Initialize TransactionBuilder
+     * @param provider - Ethers provider instance
+     * @param contractAddress - Main protocol contract address
+     * @param abi - Contract ABI
+     */
+    constructor(provider, contractAddress, abi) {
+        this.provider = provider;
+        this.contractAddress = Utils.validateAddress(contractAddress);
+        this.contract = new ethers.ethers.Contract(this.contractAddress, abi, provider);
+    }
+    // ============================================
+    // ADD YOUR TRANSACTION PREPARATION METHODS HERE
+    // ============================================
+    /**
+     * Example method - Replace with your actual contract functions
+     *
+     * Template for preparing a transaction:
+     *
+     * async prepareYourTransaction(params: YourParams): Promise<TransactionRequest> {
+     *   try {
+     *     // 1. Validate inputs
+     *     Utils.validateAddress(params.someAddress);
+     *     Utils.validateAmount(params.amount);
+     *
+     *     // 2. Populate transaction from your contract
+     *     const tx = await this.contract.yourFunction.populateTransaction(
+     *       params.arg1,
+     *       params.arg2,
+     *       // ... your parameters
+     *     );
+     *
+     *     // 3. Estimate gas (optional but recommended)
+     *     try {
+     *       const gasEstimate = await this.contract.yourFunction.estimateGas(
+     *         params.arg1,
+     *         params.arg2
+     *       );
+     *       tx.gasLimit = Utils.addGasBuffer(gasEstimate);
+     *     } catch (error) {
+     *       // Fallback to a default gas limit if estimation fails
+     *       tx.gasLimit = BigInt(200000);
+     *       console.warn('Gas estimation failed, using default:', error);
+     *     }
+     *
+     *     // 4. Return the unsigned transaction
+     *     return tx;
+     *   } catch (error) {
+     *     throw new SDKError(
+     *       `Failed to prepare transaction: ${Utils.parseContractError(error)}`,
+     *       ErrorType.TRANSACTION_ERROR,
+     *       { params }
+     *     );
+     *   }
+     * }
+     */
+    // ============================================
+    // UTILITY METHODS (Keep these - they're useful for any protocol)
+    // ============================================
+    /**
+     * Create a contract instance for custom interactions
+     * @param abi - Contract ABI
+     * @param address - Contract address (optional, defaults to main contract)
+     */
+    getContractInstance(abi, address) {
+        const contractAddress = address || this.contractAddress;
+        Utils.validateAddress(contractAddress);
+        return new ethers.ethers.Contract(contractAddress, abi, this.provider);
+    }
+    /**
+     * Get the main contract instance
+     */
+    getContract() {
+        return this.contract;
+    }
+    /**
+     * Get the provider
+     */
+    getProvider() {
+        return this.provider;
+    }
+    /**
+     * Estimate gas for any transaction
+     * @param tx - Transaction request
+     */
+    async estimateGas(tx) {
+        try {
+            const gasEstimate = await this.provider.estimateGas(tx);
+            return BigInt(Utils.addGasBuffer(gasEstimate));
+        }
+        catch (error) {
+            throw new SDKError(`Failed to estimate gas: ${Utils.parseContractError(error)}`, exports.ErrorType.TRANSACTION_ERROR);
+        }
+    }
+    /**
+     * Get current gas prices
+     */
+    async getGasPrices() {
+        return Utils.getGasPrices(this.provider);
+    }
+}
+
+/**
+ * Main SDK class that combines all functionality
+ *
+ * @example
+ * ```typescript
+ * import { ProtocolSDK } from '@yourorg/protocol-sdk';
+ * import { ethers } from 'ethers';
+ *
+ * const provider = new ethers.JsonRpcProvider('YOUR_RPC_URL');
+ *
+ * const sdk = new ProtocolSDK({
+ *   apiBaseURL: 'https://api.yourprotocol.com',
+ *   provider: provider,
+ *   contractAddress: '0x...',
+ *   abi: YourContractABI,
+ *   apiKey: 'your-api-key', // optional
+ * });
+ *
+ * // Use the SDK
+ * const markets = await sdk.api.getAllMarkets();
+ * const tx = await sdk.tx.prepareSwapTransaction({ ... });
+ * ```
+ */
+class ProtocolSDK {
+    /**
+     * Initialize the SDK
+     * @param config - SDK configuration
+     */
+    constructor(config) {
+        // Validate configuration
+        this.validateConfig(config);
+        // Initialize components
+        this.provider = config.provider;
+        this.contractAddress = config.contractAddress;
+        this.chainId = config.chainId;
+        this.api = new APIClient(config.apiBaseURL, config.apiKey);
+        this.tx = new TransactionBuilder(config.provider, config.contractAddress, config.abi);
+        this.utils = Utils;
+    }
+    /**
+     * Validate SDK configuration
+     */
+    validateConfig(config) {
+        if (!config.apiBaseURL) {
+            throw new SDKError('apiBaseURL is required', exports.ErrorType.VALIDATION_ERROR);
+        }
+        if (!config.provider) {
+            throw new SDKError('provider is required', exports.ErrorType.VALIDATION_ERROR);
+        }
+        if (!config.contractAddress) {
+            throw new SDKError('contractAddress is required', exports.ErrorType.VALIDATION_ERROR);
+        }
+        if (!config.abi || !Array.isArray(config.abi)) {
+            throw new SDKError('abi must be an array', exports.ErrorType.VALIDATION_ERROR);
+        }
+        // Validate contract address format
+        if (!Utils.isValidAddress(config.contractAddress)) {
+            throw new SDKError('Invalid contract address', exports.ErrorType.VALIDATION_ERROR);
+        }
+    }
+    /**
+     * Get network information
+     */
+    async getNetworkInfo() {
+        try {
+            const network = await this.provider.getNetwork();
+            return {
+                name: Utils.getNetworkName(Number(network.chainId)),
+                chainId: Number(network.chainId),
+            };
+        }
+        catch (error) {
+            throw new SDKError(`Failed to get network info: ${error}`, exports.ErrorType.NETWORK_ERROR);
+        }
+    }
+    /**
+     * Get current block number
+     */
+    async getBlockNumber() {
+        try {
+            return await this.provider.getBlockNumber();
+        }
+        catch (error) {
+            throw new SDKError(`Failed to get block number: ${error}`, exports.ErrorType.NETWORK_ERROR);
+        }
+    }
+    /**
+     * Check if provider is connected
+     */
+    async isConnected() {
+        try {
+            await this.provider.getBlockNumber();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get transaction receipt
+     * @param txHash - Transaction hash
+     */
+    async getTransactionReceipt(txHash) {
+        try {
+            return await this.provider.getTransactionReceipt(txHash);
+        }
+        catch (error) {
+            throw new SDKError(`Failed to get transaction receipt: ${error}`, exports.ErrorType.NETWORK_ERROR, { txHash });
+        }
+    }
+    /**
+     * Wait for transaction confirmation
+     * @param txHash - Transaction hash
+     * @param confirmations - Number of confirmations to wait for
+     */
+    async waitForTransaction(txHash, confirmations = 1) {
+        return Utils.waitForTransaction(txHash, this.provider, confirmations);
+    }
+    /**
+     * Get SDK version
+     */
+    static getVersion() {
+        return '1.0.0'; // This should match package.json version
+    }
+}
+
+/**
+ * Network configuration
+ */
+const NETWORKS = {
+    MAINNET: {
+        chainId: 1,
+        name: 'Ethereum Mainnet',
+        rpcUrl: 'https://eth.llamarpc.com',
+    },
+    GOERLI: {
+        chainId: 5,
+        name: 'Goerli Testnet',
+        rpcUrl: 'https://goerli.infura.io/v3/',
+    },
+    SEPOLIA: {
+        chainId: 11155111,
+        name: 'Sepolia Testnet',
+        rpcUrl: 'https://sepolia.infura.io/v3/',
+    },
+    POLYGON: {
+        chainId: 137,
+        name: 'Polygon Mainnet',
+        rpcUrl: 'https://polygon-rpc.com',
+    },
+    ARBITRUM: {
+        chainId: 42161,
+        name: 'Arbitrum One',
+        rpcUrl: 'https://arb1.arbitrum.io/rpc',
+    },
+};
+/**
+ * API endpoints
+ */
+const API_ENDPOINTS = {
+    MARKET_DATA: '/markets',
+    USER_BALANCE: '/balance',
+    TRANSACTIONS: '/transactions',
+    PRICES: '/prices',
+};
+/**
+ * Contract method names
+ */
+const CONTRACT_METHODS = {
+    SWAP: 'swap',
+    DEPOSIT: 'deposit',
+    WITHDRAW: 'withdraw',
+    APPROVE: 'approve',
+    BALANCE_OF: 'balanceOf',
+    ALLOWANCE: 'allowance',
+};
+/**
+ * Token decimals (common tokens)
+ */
+const TOKEN_DECIMALS = {
+    ETH: 18,
+    USDC: 6,
+    USDT: 6,
+    DAI: 18,
+    WBTC: 8,
+};
+/**
+ * Gas limit estimates for different operations
+ */
+const GAS_LIMITS = {
+    APPROVE: 50000,
+    SWAP: 200000,
+    DEPOSIT: 150000,
+    WITHDRAW: 150000,
+    TRANSFER: 21000,
+};
+/**
+ * Default transaction deadline (20 minutes from now)
+ */
+const DEFAULT_DEADLINE_MINUTES = 20;
+/**
+ * Maximum uint256 value for unlimited approvals
+ */
+const MAX_UINT256 = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
+/**
+ * Zero address
+ */
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+
+exports.APIClient = APIClient;
+exports.API_ENDPOINTS = API_ENDPOINTS;
+exports.CONTRACT_METHODS = CONTRACT_METHODS;
+exports.DEFAULT_DEADLINE_MINUTES = DEFAULT_DEADLINE_MINUTES;
+exports.GAS_LIMITS = GAS_LIMITS;
+exports.MAX_UINT256 = MAX_UINT256;
+exports.NETWORKS = NETWORKS;
+exports.ProtocolSDK = ProtocolSDK;
+exports.SDKError = SDKError;
+exports.TOKEN_DECIMALS = TOKEN_DECIMALS;
+exports.TransactionBuilder = TransactionBuilder;
+exports.Utils = Utils;
+exports.ZERO_ADDRESS = ZERO_ADDRESS;
+exports.default = ProtocolSDK;
+//# sourceMappingURL=index.js.map