@heyanon/sdk 2.3.2 → 2.3.4

package/dist/blockchain/evm/utils/isEvmChain.d.ts

@@ -1 +1,184 @@
+/**
+ * Checks if a given chain name is an EVM-compatible blockchain
+ * @param chain - The chain name to validate
+ * @returns True if the chain is EVM-compatible, false otherwise
+ * @description This function excludes non-EVM chains like Solana and TON
+ * @example
+ * ```typescript
+ * // Valid EVM chains
+ * console.log(isEvmChain('ethereum'));  // true
+ * console.log(isEvmChain('polygon'));   // true
+ * console.log(isEvmChain('bsc'));       // true
+ * console.log(isEvmChain('arbitrum'));  // true
+ * console.log(isEvmChain('base'));      // true
+ *
+ * // Non-EVM chains
+ * console.log(isEvmChain('solana'));    // false
+ * console.log(isEvmChain('ton'));       // false
+ *
+ * // Invalid/unknown chains
+ * console.log(isEvmChain('bitcoin'));   // false
+ * console.log(isEvmChain('cosmos'));    // false
+ * console.log(isEvmChain('unknown'));   // false
+ *
+ * // Use in adapter function routing
+ * async function processTransaction(chain: string, transaction: any) {
+ *   if (isEvmChain(chain)) {
+ *     // Use EVM-specific processing
+ *     return await options.evm.sendTransactions({
+ *       transactions: [transaction]
+ *     });
+ *   } else if (chain === 'solana') {
+ *     // Use Solana-specific processing
+ *     return await options.solana.sendTransactions({
+ *       transactions: [transaction]
+ *     });
+ *   } else if (chain === 'ton') {
+ *     // Use TON-specific processing
+ *     return await options.ton.sendTransactions({
+ *       transactions: [transaction]
+ *     });
+ *   } else {
+ *     throw new Error(`Unsupported chain: ${chain}`);
+ *   }
+ * }
+ *
+ * // Validate user input
+ * function validateChainSelection(selectedChain: string) {
+ *   if (!selectedChain) {
+ *     return { valid: false, error: 'Chain not selected' };
+ *   }
+ *
+ *   if (isEvmChain(selectedChain)) {
+ *     return {
+ *       valid: true,
+ *       type: 'evm',
+ *       chainId: getChainFromName(selectedChain as EvmChain)
+ *     };
+ *   }
+ *
+ *   if (selectedChain === 'solana' || selectedChain === 'ton') {
+ *     return { valid: true, type: selectedChain };
+ *   }
+ *
+ *   return { valid: false, error: `Unsupported chain: ${selectedChain}` };
+ * }
+ *
+ * // Filter tokens by chain type
+ * function filterTokensByChainType(tokens: UserToken[], evmOnly: boolean = false) {
+ *   if (evmOnly) {
+ *     return tokens.filter(token => isEvmChain(token.chain));
+ *   }
+ *   return tokens;
+ * }
+ *
+ * // Get appropriate provider based on chain
+ * function getChainProvider(chain: string) {
+ *   if (isEvmChain(chain)) {
+ *     const chainId = getChainFromName(chain as EvmChain);
+ *     return options.evm.getProvider(chainId);
+ *   } else if (chain === 'solana') {
+ *     return options.solana.getConnection();
+ *   } else if (chain === 'ton') {
+ *     return options.ton.getClient();
+ *   } else {
+ *     throw new Error(`No provider available for chain: ${chain}`);
+ *   }
+ * }
+ *
+ * // Multi-chain balance fetching with type checking
+ * async function getMultiChainBalances(
+ *   chains: string[],
+ *   tokenAddress: string,
+ *   userAddress: string
+ * ) {
+ *   const balances = await Promise.allSettled(
+ *     chains.map(async (chain) => {
+ *       if (isEvmChain(chain)) {
+ *         const provider = options.evm.getProvider(
+ *           getChainFromName(chain as EvmChain)
+ *         );
+ *
+ *         const balance = await provider.readContract({
+ *           address: tokenAddress,
+ *           abi: erc20Abi,
+ *           functionName: 'balanceOf',
+ *           args: [userAddress]
+ *         });
+ *
+ *         return { chain, balance, type: 'evm' };
+ *       } else {
+ *         // Handle non-EVM chains differently
+ *         throw new Error(`Non-EVM balance fetching not implemented for ${chain}`);
+ *       }
+ *     })
+ *   );
+ *
+ *   return balances
+ *     .filter((result): result is PromiseFulfilledResult<any> => result.status === 'fulfilled')
+ *     .map(result => result.value);
+ * }
+ *
+ * // Chain-specific transaction building
+ * function buildTransaction(chain: string, params: any) {
+ *   if (isEvmChain(chain)) {
+ *     return {
+ *       target: params.to,
+ *       data: params.data,
+ *       value: params.value || '0'
+ *     };
+ *   } else if (chain === 'solana') {
+ *     return {
+ *       instructions: params.instructions,
+ *       signers: params.signers
+ *     };
+ *   } else if (chain === 'ton') {
+ *     return {
+ *       to: params.to,
+ *       amount: params.amount,
+ *       payload: params.payload
+ *     };
+ *   } else {
+ *     throw new Error(`Cannot build transaction for unsupported chain: ${chain}`);
+ *   }
+ * }
+ *
+ * // UI component for chain selection
+ * function getChainCategories(chains: string[]) {
+ *   const evmChains = chains.filter(isEvmChain);
+ *   const nonEvmChains = chains.filter(chain => !isEvmChain(chain));
+ *
+ *   return {
+ *     evm: {
+ *       title: 'EVM Compatible',
+ *       chains: evmChains,
+ *       icon: 'ethereum-logo'
+ *     },
+ *     nonEvm: {
+ *       title: 'Other Blockchains',
+ *       chains: nonEvmChains,
+ *       icon: 'blockchain-logo'
+ *     }
+ *   };
+ * }
+ *
+ * // Type-safe chain processing
+ * function processChainSpecificOperation<T>(
+ *   chain: string,
+ *   evmHandler: (chain: EvmChain) => T,
+ *   solanaHandler: () => T,
+ *   tonHandler: () => T
+ * ): T {
+ *   if (isEvmChain(chain)) {
+ *     return evmHandler(chain as EvmChain);
+ *   } else if (chain === 'solana') {
+ *     return solanaHandler();
+ *   } else if (chain === 'ton') {
+ *     return tonHandler();
+ *   } else {
+ *     throw new Error(`Unsupported chain: ${chain}`);
+ *   }
+ * }
+ * ```
+ */
 export declare function isEvmChain(chain: string): boolean;

package/dist/blockchain/evm/utils/isNativeAddress.d.ts

@@ -0,0 +1,221 @@
+/**
+ * Checks if the given address represents a native token (ETH, BNB, MATIC, etc.)
+ * @param address - The token address to check
+ * @returns True if the address represents a native token, false otherwise
+ * @description Uses the special NATIVE_ADDRESS constant (0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) for comparison
+ * @example
+ * ```typescript
+ * // Check native token addresses
+ * console.log(isNativeAddress('0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE')); // true
+ * console.log(isNativeAddress('0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee')); // true (case insensitive)
+ *
+ * // Check ERC20 token addresses
+ * console.log(isNativeAddress('0xA0b86a33E6417e4681831442Ff7Bd6c25b5d9C7a')); // false (USDC)
+ * console.log(isNativeAddress('0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2')); // false (WETH)
+ *
+ * // Use in token swap logic
+ * async function handleTokenTransfer(
+ *   fromToken: string,
+ *   toToken: string,
+ *   amount: bigint,
+ *   recipient: string
+ * ) {
+ *   if (isNativeAddress(fromToken)) {
+ *     // Handle native token transfer (ETH, BNB, etc.)
+ *     return await options.evm.sendTransactions({
+ *       transactions: [{
+ *         target: recipient,
+ *         value: amount,
+ *         data: '0x'
+ *       }]
+ *     });
+ *   } else {
+ *     // Handle ERC20 token transfer
+ *     return await options.evm.sendTransactions({
+ *       transactions: [{
+ *         target: fromToken,
+ *         data: encodeFunctionData({
+ *           abi: erc20Abi,
+ *           functionName: 'transfer',
+ *           args: [recipient, amount]
+ *         })
+ *       }]
+ *     });
+ *   }
+ * }
+ *
+ * // Use in DEX swap preparation
+ * function prepareSwapTransaction(
+ *   tokenIn: string,
+ *   tokenOut: string,
+ *   amountIn: bigint,
+ *   chain: EvmChain
+ * ) {
+ *   const transactions: TransactionParams[] = [];
+ *
+ *   // If input token is native, we might need to wrap it first
+ *   if (isNativeAddress(tokenIn)) {
+ *     const wrapData = getWrapData(chain, amountIn);
+ *     transactions.push(wrapData);
+ *     tokenIn = getWrapAddress(chain); // Update to wrapped token address
+ *   } else {
+ *     // Approve ERC20 token for DEX router
+ *     transactions.push(...getApprovalTransactions(tokenIn, DEX_ROUTER, amountIn));
+ *   }
+ *
+ *   // Add swap transaction
+ *   transactions.push(buildSwapTransaction(tokenIn, tokenOut, amountIn));
+ *
+ *   // If output token should be native, add unwrap transaction
+ *   if (isNativeAddress(tokenOut)) {
+ *     const unwrapData = getUnwrapData(chain, expectedAmountOut);
+ *     transactions.push(unwrapData);
+ *   }
+ *
+ *   return transactions;
+ * }
+ *
+ * // Get token balance (native vs ERC20)
+ * async function getTokenBalance(
+ *   tokenAddress: string,
+ *   userAddress: string,
+ *   provider: PublicClient
+ * ): Promise<bigint> {
+ *   if (isNativeAddress(tokenAddress)) {
+ *     // Get native token balance (ETH, BNB, etc.)
+ *     return await provider.getBalance({ address: userAddress });
+ *   } else {
+ *     // Get ERC20 token balance
+ *     return await provider.readContract({
+ *       address: tokenAddress,
+ *       abi: erc20Abi,
+ *       functionName: 'balanceOf',
+ *       args: [userAddress]
+ *     });
+ *   }
+ * }
+ *
+ * // Token validation for UI
+ * function validateTokenAddress(address: string): {
+ *   valid: boolean;
+ *   type: 'native' | 'erc20' | 'invalid';
+ *   message?: string;
+ * } {
+ *   if (!address) {
+ *     return { valid: false, type: 'invalid', message: 'Address is required' };
+ *   }
+ *
+ *   if (isNativeAddress(address)) {
+ *     return { valid: true, type: 'native' };
+ *   }
+ *
+ *   if (isAddress(address)) {
+ *     return { valid: true, type: 'erc20' };
+ *   }
+ *
+ *   return { valid: false, type: 'invalid', message: 'Invalid address format' };
+ * }
+ *
+ * // Portfolio calculation with native tokens
+ * async function calculatePortfolioValue(
+ *   tokens: Array<{ address: string; amount: bigint }>,
+ *   chain: EvmChain
+ * ) {
+ *   const provider = options.evm.getProvider(getChainFromName(chain));
+ *
+ *   const tokenValues = await Promise.all(
+ *     tokens.map(async ({ address, amount }) => {
+ *       let tokenSymbol: string;
+ *       let tokenDecimals: number;
+ *
+ *       if (isNativeAddress(address)) {
+ *         // Handle native token
+ *         tokenSymbol = getNativeTokenSymbol(chain); // ETH, BNB, MATIC, etc.
+ *         tokenDecimals = 18;
+ *       } else {
+ *         // Handle ERC20 token
+ *         [tokenSymbol, tokenDecimals] = await Promise.all([
+ *           provider.readContract({
+ *             address: address,
+ *             abi: erc20Abi,
+ *             functionName: 'symbol'
+ *           }),
+ *           provider.readContract({
+ *             address: address,
+ *             abi: erc20Abi,
+ *             functionName: 'decimals'
+ *           })
+ *         ]);
+ *       }
+ *
+ *       const formattedAmount = formatUnits(amount, tokenDecimals);
+ *       const usdValue = await getTokenPriceUSD(tokenSymbol);
+ *
+ *       return {
+ *         address,
+ *         symbol: tokenSymbol,
+ *         amount: formattedAmount,
+ *         usdValue: parseFloat(formattedAmount) * usdValue,
+ *         isNative: isNativeAddress(address)
+ *       };
+ *     })
+ *   );
+ *
+ *   return tokenValues;
+ * }
+ *
+ * // Gas estimation for different token types
+ * async function estimateTransferGas(
+ *   tokenAddress: string,
+ *   to: string,
+ *   amount: bigint,
+ *   from: string,
+ *   provider: PublicClient
+ * ): Promise<bigint> {
+ *   if (isNativeAddress(tokenAddress)) {
+ *     // Estimate gas for native token transfer
+ *     return await provider.estimateGas({
+ *       account: from,
+ *       to,
+ *       value: amount
+ *     });
+ *   } else {
+ *     // Estimate gas for ERC20 transfer
+ *     return await provider.estimateGas({
+ *       account: from,
+ *       to: tokenAddress,
+ *       data: encodeFunctionData({
+ *         abi: erc20Abi,
+ *         functionName: 'transfer',
+ *         args: [to, amount]
+ *       })
+ *     });
+ *   }
+ * }
+ *
+ * // Filter tokens by type
+ * function filterTokensByType(
+ *   tokens: UserToken[],
+ *   includeNative: boolean = true,
+ *   includeERC20: boolean = true
+ * ) {
+ *   return tokens.filter(token => {
+ *     const isNative = isNativeAddress(token.address);
+ *     return (includeNative && isNative) || (includeERC20 && !isNative);
+ *   });
+ * }
+ *
+ * // Transaction fee calculation
+ * function calculateTransactionCost(
+ *   tokenAddress: string,
+ *   gasPrice: bigint,
+ *   gasLimit: bigint
+ * ): { gasCost: bigint; requiresNativeForGas: boolean } {
+ *   const gasCost = gasPrice * gasLimit;
+ *   const requiresNativeForGas = !isNativeAddress(tokenAddress);
+ *
+ *   return { gasCost, requiresNativeForGas };
+ * }
+ * ```
+ */
+export declare function isNativeAddress(address: string): boolean;

package/dist/blockchain/evm/utils/isNativeAddress.test.d.ts

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

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

@@ -1,16 +1,307 @@
 import { PublicKey, TransactionSignature, VersionedTransaction, Transaction } from '@solana/web3.js';
+/**
+ * Data returned for each executed Solana transaction
+ * @interface TransactionReturnData
+ * @example
+ * ```typescript
+ * // Successful transaction result
+ * const successData: TransactionReturnData = {
+ *   message: "Transaction confirmed",
+ *   hash: "2ZE7R7Xhm9V8Qf4vKyRKMJ6XHKM6eRXmFw7P8NXTW7qTgJhG5jzYR4M8KKvxjJb9Vs6KfYQpYsKJ4JUhP5K"
+ * };
+ *
+ * // Failed transaction result
+ * const failedData: TransactionReturnData = {
+ *   message: "Transaction failed: Insufficient funds",
+ *   hash: "3AF8S8Ymi0W9Rg5wLzSKNK7YILM7fSYnGx8Q9OYUX8rUhKiH6kzZS5N9LLwyKc0Wr7LgZRqQtLJ5KViQ6L"
+ * };
+ *
+ * // Process transaction result
+ * function handleTransactionResult(result: TransactionReturnData) {
+ *   console.log(`Status: ${result.message}`);
+ *   console.log(`Transaction: https://solscan.io/tx/${result.hash}`);
+ *
+ *   if (result.message.includes('confirmed')) {
+ *     // Handle success
+ *     showSuccessNotification(result.hash);
+ *   } else {
+ *     // Handle error
+ *     showErrorNotification(result.message);
+ *   }
+ * }
+ * ```
+ */
 export interface TransactionReturnData {
+    /** Status message or error description */
     readonly message: string;
+    /** Transaction signature/hash on Solana blockchain */
     readonly hash: TransactionSignature;
 }
+/**
+ * Complete result of Solana transaction execution containing all transaction results
+ * @interface TransactionReturn
+ * @example
+ * ```typescript
+ * // Batch transaction result
+ * const batchResult: TransactionReturn = {
+ *   data: [
+ *     {
+ *       message: "Token transfer confirmed",
+ *       hash: "2ZE7R7Xhm9V8Qf4vKyRKMJ6XHKM6eRXmFw7P8NXTW7qTgJhG5jzYR4M8KKvxjJb9Vs6KfYQpYsKJ4JUhP5K"
+ *     },
+ *     {
+ *       message: "Swap completed",
+ *       hash: "3AF8S8Ymi0W9Rg5wLzSKNK7YILM7fSYnGx8Q9OYUX8rUhKiH6kzZS5N9LLwyKc0Wr7LgZRqQtLJ5KViQ6L"
+ *     }
+ *   ]
+ * };
+ *
+ * // Single transaction result
+ * const singleResult: TransactionReturn = {
+ *   data: [{
+ *     message: "SOL transfer successful",
+ *     hash: "4BG9T9Znj1X0Sg6xMzTKOL8YJMN8gTZoHy9R0PZVY9sVjLjI7l0aT6O0MMxzLd1Xs8MhaSrRuMK6LWjR7M"
+ *   }]
+ * };
+ *
+ * // Process all results
+ * function processBatchResults(result: TransactionReturn) {
+ *   const successful = result.data.filter(tx =>
+ *     tx.message.includes('confirmed') || tx.message.includes('successful')
+ *   );
+ *
+ *   const failed = result.data.filter(tx =>
+ *     tx.message.includes('failed') || tx.message.includes('error')
+ *   );
+ *
+ *   console.log(`Successful: ${successful.length}, Failed: ${failed.length}`);
+ *
+ *   // Create summary for user
+ *   return {
+ *     totalTransactions: result.data.length,
+ *     successCount: successful.length,
+ *     failureCount: failed.length,
+ *     successfulHashes: successful.map(tx => tx.hash),
+ *     failedHashes: failed.map(tx => tx.hash)
+ *   };
+ * }
+ * ```
+ */
 export interface TransactionReturn {
+    /** Array of transaction results */
     readonly data: TransactionReturnData[];
 }
+/**
+ * Properties for sending one or multiple Solana transactions
+ * @interface SendTransactionProps
+ * @example
+ * ```typescript
+ * // Single transaction
+ * const transferProps: SendTransactionProps = {
+ *   account: toPublicKey('11111111111111111111111111111112'),
+ *   transactions: [await buildV0Transaction({
+ *     connection: options.solana.getConnection(),
+ *     payer: userPublicKey,
+ *     instructions: [SystemProgram.transfer({
+ *       fromPubkey: userPublicKey,
+ *       toPubkey: recipientPublicKey,
+ *       lamports: 0.1 * LAMPORTS_PER_SOL
+ *     })]
+ *   })]
+ * };
+ *
+ * // Multiple transactions (batch operations)
+ * const batchProps: SendTransactionProps = {
+ *   account: userPublicKey,
+ *   transactions: [
+ *     await buildV0Transaction({
+ *       connection: options.solana.getConnection(),
+ *       payer: userPublicKey,
+ *       instructions: [createAssociatedTokenAccountInstruction(
+ *         userPublicKey, // payer
+ *         tokenAccount, // associated token account
+ *         userPublicKey, // owner
+ *         mintAddress // mint
+ *       )]
+ *     }),
+ *     await buildV0Transaction({
+ *       connection: options.solana.getConnection(),
+ *       payer: userPublicKey,
+ *       instructions: [createTransferInstruction(
+ *         fromTokenAccount,
+ *         toTokenAccount,
+ *         userPublicKey,
+ *         100_000 // 0.1 USDC
+ *       )]
+ *     })
+ *   ]
+ * };
+ *
+ * // Jupiter swap transaction
+ * const swapProps: SendTransactionProps = {
+ *   account: await options.solana.getPublicKey(),
+ *   transactions: [await buildV0Transaction({
+ *     connection: options.solana.getConnection(),
+ *     payer: await options.solana.getPublicKey(),
+ *     instructions: await getJupiterSwapInstructions({
+ *       inputMint: 'So11111111111111111111111111111111111111112', // SOL
+ *       outputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', // USDC
+ *       amount: 0.1 * LAMPORTS_PER_SOL,
+ *       slippageBps: 50
+ *     })
+ *   })]
+ * };
+ *
+ * // Usage in adapter function
+ * async function executeSolanaTransactions(props: SendTransactionProps) {
+ *   const result = await options.solana.sendTransactions(props);
+ *
+ *   // Log all transaction hashes
+ *   result.data.forEach((tx, index) => {
+ *     console.log(`Transaction ${index + 1}: ${tx.hash}`);
+ *   });
+ *
+ *   return result;
+ * }
+ *
+ * // Error handling wrapper
+ * async function safeSendTransactions(props: SendTransactionProps) {
+ *   try {
+ *     return await options.solana.sendTransactions(props);
+ *   } catch (error) {
+ *     console.error('Failed to send transactions:', error);
+ *     return {
+ *       data: props.transactions.map(() => ({
+ *         message: `Transaction failed: ${error.message}`,
+ *         hash: '' as TransactionSignature
+ *       }))
+ *     };
+ *   }
+ * }
+ * ```
+ */
 export interface SendTransactionProps {
+    /** Account that will execute the transactions */
     readonly account: PublicKey;
+    /** Array of versioned transactions to execute */
     readonly transactions: VersionedTransaction[];
 }
+/**
+ * Properties for signing Solana transactions
+ * @interface SignTransactionProps
+ * @example
+ * ```typescript
+ * // Sign a versioned transaction (default)
+ * const signProps: SignTransactionProps = {
+ *   transaction: await buildV0Transaction({
+ *     connection: options.solana.getConnection(),
+ *     payer: userPublicKey,
+ *     instructions: [transferInstruction]
+ *   })
+ * };
+ *
+ * // Sign with specific method
+ * const partialSignProps: SignTransactionProps = {
+ *   transaction: versionedTransaction,
+ *   signName: 'partialSign' // For multi-sig scenarios
+ * };
+ *
+ * // Sign legacy transaction
+ * const legacySignProps: SignTransactionProps = {
+ *   transaction: new Transaction().add(transferInstruction),
+ *   signName: 'sign'
+ * };
+ *
+ * // Multi-signature workflow
+ * async function multiSigTransactionFlow(
+ *   transaction: VersionedTransaction,
+ *   signers: PublicKey[]
+ * ) {
+ *   const signatures: (VersionedTransaction | Transaction)[] = [];
+ *
+ *   // Each signer partially signs the transaction
+ *   for (const signer of signers) {
+ *     const signedTx = await options.solana.signTransactions([{
+ *       transaction,
+ *       signName: 'partialSign'
+ *     }]);
+ *
+ *     signatures.push(signedTx[0]);
+ *   }
+ *
+ *   return signatures;
+ * }
+ *
+ * // Batch signing
+ * async function signMultipleTransactions(
+ *   transactions: (VersionedTransaction | Transaction)[]
+ * ) {
+ *   const signProps = transactions.map(tx => ({
+ *     transaction: tx,
+ *     signName: 'sign' as const
+ *   }));
+ *
+ *   return await options.solana.signTransactions(signProps);
+ * }
+ *
+ * // Conditional signing based on transaction type
+ * function createSignProps(
+ *   transaction: VersionedTransaction | Transaction,
+ *   isMultiSig: boolean = false
+ * ): SignTransactionProps {
+ *   return {
+ *     transaction,
+ *     signName: isMultiSig ? 'partialSign' : 'sign'
+ *   };
+ * }
+ *
+ * // Prepare transaction for signing
+ * async function prepareAndSignTransaction(
+ *   instructions: TransactionInstruction[],
+ *   requiresPartialSign: boolean = false
+ * ) {
+ *   const transaction = await buildV0Transaction({
+ *     connection: options.solana.getConnection(),
+ *     payer: await options.solana.getPublicKey(),
+ *     instructions
+ *   });
+ *
+ *   const signProps: SignTransactionProps = {
+ *     transaction,
+ *     signName: requiresPartialSign ? 'partialSign' : 'sign'
+ *   };
+ *
+ *   const [signedTransaction] = await options.solana.signTransactions([signProps]);
+ *   return signedTransaction;
+ * }
+ *
+ * // Integration with wallet adapters
+ * async function signTransactionWithWallet(
+ *   transaction: VersionedTransaction,
+ *   walletType: 'phantom' | 'solflare' | 'backpack'
+ * ) {
+ *   const signProps: SignTransactionProps = {
+ *     transaction,
+ *     signName: 'sign'
+ *   };
+ *
+ *   // Different wallets might have different signing patterns
+ *   switch (walletType) {
+ *     case 'phantom':
+ *       return await options.solana.signTransactions([signProps]);
+ *     case 'solflare':
+ *       return await options.solana.signTransactions([signProps]);
+ *     case 'backpack':
+ *       return await options.solana.signTransactions([signProps]);
+ *     default:
+ *       throw new Error(`Unsupported wallet: ${walletType}`);
+ *   }
+ * }
+ * ```
+ */
 export interface SignTransactionProps {
+    /** Transaction to sign (versioned or legacy) */
     readonly transaction: VersionedTransaction | Transaction;
+    /** Signing method - 'sign' for full signature, 'partialSign' for multi-sig scenarios */
     readonly signName?: 'sign' | 'partialSign';
 }