@heyanon/sdk 2.3.2 → 2.3.4

package/dist/blockchain/ton/types.d.ts

@@ -2,20 +2,430 @@ import { SenderArguments } from '@ton/core';
 import { TonApiClient } from '@ton-api/client';
 import { ContractAdapter } from '@ton-api/ton-adapter';
 import { Address, TonClient, TonClient4 } from '@ton/ton';
+/**
+ * Data returned for each executed TON transaction
+ * @interface TransactionReturnData
+ * @example
+ * ```typescript
+ * // Successful transaction result
+ * const successData: TransactionReturnData = {
+ *   message: "Transaction confirmed",
+ *   hash: "a1b2c3d4e5f6789012345678901234567890abcdef1234567890abcdef123456"
+ * };
+ *
+ * // Failed transaction result
+ * const failedData: TransactionReturnData = {
+ *   message: "Transaction failed: Insufficient balance",
+ *   hash: "b2c3d4e5f6789012345678901234567890abcdef1234567890abcdef1234567a"
+ * };
+ *
+ * // Process transaction result
+ * function handleTonTransactionResult(result: TransactionReturnData) {
+ *   console.log(`Status: ${result.message}`);
+ *   console.log(`Transaction: https://tonscan.org/tx/${result.hash}`);
+ *
+ *   if (result.message.includes('confirmed')) {
+ *     // Handle success
+ *     showSuccessNotification(`Transaction confirmed: ${result.hash}`);
+ *   } else {
+ *     // Handle error
+ *     showErrorNotification(result.message);
+ *   }
+ * }
+ *
+ * // Extract transaction details
+ * function parseTransactionResult(result: TransactionReturnData) {
+ *   return {
+ *     isSuccess: result.message.includes('confirmed') || result.message.includes('successful'),
+ *     transactionId: result.hash,
+ *     explorerUrl: `https://tonscan.org/tx/${result.hash}`,
+ *     statusMessage: result.message
+ *   };
+ * }
+ * ```
+ */
 export interface TransactionReturnData {
+    /** Status message or error description */
     readonly message: string;
+    /** Transaction hash on TON blockchain */
     readonly hash: string;
 }
+/**
+ * Complete result of TON transaction execution containing all transaction results
+ * @interface TransactionReturn
+ * @example
+ * ```typescript
+ * // Batch transaction result
+ * const batchResult: TransactionReturn = {
+ *   data: [
+ *     {
+ *       message: "TON transfer confirmed",
+ *       hash: "a1b2c3d4e5f6789012345678901234567890abcdef1234567890abcdef123456"
+ *     },
+ *     {
+ *       message: "Jetton transfer completed",
+ *       hash: "b2c3d4e5f6789012345678901234567890abcdef1234567890abcdef1234567a"
+ *     }
+ *   ]
+ * };
+ *
+ * // Single transaction result
+ * const singleResult: TransactionReturn = {
+ *   data: [{
+ *     message: "Smart contract deployment successful",
+ *     hash: "c3d4e5f6789012345678901234567890abcdef1234567890abcdef1234567ab2"
+ *   }]
+ * };
+ *
+ * // Process all results
+ * function processTonBatchResults(result: TransactionReturn) {
+ *   const successful = result.data.filter(tx =>
+ *     tx.message.includes('confirmed') ||
+ *     tx.message.includes('successful') ||
+ *     tx.message.includes('completed')
+ *   );
+ *
+ *   const failed = result.data.filter(tx =>
+ *     tx.message.includes('failed') ||
+ *     tx.message.includes('error') ||
+ *     tx.message.includes('rejected')
+ *   );
+ *
+ *   console.log(`TON Transactions - Successful: ${successful.length}, Failed: ${failed.length}`);
+ *
+ *   // Create comprehensive summary
+ *   return {
+ *     totalTransactions: result.data.length,
+ *     successCount: successful.length,
+ *     failureCount: failed.length,
+ *     successfulHashes: successful.map(tx => tx.hash),
+ *     failedHashes: failed.map(tx => tx.hash),
+ *     explorerLinks: result.data.map(tx => `https://tonscan.org/tx/${tx.hash}`)
+ *   };
+ * }
+ *
+ * // Calculate transaction fees
+ * async function calculateTransactionCosts(result: TransactionReturn, client: Client) {
+ *   const costs = await Promise.all(
+ *     result.data.map(async (tx) => {
+ *       try {
+ *         const txData = await client.api.blockchain.getBlockchainTransaction(tx.hash);
+ *         return {
+ *           hash: tx.hash,
+ *           fee: txData.fee.total,
+ *           success: tx.message.includes('confirmed')
+ *         };
+ *       } catch (error) {
+ *         return {
+ *           hash: tx.hash,
+ *           fee: 0,
+ *           success: false,
+ *           error: error.message
+ *         };
+ *       }
+ *     })
+ *   );
+ *
+ *   return costs;
+ * }
+ * ```
+ */
 export interface TransactionReturn {
+    /** Array of transaction results */
     readonly data: TransactionReturnData[];
 }
+/**
+ * Properties for sending one or multiple TON transactions
+ * @interface SendTransactionProps
+ * @example
+ * ```typescript
+ * // Simple TON transfer
+ * const transferProps: SendTransactionProps = {
+ *   account: Address.parse('EQD4FPq-PRDieyQKkizFTRtSDyucUIqrj0v_zXJmqaDp6_0t'),
+ *   transactions: [{
+ *     to: Address.parse('EQCD39VS5jcptHL8vMjEXrzGaRcCVYto7HUn4bpAOg8xqB2N'),
+ *     value: toNano('1'), // 1 TON
+ *     body: beginCell().endCell(), // Empty body for simple transfer
+ *     bounce: false
+ *   }]
+ * };
+ *
+ * // Jetton (TON token) transfer
+ * const jettonTransferProps: SendTransactionProps = {
+ *   account: senderAddress,
+ *   transactions: [{
+ *     to: jettonWalletAddress,
+ *     value: toNano('0.1'), // Gas fee
+ *     body: beginCell()
+ *       .storeUint(0xf8a7ea5, 32) // Jetton transfer opcode
+ *       .storeUint(0, 64) // Query ID
+ *       .storeCoins(toNano('100')) // Jetton amount
+ *       .storeAddress(recipientAddress)
+ *       .storeAddress(senderAddress) // Response address
+ *       .storeBit(0) // Custom payload
+ *       .storeCoins(toNano('0.01')) // Forward amount
+ *       .storeBit(0) // Forward payload
+ *       .endCell(),
+ *     bounce: false
+ *   }]
+ * };
+ *
+ * // Smart contract deployment
+ * const deployProps: SendTransactionProps = {
+ *   account: deployerAddress,
+ *   transactions: [{
+ *     to: contractAddress,
+ *     value: toNano('0.5'), // Initial contract balance
+ *     body: beginCell()
+ *       .storeRef(contractCode) // Contract code
+ *       .storeRef(contractData) // Initial data
+ *       .endCell(),
+ *     bounce: false,
+ *     init: {
+ *       code: contractCode,
+ *       data: contractData
+ *     }
+ *   }]
+ * };
+ *
+ * // Batch operations (multiple transactions)
+ * const batchProps: SendTransactionProps = {
+ *   account: userAddress,
+ *   transactions: [
+ *     {
+ *       to: Address.parse('EQCD39VS5jcptHL8vMjEXrzGaRcCVYto7HUn4bpAOg8xqB2N'),
+ *       value: toNano('0.5'),
+ *       body: beginCell().endCell(),
+ *       bounce: false
+ *     },
+ *     {
+ *       to: jettonMasterAddress,
+ *       value: toNano('0.1'),
+ *       body: buildJettonMintBody({
+ *         recipient: userAddress,
+ *         amount: toNano('1000'),
+ *         queryId: Date.now()
+ *       }),
+ *       bounce: true
+ *     }
+ *   ]
+ * };
+ *
+ * // DEX operations (DeDust swap)
+ * const swapProps: SendTransactionProps = {
+ *   account: await options.ton.getAddress(),
+ *   transactions: [{
+ *     to: poolAddress,
+ *     value: toNano('1.5'), // TON amount + gas
+ *     body: beginCell()
+ *       .storeUint(0xea06185d, 32) // Swap opcode
+ *       .storeUint(0, 64) // Query ID
+ *       .storeCoins(toNano('1')) // Amount in
+ *       .storeAddress(jettonAddressOut)
+ *       .storeCoins(minAmountOut)
+ *       .storeAddress(userAddress) // Recipient
+ *       .endCell(),
+ *     bounce: true
+ *   }]
+ * };
+ *
+ * // NFT operations
+ * const nftTransferProps: SendTransactionProps = {
+ *   account: nftOwnerAddress,
+ *   transactions: [{
+ *     to: nftItemAddress,
+ *     value: toNano('0.1'),
+ *     body: beginCell()
+ *       .storeUint(0x5fcc3d14, 32) // NFT transfer opcode
+ *       .storeUint(0, 64) // Query ID
+ *       .storeAddress(newOwnerAddress)
+ *       .storeAddress(nftOwnerAddress) // Response address
+ *       .storeBit(0) // Custom payload
+ *       .storeCoins(toNano('0.01')) // Forward amount
+ *       .endCell(),
+ *     bounce: false
+ *   }]
+ * };
+ *
+ * // Usage in adapter function
+ * async function executeTonTransactions(props: SendTransactionProps) {
+ *   const result = await options.ton.sendTransactions(props);
+ *
+ *   // Log all transaction hashes
+ *   result.data.forEach((tx, index) => {
+ *     console.log(`TON Transaction ${index + 1}: ${tx.hash}`);
+ *     console.log(`Status: ${tx.message}`);
+ *   });
+ *
+ *   return result;
+ * }
+ * ```
+ */
 export interface SendTransactionProps {
+    /** Account that will execute the transactions */
     readonly account: Address;
+    /** Array of TON transaction arguments */
     readonly transactions: SenderArguments[];
 }
+/**
+ * TON blockchain client configuration with multiple client types and adapters
+ * @interface Client
+ * @example
+ * ```typescript
+ * // Create TON client configuration
+ * const tonClient: Client = {
+ *   api: new TonApiClient({
+ *     baseUrl: 'https://tonapi.io',
+ *     apiKey: 'your-api-key'
+ *   }),
+ *   client: new TonClient({
+ *     endpoint: 'https://toncenter.com/api/v2/jsonRPC'
+ *   }),
+ *   client4: new TonClient4({
+ *     endpoint: 'https://mainnet-v4.tonhubapi.com'
+ *   }),
+ *   adapter: new ContractAdapter()
+ * };
+ *
+ * // Use different clients for different operations
+ * async function getTonAccountInfo(address: Address, client: Client) {
+ *   // Use TonApiClient for rich API data
+ *   const accountInfo = await client.api.accounts.getAccount(address.toString());
+ *
+ *   // Use TonClient for basic operations
+ *   const balance = await client.client.getBalance(address);
+ *
+ *   // Use TonClient4 for v4 API features
+ *   const accountState = await client.client4.getAccount(
+ *     client.client4.provider.block.lastSeqno,
+ *     address
+ *   );
+ *
+ *   return {
+ *     address: address.toString(),
+ *     balance: balance.toString(),
+ *     status: accountInfo.status,
+ *     lastActivity: accountInfo.lastActivity,
+ *     interfaces: accountInfo.interfaces
+ *   };
+ * }
+ *
+ * // Smart contract interaction
+ * async function interactWithContract(
+ *   contractAddress: Address,
+ *   method: string,
+ *   params: any[],
+ *   client: Client
+ * ) {
+ *   // Use adapter for contract interactions
+ *   const contract = client.adapter.open(
+ *     Contract.create({
+ *       workchain: contractAddress.workChain,
+ *       address: contractAddress.hash
+ *     }, contractCode)
+ *   );
+ *
+ *   // Call contract method
+ *   const result = await contract.get(method, params);
+ *   return result;
+ * }
+ *
+ * // Jetton operations using different clients
+ * async function getJettonInfo(jettonMaster: Address, client: Client) {
+ *   // Get jetton data using API client
+ *   const jettonInfo = await client.api.jettons.getJetton(jettonMaster.toString());
+ *
+ *   // Get on-chain data using TonClient
+ *   const jettonData = await client.client.runMethod(jettonMaster, 'get_jetton_data');
+ *
+ *   return {
+ *     name: jettonInfo.metadata?.name,
+ *     symbol: jettonInfo.metadata?.symbol,
+ *     decimals: jettonInfo.metadata?.decimals,
+ *     totalSupply: jettonData.stack.readBigNumber(),
+ *     mintable: jettonData.stack.readBoolean(),
+ *     adminAddress: jettonData.stack.readAddress()
+ *   };
+ * }
+ *
+ * // Transaction tracking
+ * async function trackTransaction(hash: string, client: Client) {
+ *   try {
+ *     // Use API client for detailed transaction info
+ *     const txInfo = await client.api.blockchain.getBlockchainTransaction(hash);
+ *
+ *     return {
+ *       hash: txInfo.hash,
+ *       success: txInfo.success,
+ *       fee: txInfo.fee.total,
+ *       timestamp: txInfo.utime,
+ *       inMsg: txInfo.inMsg,
+ *       outMsgs: txInfo.outMsgs
+ *     };
+ *   } catch (error) {
+ *     console.error('Failed to track transaction:', error);
+ *     return null;
+ *   }
+ * }
+ *
+ * // Multi-client balance checking
+ * async function getComprehensiveBalance(address: Address, client: Client) {
+ *   const [apiBalance, clientBalance, client4Balance] = await Promise.allSettled([
+ *     client.api.accounts.getAccount(address.toString())
+ *       .then(acc => acc.balance),
+ *     client.client.getBalance(address),
+ *     client.client4.getAccount(
+ *       await client.client4.provider.block.lastSeqno,
+ *       address
+ *     ).then(acc => acc.account.balance?.coins || 0n)
+ *   ]);
+ *
+ *   return {
+ *     api: apiBalance.status === 'fulfilled' ? apiBalance.value : null,
+ *     client: clientBalance.status === 'fulfilled' ? clientBalance.value : null,
+ *     client4: client4Balance.status === 'fulfilled' ? client4Balance.value : null
+ *   };
+ * }
+ *
+ * // Initialize client with configuration
+ * function createTonClient(config: {
+ *   apiKey?: string;
+ *   network?: 'mainnet' | 'testnet';
+ *   endpoints?: {
+ *     api?: string;
+ *     client?: string;
+ *     client4?: string;
+ *   };
+ * }): Client {
+ *   const isTestnet = config.network === 'testnet';
+ *
+ *   return {
+ *     api: new TonApiClient({
+ *       baseUrl: config.endpoints?.api || (isTestnet ? 'https://testnet.tonapi.io' : 'https://tonapi.io'),
+ *       apiKey: config.apiKey
+ *     }),
+ *     client: new TonClient({
+ *       endpoint: config.endpoints?.client || (isTestnet
+ *         ? 'https://testnet.toncenter.com/api/v2/jsonRPC'
+ *         : 'https://toncenter.com/api/v2/jsonRPC')
+ *     }),
+ *     client4: new TonClient4({
+ *       endpoint: config.endpoints?.client4 || (isTestnet
+ *         ? 'https://testnet-v4.tonhubapi.com'
+ *         : 'https://mainnet-v4.tonhubapi.com')
+ *     }),
+ *     adapter: new ContractAdapter()
+ *   };
+ * }
+ * ```
+ */
 export interface Client {
+    /** TON API client for rich blockchain data and operations */
     readonly api: TonApiClient;
+    /** Standard TON client for basic blockchain operations */
     readonly client: TonClient;
+    /** TON v4 client for advanced features and better performance */
     readonly client4: TonClient4;
+    /** Contract adapter for smart contract interactions */
     readonly adapter: ContractAdapter;
 }

package/dist/index.js

@@ -3,6 +3,7 @@
 var viem = require('viem');
 var sdk = require('@real-wagmi/sdk');
 var web3_js = require('@solana/web3.js');
+var ton = require('@ton/ton');
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -38,32 +39,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, {
@@ -89,7 +64,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;
@@ -174,39 +151,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 */]: sdk.ethereumTokens.weth,
+  /** Wrapped Ether (WETH) on Optimism */
   ["optimism" /* OPTIMISM */]: sdk.optimismTokens.weth,
+  /** Wrapped BNB (WBNB) on Binance Smart Chain */
   ["bsc" /* BSC */]: sdk.bscTokens.wbnb,
+  /** Wrapped POL (WPOL) on Polygon */
   ["polygon" /* POLYGON */]: sdk.polygonTokens.wpol,
+  /** Wrapped Ether (WETH) on zkSync Era */
   ["zksync" /* ZKSYNC */]: sdk.zkSyncTokens.weth,
+  /** Wrapped KAVA (WKAVA) on Kava EVM */
   ["kava_evm" /* KAVA_EVM */]: sdk.kavaTokens.wkava,
+  /** Wrapped AVAX (WAVAX) on Avalanche */
   ["avalanche" /* AVALANCHE */]: sdk.avalancheTokens.wavax,
+  /** Wrapped Ether (WETH) on Arbitrum */
   ["arbitrum" /* ARBITRUM */]: sdk.arbitrumTokens.weth,
+  /** Wrapped METIS (WMETIS) on Metis */
   ["metis" /* METIS */]: sdk.metisTokens.wmetis,
+  /** Wrapped Ether (WETH) on Base */
   ["base" /* BASE */]: sdk.baseTokens.weth,
+  /** Wrapped S (WS) on Sonic */
   ["sonic" /* SONIC */]: sdk.sonicTokens.ws,
+  /** Wrapped Ether (WETH) on Scroll */
   ["scroll" /* SCROLL */]: new sdk.Token(ChainIds["scroll" /* SCROLL */], "0x5300000000000000000000000000000000000004", 18, "WETH", "Wrapped Ether"),
+  /** Wrapped xDAI (WXDAI) on Gnosis Chain */
   ["gnosis" /* GNOSIS */]: new sdk.Token(ChainIds["gnosis" /* GNOSIS */], "0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d", 18, "WXDAI", "Wrapped XDAI"),
+  /** Wrapped HYPE (WHYPE) on HyperEVM */
   ["hyperevm" /* HYPEREVM */]: new sdk.Token(ChainIds["hyperevm" /* HYPEREVM */], "0x5555555555555555555555555555555555555555", 18, "WHYPE", "Wrapped HYPE"),
+  /** Wrapped XPL (WXPL) on Plasma */
   ["plasma" /* PLASMA */]: new sdk.Token(ChainIds["plasma" /* PLASMA */], "0x6100E367285b01F48D07953803A2d8dCA5D19873", 18, "WXPL", "Wrapped XPL")
 };
 
@@ -568,6 +575,55 @@ __export(ton_exports, {
 
 // src/blockchain/ton/types.ts
 var types_exports3 = {};
+function isAddress(value) {
+  let result = { valid: false };
+  try {
+    result.valid = viem.isAddress(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 {
+    ton.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 || {});
 
 exports.AdapterTag = AdapterTag;
 exports.Chain = Chain;
@@ -577,6 +633,7 @@ exports.TON = ton_exports;
 exports.WalletType = WalletType;
 exports.allChains = allChains;
 exports.allEvmChains = allEvmChains;
+exports.isAddress = isAddress;
 exports.retry = retry;
 exports.sleep = sleep;
 exports.stringify = stringify;