@heyanon/sdk 2.3.2 → 2.3.4

package/dist/index.mjs

@@ -1,6 +1,7 @@
-import { erc20Abi, getAddress, encodeFunctionData } from 'viem';
+import { erc20Abi, getAddress, encodeFunctionData, isAddress as isAddress$1 } from 'viem';
 import { ethereumTokens, optimismTokens, bscTokens, polygonTokens, zkSyncTokens, kavaTokens, avalancheTokens, arbitrumTokens, metisTokens, baseTokens, sonicTokens, Token } from '@real-wagmi/sdk';
 import { TransactionMessage, VersionedTransaction, PublicKey } from '@solana/web3.js';
+import { Address } from '@ton/ton';
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -36,32 +37,6 @@ function stringify(value, space) {
   return JSON.stringify(value, (_key, value2) => typeof value2 === "bigint" ? value2.toString() : value2, space);
 }
 
-// src/adapter/transformers/toResult.ts
-function toResult(data, error = false) {
-  const formatedData = typeof data === "string" ? data : stringify(data);
-  return {
-    success: !error,
-    data: error ? `ERROR: ${formatedData}` : formatedData
-  };
-}
-
-// src/adapter/misc.ts
-var AdapterTag = /* @__PURE__ */ ((AdapterTag2) => {
-  AdapterTag2["ALM"] = "ALM";
-  AdapterTag2["STAKE"] = "Stake";
-  AdapterTag2["LENDING"] = "Lending";
-  AdapterTag2["FARM"] = "Farm";
-  AdapterTag2["PERPETUALS"] = "Perpetuals";
-  AdapterTag2["BRIDGE"] = "Bridge";
-  AdapterTag2["LIMIT_ORDER"] = "Limit orders";
-  AdapterTag2["DEX"] = "DEX";
-  AdapterTag2["LP"] = "LP";
-  AdapterTag2["GAMES"] = "Games";
-  AdapterTag2["CEX"] = "CEX";
-  AdapterTag2["LAUNCHPAD"] = "Launchpad";
-  return AdapterTag2;
-})(AdapterTag || {});
-
 // src/blockchain/evm/index.ts
 var evm_exports = {};
 __export(evm_exports, {
@@ -87,7 +62,9 @@ __export(utils_exports, {
   isEvmChain: () => isEvmChain
 });
 var ZERO_ALLOWANCE = {
+  /** Ethereum mainnet tokens requiring zero allowance reset */
   1: ["0xdAC17F958D2ee523a2206206994597C13D831ec7"]
+  // USDT
 };
 async function checkToApprove({ args, transactions, provider }) {
   const { account, target, spender, amount } = args;
@@ -172,39 +149,69 @@ var WalletType = /* @__PURE__ */ ((WalletType2) => {
 
 // src/blockchain/evm/constants/chains.ts
 var ChainIds = {
+  /** Ethereum Mainnet - Chain ID: 1 */
   ["ethereum" /* ETHEREUM */]: 1,
+  /** Optimism - Chain ID: 10 */
   ["optimism" /* OPTIMISM */]: 10,
+  /** Binance Smart Chain - Chain ID: 56 */
   ["bsc" /* BSC */]: 56,
+  /** Gnosis Chain - Chain ID: 100 */
   ["gnosis" /* GNOSIS */]: 100,
+  /** Polygon - Chain ID: 137 */
   ["polygon" /* POLYGON */]: 137,
+  /** Sonic - Chain ID: 146 */
   ["sonic" /* SONIC */]: 146,
+  /** zkSync Era - Chain ID: 324 */
   ["zksync" /* ZKSYNC */]: 324,
+  /** Metis Andromeda - Chain ID: 1088 */
   ["metis" /* METIS */]: 1088,
+  /** Kava EVM - Chain ID: 2222 */
   ["kava_evm" /* KAVA_EVM */]: 2222,
+  /** Base - Chain ID: 8453 */
   ["base" /* BASE */]: 8453,
+  /** Avalanche C-Chain - Chain ID: 43114 */
   ["avalanche" /* AVALANCHE */]: 43114,
+  /** Arbitrum One - Chain ID: 42161 */
   ["arbitrum" /* ARBITRUM */]: 42161,
+  /** Scroll - Chain ID: 534352 */
   ["scroll" /* SCROLL */]: 534352,
+  /** HyperEVM - Chain ID: 999 */
   ["hyperevm" /* HYPEREVM */]: 999,
+  /** Plasma - Chain ID: 9745 */
   ["plasma" /* PLASMA */]: 9745
 };
 
 // src/blockchain/evm/constants/weth9.ts
 var WETH9 = {
+  /** Wrapped Ether (WETH) on Ethereum */
   ["ethereum" /* ETHEREUM */]: ethereumTokens.weth,
+  /** Wrapped Ether (WETH) on Optimism */
   ["optimism" /* OPTIMISM */]: optimismTokens.weth,
+  /** Wrapped BNB (WBNB) on Binance Smart Chain */
   ["bsc" /* BSC */]: bscTokens.wbnb,
+  /** Wrapped POL (WPOL) on Polygon */
   ["polygon" /* POLYGON */]: polygonTokens.wpol,
+  /** Wrapped Ether (WETH) on zkSync Era */
   ["zksync" /* ZKSYNC */]: zkSyncTokens.weth,
+  /** Wrapped KAVA (WKAVA) on Kava EVM */
   ["kava_evm" /* KAVA_EVM */]: kavaTokens.wkava,
+  /** Wrapped AVAX (WAVAX) on Avalanche */
   ["avalanche" /* AVALANCHE */]: avalancheTokens.wavax,
+  /** Wrapped Ether (WETH) on Arbitrum */
   ["arbitrum" /* ARBITRUM */]: arbitrumTokens.weth,
+  /** Wrapped METIS (WMETIS) on Metis */
   ["metis" /* METIS */]: metisTokens.wmetis,
+  /** Wrapped Ether (WETH) on Base */
   ["base" /* BASE */]: baseTokens.weth,
+  /** Wrapped S (WS) on Sonic */
   ["sonic" /* SONIC */]: sonicTokens.ws,
+  /** Wrapped Ether (WETH) on Scroll */
   ["scroll" /* SCROLL */]: new Token(ChainIds["scroll" /* SCROLL */], "0x5300000000000000000000000000000000000004", 18, "WETH", "Wrapped Ether"),
+  /** Wrapped xDAI (WXDAI) on Gnosis Chain */
   ["gnosis" /* GNOSIS */]: new Token(ChainIds["gnosis" /* GNOSIS */], "0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d", 18, "WXDAI", "Wrapped XDAI"),
+  /** Wrapped HYPE (WHYPE) on HyperEVM */
   ["hyperevm" /* HYPEREVM */]: new Token(ChainIds["hyperevm" /* HYPEREVM */], "0x5555555555555555555555555555555555555555", 18, "WHYPE", "Wrapped HYPE"),
+  /** Wrapped XPL (WXPL) on Plasma */
   ["plasma" /* PLASMA */]: new Token(ChainIds["plasma" /* PLASMA */], "0x6100E367285b01F48D07953803A2d8dCA5D19873", 18, "WXPL", "Wrapped XPL")
 };
 
@@ -566,5 +573,54 @@ __export(ton_exports, {
 
 // src/blockchain/ton/types.ts
 var types_exports3 = {};
+function isAddress(value) {
+  let result = { valid: false };
+  try {
+    result.valid = isAddress$1(value);
+    if (result.valid) {
+      result.walletType = "evm" /* EVM */;
+    }
+  } catch (_error) {
+  }
+  try {
+    solana_exports.utils.toPublicKey(value);
+    result.valid = true;
+    result.walletType = "solana" /* SOLANA */;
+  } catch (_error) {
+  }
+  try {
+    Address.parse(value);
+    result.valid = true;
+    result.walletType = "ton" /* TON */;
+  } catch (_error) {
+  }
+  return result;
+}
+
+// src/adapter/transformers/toResult.ts
+function toResult(data, error = false) {
+  const formatedData = typeof data === "string" ? data : stringify(data);
+  return {
+    success: !error,
+    data: error ? `ERROR: ${formatedData}` : formatedData
+  };
+}
+
+// src/adapter/misc.ts
+var AdapterTag = /* @__PURE__ */ ((AdapterTag2) => {
+  AdapterTag2["ALM"] = "ALM";
+  AdapterTag2["STAKE"] = "Stake";
+  AdapterTag2["LENDING"] = "Lending";
+  AdapterTag2["FARM"] = "Farm";
+  AdapterTag2["PERPETUALS"] = "Perpetuals";
+  AdapterTag2["BRIDGE"] = "Bridge";
+  AdapterTag2["LIMIT_ORDER"] = "Limit orders";
+  AdapterTag2["DEX"] = "DEX";
+  AdapterTag2["LP"] = "LP";
+  AdapterTag2["GAMES"] = "Games";
+  AdapterTag2["CEX"] = "CEX";
+  AdapterTag2["LAUNCHPAD"] = "Launchpad";
+  return AdapterTag2;
+})(AdapterTag || {});
 
-export { AdapterTag, Chain, evm_exports as EVM, solana_exports as Solana, ton_exports as TON, WalletType, allChains, allEvmChains, retry, sleep, stringify, toResult };
+export { AdapterTag, Chain, evm_exports as EVM, solana_exports as Solana, ton_exports as TON, WalletType, allChains, allEvmChains, isAddress, retry, sleep, stringify, toResult };

package/dist/utils/index.d.ts

@@ -1,3 +1,4 @@
 export * from './retry';
 export * from './sleep';
 export * from './stringify';
+export * from './is-address';

package/dist/utils/is-address.d.ts

@@ -0,0 +1,7 @@
+import { WalletType } from '../blockchain';
+interface IsAddressResult {
+    valid: boolean;
+    walletType?: WalletType;
+}
+export declare function isAddress(value: string): IsAddressResult;
+export {};

package/dist/utils/is-address.spec.d.ts

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

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>;