@heyanon/sdk 2.3.1 → 2.3.3

package/dist/utils/retry.d.ts

@@ -1,6 +1,224 @@
+/**
+ * Options for configuring retry behavior
+ * @interface Options
+ */
 interface Options {
+    /** Number of retry attempts (default: 0) */
     readonly retries?: number;
+    /** Delay between retry attempts in milliseconds (optional) */
     readonly delayMs?: number;
 }
+/**
+ * Executes an async function with automatic retry logic on failure
+ * @template T - The return type of the function
+ * @param fn - The async function to execute with retry logic
+ * @param options - Configuration options for retry behavior
+ * @returns Promise that resolves with the function result or rejects after all retries are exhausted
+ * @example
+ * ```typescript
+ * // Basic retry without delay
+ * const result = await retry(
+ *   async () => {
+ *     const response = await fetch('https://api.example.com/data');
+ *     if (!response.ok) throw new Error('Network error');
+ *     return response.json();
+ *   },
+ *   { retries: 3 }
+ * );
+ *
+ * // Retry with delay between attempts
+ * const dataWithDelay = await retry(
+ *   async () => {
+ *     const connection = await database.connect();
+ *     return await connection.query('SELECT * FROM users');
+ *   },
+ *   { retries: 5, delayMs: 1000 } // Wait 1 second between retries
+ * );
+ *
+ * // Blockchain transaction with exponential backoff simulation
+ * async function sendTransactionWithRetry(transaction: TransactionParams) {
+ *   let attempt = 0;
+ *
+ *   return await retry(
+ *     async () => {
+ *       attempt++;
+ *       console.log(`Attempt ${attempt}: Sending transaction...`);
+ *
+ *       const result = await options.evm.sendTransactions({
+ *         transactions: [transaction]
+ *       });
+ *
+ *       if (!result.data[0].message.includes('confirmed')) {
+ *         throw new Error('Transaction not confirmed');
+ *       }
+ *
+ *       return result;
+ *     },
+ *     { retries: 3, delayMs: 2000 }
+ *   );
+ * }
+ *
+ * // API call with retry for rate limiting
+ * async function fetchTokenPrice(tokenAddress: string) {
+ *   return await retry(
+ *     async () => {
+ *       const response = await fetch(`https://api.coingecko.com/api/v3/tokens/${tokenAddress}`);
+ *
+ *       if (response.status === 429) {
+ *         throw new Error('Rate limited');
+ *       }
+ *
+ *       if (!response.ok) {
+ *         throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+ *       }
+ *
+ *       return await response.json();
+ *     },
+ *     { retries: 5, delayMs: 3000 } // 3 second delay for rate limits
+ *   );
+ * }
+ *
+ * // RPC provider failover
+ * async function getBlockNumberWithFailover(providers: PublicClient[]) {
+ *   let providerIndex = 0;
+ *
+ *   return await retry(
+ *     async () => {
+ *       if (providerIndex >= providers.length) {
+ *         throw new Error('All providers failed');
+ *       }
+ *
+ *       const provider = providers[providerIndex];
+ *
+ *       try {
+ *         return await provider.getBlockNumber();
+ *       } catch (error) {
+ *         providerIndex++;
+ *         throw error;
+ *       }
+ *     },
+ *     { retries: providers.length - 1, delayMs: 500 }
+ *   );
+ * }
+ *
+ * // Solana transaction confirmation
+ * async function confirmSolanaTransaction(signature: string, connection: Connection) {
+ *   return await retry(
+ *     async () => {
+ *       const status = await connection.getSignatureStatus(signature);
+ *
+ *       if (!status.value) {
+ *         throw new Error('Transaction not found');
+ *       }
+ *
+ *       if (status.value.err) {
+ *         throw new Error(`Transaction failed: ${JSON.stringify(status.value.err)}`);
+ *       }
+ *
+ *       if (!status.value.confirmationStatus) {
+ *         throw new Error('Transaction not confirmed yet');
+ *       }
+ *
+ *       return status.value;
+ *     },
+ *     { retries: 30, delayMs: 1000 } // Check every second for 30 seconds
+ *   );
+ * }
+ *
+ * // TON client operations with retry
+ * async function getTonAccountWithRetry(address: Address, client: Client) {
+ *   return await retry(
+ *     async () => {
+ *       try {
+ *         return await client.api.accounts.getAccount(address.toString());
+ *       } catch (error) {
+ *         if (error.message.includes('429')) {
+ *           throw new Error('Rate limited - will retry');
+ *         }
+ *         if (error.message.includes('timeout')) {
+ *           throw new Error('Timeout - will retry');
+ *         }
+ *         // Don't retry for other errors
+ *         throw error;
+ *       }
+ *     },
+ *     { retries: 3, delayMs: 2000 }
+ *   );
+ * }
+ *
+ * // File operations with retry
+ * async function readFileWithRetry(filePath: string) {
+ *   return await retry(
+ *     async () => {
+ *       const fs = await import('fs/promises');
+ *       return await fs.readFile(filePath, 'utf-8');
+ *     },
+ *     { retries: 3, delayMs: 100 }
+ *   );
+ * }
+ *
+ * // Complex retry with custom logic
+ * async function smartContractCallWithRetry(
+ *   contractAddress: Address,
+ *   methodName: string,
+ *   args: any[],
+ *   provider: PublicClient
+ * ) {
+ *   let gasPrice = await provider.getGasPrice();
+ *
+ *   return await retry(
+ *     async () => {
+ *       try {
+ *         return await provider.readContract({
+ *           address: contractAddress,
+ *           abi: contractAbi,
+ *           functionName: methodName,
+ *           args
+ *         });
+ *       } catch (error) {
+ *         if (error.message.includes('gas')) {
+ *           // Increase gas price for next attempt
+ *           gasPrice = gasPrice * 110n / 100n; // +10%
+ *           console.log(`Increasing gas price to ${gasPrice}`);
+ *         }
+ *         throw error;
+ *       }
+ *     },
+ *     { retries: 3, delayMs: 1000 }
+ *   );
+ * }
+ *
+ * // Error handling patterns
+ * async function handleOperationWithRetry<T>(
+ *   operation: () => Promise<T>,
+ *   operationName: string
+ * ): Promise<T> {
+ *   try {
+ *     return await retry(operation, { retries: 3, delayMs: 1000 });
+ *   } catch (error) {
+ *     console.error(`${operationName} failed after all retries:`, error);
+ *
+ *     // Log for monitoring
+ *     if (typeof error === 'object' && error !== null) {
+ *       console.error('Final error details:', {
+ *         message: error.message,
+ *         stack: error.stack,
+ *         operation: operationName
+ *       });
+ *     }
+ *
+ *     throw new Error(`${operationName} failed: ${error.message}`);
+ *   }
+ * }
+ *
+ * // Usage in adapter functions
+ * async function executeWithRetry<T>(
+ *   operation: () => Promise<T>,
+ *   retryConfig: Options = { retries: 3, delayMs: 1000 }
+ * ): Promise<T> {
+ *   return await retry(operation, retryConfig);
+ * }
+ * ```
+ */
 export declare function retry<T>(fn: () => Promise<T>, options?: Options): Promise<T>;
 export {};

package/dist/utils/sleep.d.ts

@@ -1 +1,240 @@
+/**
+ * Creates a promise that resolves after the specified number of milliseconds
+ * @param ms - Number of milliseconds to sleep/wait
+ * @returns Promise that resolves after the specified delay
+ * @example
+ * ```typescript
+ * // Basic usage - wait for 1 second
+ * await sleep(1000);
+ * console.log('Executed after 1 second');
+ *
+ * // Wait between operations
+ * console.log('Starting operation...');
+ * await sleep(2000);
+ * console.log('Continuing after 2 seconds...');
+ *
+ * // Use in blockchain operations for rate limiting
+ * async function batchProcessTransactions(transactions: TransactionParams[]) {
+ *   const results = [];
+ *
+ *   for (const tx of transactions) {
+ *     const result = await options.evm.sendTransactions({
+ *       transactions: [tx]
+ *     });
+ *     results.push(result);
+ *
+ *     // Wait 3 seconds between transactions to avoid rate limits
+ *     await sleep(3000);
+ *   }
+ *
+ *   return results;
+ * }
+ *
+ * // Polling with delays
+ * async function pollTransactionStatus(hash: string, maxAttempts: number = 30) {
+ *   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+ *     const receipt = await provider.getTransactionReceipt(hash);
+ *
+ *     if (receipt) {
+ *       return receipt;
+ *     }
+ *
+ *     console.log(`Attempt ${attempt}: Transaction not confirmed yet, waiting...`);
+ *     await sleep(2000); // Wait 2 seconds before next check
+ *   }
+ *
+ *   throw new Error('Transaction confirmation timeout');
+ * }
+ *
+ * // Gradual data loading with delays
+ * async function loadUserPortfolio(userAddress: string, chains: EvmChain[]) {
+ *   const portfolio = [];
+ *
+ *   for (const chain of chains) {
+ *     console.log(`Loading ${chain} data...`);
+ *
+ *     const chainData = await getUserBalances(userAddress, chain);
+ *     portfolio.push({ chain, data: chainData });
+ *
+ *     // Small delay to prevent overwhelming APIs
+ *     await sleep(500);
+ *   }
+ *
+ *   return portfolio;
+ * }
+ *
+ * // Retry with increasing delays (exponential backoff)
+ * async function exponentialBackoffOperation<T>(
+ *   operation: () => Promise<T>,
+ *   maxRetries: number = 5
+ * ): Promise<T> {
+ *   let lastError: Error;
+ *
+ *   for (let attempt = 1; attempt <= maxRetries; attempt++) {
+ *     try {
+ *       return await operation();
+ *     } catch (error) {
+ *       lastError = error as Error;
+ *
+ *       if (attempt === maxRetries) {
+ *         throw lastError;
+ *       }
+ *
+ *       const delayMs = Math.pow(2, attempt) * 1000; // 2s, 4s, 8s, 16s, 32s
+ *       console.log(`Attempt ${attempt} failed, retrying in ${delayMs}ms...`);
+ *       await sleep(delayMs);
+ *     }
+ *   }
+ *
+ *   throw lastError!;
+ * }
+ *
+ * // Animation delays in UI
+ * async function animatedTokenTransfer(fromAddress: string, toAddress: string, amount: bigint) {
+ *   console.log('🚀 Initiating transfer...');
+ *   await sleep(500);
+ *
+ *   console.log('⏳ Preparing transaction...');
+ *   const tx = await buildTransferTransaction(fromAddress, toAddress, amount);
+ *   await sleep(800);
+ *
+ *   console.log('📝 Signing transaction...');
+ *   await sleep(1000);
+ *
+ *   console.log('📡 Broadcasting to network...');
+ *   const result = await options.evm.sendTransactions({ transactions: [tx] });
+ *   await sleep(500);
+ *
+ *   console.log('✅ Transfer complete!');
+ *   return result;
+ * }
+ *
+ * // Throttled API calls
+ * async function throttledApiCalls<T>(
+ *   apiCalls: (() => Promise<T>)[],
+ *   delayBetweenCalls: number = 1000
+ * ): Promise<T[]> {
+ *   const results: T[] = [];
+ *
+ *   for (let i = 0; i < apiCalls.length; i++) {
+ *     const result = await apiCalls[i]();
+ *     results.push(result);
+ *
+ *     // Don't wait after the last call
+ *     if (i < apiCalls.length - 1) {
+ *       await sleep(delayBetweenCalls);
+ *     }
+ *   }
+ *
+ *   return results;
+ * }
+ *
+ * // Blockchain confirmation waiting
+ * async function waitForConfirmations(
+ *   transactionHash: string,
+ *   requiredConfirmations: number = 6,
+ *   checkInterval: number = 15000 // 15 seconds
+ * ) {
+ *   let confirmations = 0;
+ *
+ *   while (confirmations < requiredConfirmations) {
+ *     const receipt = await provider.getTransactionReceipt(transactionHash);
+ *
+ *     if (!receipt) {
+ *       console.log('Transaction not found, waiting...');
+ *       await sleep(checkInterval);
+ *       continue;
+ *     }
+ *
+ *     const currentBlock = await provider.getBlockNumber();
+ *     confirmations = currentBlock - receipt.blockNumber + 1;
+ *
+ *     console.log(`Confirmations: ${confirmations}/${requiredConfirmations}`);
+ *
+ *     if (confirmations < requiredConfirmations) {
+ *       await sleep(checkInterval);
+ *     }
+ *   }
+ *
+ *   console.log('✅ Transaction fully confirmed!');
+ * }
+ *
+ * // Solana transaction confirmation with sleep
+ * async function confirmSolanaTransactionWithSleep(
+ *   signature: string,
+ *   connection: Connection,
+ *   timeout: number = 60000
+ * ) {
+ *   const startTime = Date.now();
+ *
+ *   while (Date.now() - startTime < timeout) {
+ *     const status = await connection.getSignatureStatus(signature);
+ *
+ *     if (status.value?.confirmationStatus === 'confirmed' ||
+ *         status.value?.confirmationStatus === 'finalized') {
+ *       return status.value;
+ *     }
+ *
+ *     await sleep(1000); // Check every second
+ *   }
+ *
+ *   throw new Error('Transaction confirmation timeout');
+ * }
+ *
+ * // TON transaction monitoring
+ * async function monitorTonTransaction(hash: string, client: Client) {
+ *   const maxAttempts = 30;
+ *
+ *   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+ *     try {
+ *       const tx = await client.api.blockchain.getBlockchainTransaction(hash);
+ *
+ *       if (tx.success) {
+ *         return tx;
+ *       } else {
+ *         throw new Error('Transaction failed');
+ *       }
+ *     } catch (error) {
+ *       if (attempt === maxAttempts) {
+ *         throw error;
+ *       }
+ *
+ *       console.log(`Attempt ${attempt}: Transaction not ready, waiting 2 seconds...`);
+ *       await sleep(2000);
+ *     }
+ *   }
+ * }
+ *
+ * // Progressive loading with sleep
+ * async function progressiveDataLoad(addresses: string[], progressCallback?: (progress: number) => void) {
+ *   const results = [];
+ *   const total = addresses.length;
+ *
+ *   for (let i = 0; i < addresses.length; i++) {
+ *     const address = addresses[i];
+ *     const data = await getAddressData(address);
+ *     results.push(data);
+ *
+ *     // Update progress
+ *     const progress = ((i + 1) / total) * 100;
+ *     progressCallback?.(progress);
+ *
+ *     // Brief pause between loads
+ *     if (i < addresses.length - 1) {
+ *       await sleep(200);
+ *     }
+ *   }
+ *
+ *   return results;
+ * }
+ *
+ * // Utility functions with sleep
+ * const sleepSeconds = (seconds: number) => sleep(seconds * 1000);
+ * const sleepMinutes = (minutes: number) => sleep(minutes * 60 * 1000);
+ *
+ * // Usage examples
+ * // await sleepSeconds(5); // Sleep for 5 seconds
+ * // await sleepMinutes(1); // Sleep for 1 minute
+ * ```
+ */
 export declare const sleep: (ms: number) => Promise<unknown>;

package/dist/utils/stringify.d.ts

@@ -1 +1,236 @@
+/**
+ * Converts a JavaScript value to a JSON string with support for BigInt values
+ *
+ * This function extends the standard JSON.stringify to handle BigInt values,
+ * which are commonly used in blockchain applications for handling large numbers
+ * like token amounts, gas prices, and transaction values.
+ *
+ * @param value - The value to convert to JSON string
+ * @param space - Optional. A String or Number object used to insert white space into the output JSON string for readability purposes
+ * @returns JSON string representation of the value with BigInt values converted to strings
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with primitive values
+ * stringify({ name: 'Alice', age: 25 });
+ * // Returns: '{"name":"Alice","age":25}'
+ *
+ * // Handling BigInt values (common in blockchain)
+ * const tokenAmount = BigInt('1000000000000000000'); // 1 ETH in wei
+ * stringify({ amount: tokenAmount, symbol: 'ETH' });
+ * // Returns: '{"amount":"1000000000000000000","symbol":"ETH"}'
+ *
+ * // Pretty printing with indentation
+ * const transactionData = {
+ *   hash: '0x1234567890abcdef',
+ *   value: BigInt('500000000000000000'), // 0.5 ETH
+ *   gasPrice: BigInt('20000000000'), // 20 Gwei
+ *   gasLimit: BigInt('21000')
+ * };
+ *
+ * stringify(transactionData, 2);
+ * // Returns:
+ * // {
+ * //   "hash": "0x1234567890abcdef",
+ * //   "value": "500000000000000000",
+ * //   "gasPrice": "20000000000",
+ * //   "gasLimit": "21000"
+ * // }
+ *
+ * // EVM transaction parameters
+ * const evmTx = {
+ *   to: '0x742d35cc6798c532c9c75e2c7ad3e6b9b11b38c1',
+ *   value: BigInt('1000000000000000000'), // 1 ETH
+ *   gasLimit: BigInt('21000'),
+ *   gasPrice: BigInt('30000000000'), // 30 Gwei
+ *   nonce: 42,
+ *   data: '0x'
+ * };
+ *
+ * const txJson = stringify(evmTx);
+ * console.log('Transaction JSON:', txJson);
+ * // Outputs: {"to":"0x742d35cc6798c532c9c75e2c7ad3e6b9b11b38c1","value":"1000000000000000000","gasLimit":"21000","gasPrice":"30000000000","nonce":42,"data":"0x"}
+ *
+ * // Token balance information
+ * const tokenBalance = {
+ *   address: '0xa0b86a33e6885b3ae5372f1c6c8e0e2e3e3b8c4d',
+ *   symbol: 'USDC',
+ *   decimals: 6,
+ *   balance: BigInt('1500000000'), // 1,500 USDC (6 decimals)
+ *   valueInWei: BigInt('1500000000000000000000') // equivalent ETH value
+ * };
+ *
+ * stringify(tokenBalance, '  '); // Using string indentation
+ * // Returns formatted JSON with BigInt values as strings
+ *
+ * // Array of transactions with BigInt values
+ * const transactions = [
+ *   {
+ *     hash: '0xabc123',
+ *     value: BigInt('100000000000000000'), // 0.1 ETH
+ *     timestamp: 1697184000
+ *   },
+ *   {
+ *     hash: '0xdef456',
+ *     value: BigInt('250000000000000000'), // 0.25 ETH
+ *     timestamp: 1697184060
+ *   }
+ * ];
+ *
+ * stringify(transactions);
+ * // Returns: [{"hash":"0xabc123","value":"100000000000000000","timestamp":1697184000},{"hash":"0xdef456","value":"250000000000000000","timestamp":1697184060}]
+ *
+ * // Solana transaction data
+ * const solanaData = {
+ *   signature: '5VERv8NMvzbJMEkV8xnrLkEaWRtSz9CosKDYjCJjBRnbJLgp8uirBgmQpjKhoR4tjF3ZpRzrFmBV6UjKdiSZkQUW',
+ *   slot: BigInt('123456789'),
+ *   lamports: BigInt('1000000000'), // 1 SOL in lamports
+ *   fee: BigInt('5000') // transaction fee
+ * };
+ *
+ * stringify(solanaData, 4);
+ * // Returns formatted JSON with BigInt slot and lamport values as strings
+ *
+ * // TON transaction information
+ * const tonTx = {
+ *   hash: 'abc123def456',
+ *   lt: BigInt('25123456000001'), // logical time
+ *   value: BigInt('1000000000'), // 1 TON in nanotons
+ *   fees: {
+ *     inFwdFee: BigInt('1000000'),
+ *     storageFee: BigInt('500000'),
+ *     gasFee: BigInt('2000000')
+ *   }
+ * };
+ *
+ * stringify(tonTx);
+ * // All BigInt values converted to strings for JSON compatibility
+ *
+ * // DeFi protocol data with large numbers
+ * const defiData = {
+ *   protocol: 'Uniswap V3',
+ *   poolAddress: '0x8ad599c3a0ff1de082011efddc58f1908eb6e6d8',
+ *   liquidity: BigInt('12345678901234567890123'),
+ *   sqrtPriceX96: BigInt('1234567890123456789012345'),
+ *   tick: -276324,
+ *   feeGrowthGlobal0X128: BigInt('98765432109876543210'),
+ *   feeGrowthGlobal1X128: BigInt('13579246801357924680')
+ * };
+ *
+ * const defiJson = stringify(defiData, 2);
+ * console.log('DeFi Pool Data:', defiJson);
+ *
+ * // NFT metadata with BigInt token IDs
+ * const nftData = {
+ *   contractAddress: '0x60e4d786628fea6478f785a6d7e704777c86a7c6',
+ *   tokenId: BigInt('1234567890123456789'),
+ *   owner: '0x123456789abcdef123456789abcdef123456789a',
+ *   metadata: {
+ *     name: 'Cool NFT #1234567890123456789',
+ *     description: 'A unique digital asset',
+ *     image: 'ipfs://QmHash123456789'
+ *   },
+ *   lastSalePrice: BigInt('5000000000000000000') // 5 ETH
+ * };
+ *
+ * stringify(nftData);
+ * // BigInt tokenId and lastSalePrice converted to strings
+ *
+ * // Multi-chain portfolio data
+ * const portfolio = {
+ *   ethereum: {
+ *     nativeBalance: BigInt('2500000000000000000'), // 2.5 ETH
+ *     tokens: [
+ *       {
+ *         symbol: 'USDC',
+ *         balance: BigInt('1000000000'), // 1,000 USDC (6 decimals)
+ *         address: '0xa0b86a33e6885b3ae5372f1c6c8e0e2e3e3b8c4d'
+ *       }
+ *     ]
+ *   },
+ *   polygon: {
+ *     nativeBalance: BigInt('100000000000000000000'), // 100 MATIC
+ *     tokens: []
+ *   },
+ *   solana: {
+ *     nativeBalance: BigInt('5000000000'), // 5 SOL
+ *     tokens: []
+ *   }
+ * };
+ *
+ * const portfolioJson = stringify(portfolio, 2);
+ * // All BigInt balances converted to strings for cross-chain compatibility
+ *
+ * // Error handling with BigInt
+ * try {
+ *   const problematicData = {
+ *     regularNumber: 123,
+ *     bigIntValue: BigInt('999999999999999999999'),
+ *     circularRef: null as any
+ *   };
+ *   problematicData.circularRef = problematicData; // Creates circular reference
+ *
+ *   // This will throw due to circular reference, not BigInt
+ *   stringify(problematicData);
+ * } catch (error) {
+ *   console.error('Stringify error:', error.message);
+ * }
+ *
+ * // Comparison with standard JSON.stringify (would fail with BigInt)
+ * const bigIntData = { amount: BigInt('123456789012345678901234567890') };
+ *
+ * // ❌ This would throw: JSON.stringify(bigIntData)
+ * // TypeError: Do not know how to serialize a BigInt
+ *
+ * // ✅ This works: stringify(bigIntData)
+ * stringify(bigIntData);
+ * // Returns: '{"amount":"123456789012345678901234567890"}'
+ *
+ * // Logging blockchain events with BigInt block numbers
+ * const blockchainEvents = [
+ *   {
+ *     event: 'Transfer',
+ *     blockNumber: BigInt('18500000'),
+ *     transactionIndex: 25,
+ *     logIndex: 3,
+ *     args: {
+ *       from: '0x123...',
+ *       to: '0x456...',
+ *       value: BigInt('1000000000000000000')
+ *     }
+ *   }
+ * ];
+ *
+ * const eventsLog = stringify(blockchainEvents, 2);
+ * console.log('Blockchain Events:', eventsLog);
+ *
+ * // Configuration objects with BigInt limits
+ * const sdkConfig = {
+ *   maxGasPrice: BigInt('100000000000'), // 100 Gwei
+ *   minBalance: BigInt('100000000000000000'), // 0.1 ETH
+ *   retryDelayMs: 1000,
+ *   maxRetries: 3,
+ *   networkTimeouts: {
+ *     ethereum: BigInt('15000'), // 15 seconds in ms
+ *     polygon: BigInt('5000'),   // 5 seconds in ms
+ *     solana: BigInt('10000')    // 10 seconds in ms
+ *   }
+ * };
+ *
+ * const configJson = stringify(sdkConfig);
+ * // Safely serialize configuration with BigInt values
+ *
+ * // Utility for pretty-printing blockchain data
+ * function logBlockchainData(data: any, label: string = 'Data') {
+ *   console.log(`${label}:`, stringify(data, 2));
+ * }
+ *
+ * // Usage in debugging
+ * logBlockchainData({
+ *   txHash: '0xabc123',
+ *   blockNumber: BigInt('18500001'),
+ *   gasUsed: BigInt('21000')
+ * }, 'Transaction Receipt');
+ * ```
+ */
 export declare function stringify(value: any, space?: string | number): string;

package/dist/utils/stringify.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heyanon/sdk",
-  "version": "2.3.1",
+  "version": "2.3.3",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",