pwc-sdk-wallet 0.8.2 → 0.8.4

package/README.md

@@ -1881,6 +1881,9 @@ console.log('New account address:', newAccount.address);
 // Add a new Solana account
 const newSolanaAccount = await vault.addNewSolanaAccount();
 console.log('New Solana account:', newSolanaAccount.address);
+
+// Note: All Solana accounts are automatically persisted when you encrypt and save the vault.
+// When you load the vault later, all previously added accounts will be restored.
 ```
 
 #### Add New TRON Account

package/dist/Vault.js

@@ -1000,6 +1000,7 @@ class Vault {
             const chainService = new ChainService_1.ChainService(privateKey, chainInfo);
             const tx = {
                 to: to,
+                // @ts-expect-error - ethers v6 parseEther compatibility
                 value: ethers_1.ethers.parseEther(amount)
             };
             return chainService.estimateGas(tx);
@@ -1041,6 +1042,7 @@ class Vault {
             const chainService = new ChainService_1.ChainService(privateKey, chainInfo);
             // Get token info to parse amount correctly
             const tokenInfo = await chainService.getTokenInfo(tokenAddress);
+            // @ts-expect-error - ethers v6 parseUnits compatibility
             const parsedAmount = ethers_1.ethers.parseUnits(amount, tokenInfo.decimals);
             // Create contract instance for gas estimation
             const contract = new ethers_1.ethers.Contract(tokenAddress, [
@@ -1365,6 +1367,7 @@ class Vault {
             // Create transaction request for native token transfer
             const txRequest = {
                 to: to,
+                // @ts-expect-error - ethers v6 parseEther compatibility
                 value: ethers_1.ethers.parseEther(amount)
             };
             const result = await chainService.sendTransaction(txRequest);

package/dist/chain/ChainService.js

@@ -28,6 +28,7 @@ class ChainService {
         if (chainConfig.type !== 'evm') {
             throw new Error('ChainService only supports EVM chains');
         }
+        // @ts-expect-error - ethers v6 JsonRpcProvider compatibility
         const provider = new ethers_1.ethers.JsonRpcProvider(chainConfig.rpcUrl);
         this.wallet = new ethers_1.ethers.Wallet(privateKey, provider);
     }
@@ -48,7 +49,8 @@ class ChainService {
         if (!this.wallet.provider) {
             throw new Error('Provider not set for wallet.');
         }
-        return this.wallet.provider.getBalance(this.wallet.address);
+        const balance = await this.wallet.provider.getBalance(this.wallet.address);
+        return typeof balance === 'bigint' ? balance : BigInt(balance.toString());
     }
     /**
      * Gets the balance of a specific ERC-20 token for the wallet.
@@ -91,7 +93,8 @@ class ChainService {
         if (!this.wallet.provider) {
             throw new Error('Provider not set for wallet.');
         }
-        return this.wallet.provider.estimateGas(transaction);
+        const gas = await this.wallet.provider.estimateGas(transaction);
+        return typeof gas === 'bigint' ? gas : BigInt(gas.toString());
     }
     /**
      * Sends a transaction to the blockchain.
@@ -116,6 +119,7 @@ class ChainService {
         }
         const contract = new ethers_1.ethers.Contract(tokenAddress, ERC20_ABI, this.wallet);
         const tokenInfo = await this.getTokenInfo(tokenAddress);
+        // @ts-expect-error - ethers v6 parseUnits compatibility
         const parsedAmount = ethers_1.ethers.parseUnits(amount, tokenInfo.decimals);
         // The contract instance is connected to the wallet, which will sign and send the transaction.
         return contract.transfer(to, parsedAmount);

package/dist/components/ConnectionModal.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectionModal = void 0;
+// @ts-nocheck - React Native peer dependency
 const react_1 = __importDefault(require("react"));
 const react_native_1 = require("react-native");
 const ConnectionModal = ({ visible, dAppInfo, onApprove, onReject, }) => {

package/dist/components/DAppBrowser.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DAppBrowser = void 0;
+// @ts-nocheck - React Native peer dependency
 const react_1 = __importStar(require("react"));
 const react_native_1 = require("react-native");
 // Note: react-native-webview is a peer dependency

package/dist/components/TransactionModal.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionModal = void 0;
+// @ts-nocheck - React Native peer dependency
 const react_1 = __importDefault(require("react"));
 const react_native_1 = require("react-native");
 const TransactionModal = ({ visible, transaction, onApprove, onReject, }) => {

package/dist/config/chains.js

@@ -163,6 +163,7 @@ exports.SUPPORTED_CHAINS = {
  * @returns An ethers.js JsonRpcProvider instance for the specified chain
  * @throws Error if the chain is not supported or is not an EVM chain
  */
+// @ts-expect-error - ethers v6 JsonRpcProvider compatibility
 const getProvider = (chainId) => {
     const chainInfo = exports.SUPPORTED_CHAINS[chainId];
     if (!chainInfo) {
@@ -171,6 +172,7 @@ const getProvider = (chainId) => {
     if (chainInfo.type !== 'evm') {
         throw new Error(`Chain ${chainId} is not an EVM chain`);
     }
+    // @ts-expect-error - ethers v6 JsonRpcProvider compatibility
     return new ethers_1.ethers.JsonRpcProvider(chainInfo.rpcUrl);
 };
 exports.getProvider = getProvider;

package/dist/keyrings/SolanaKeyring.d.ts

@@ -1,4 +1,12 @@
 import { Keypair } from '@solana/web3.js';
+/**
+ * Serialized keyring data structure
+ */
+export interface SerializedSolanaKeyring {
+    type: 'Solana';
+    mnemonic: string;
+    accounts: string[];
+}
 /**
  * Solana keyring for managing multiple Solana accounts
  * derived from a single mnemonic phrase using BIP-44 derivation paths.
@@ -9,12 +17,25 @@ export declare class SolanaKeyring {
     private keypairs;
     accounts: string[];
     private mnemonic;
+    private seed;
+    private static seedCache;
+    private static readonly ERROR_INVALID_MNEMONIC;
+    private static readonly ERROR_INVALID_INDEX;
+    private static readonly ERROR_DUPLICATE_ACCOUNT;
+    private static readonly ERROR_ADDRESS_NOT_FOUND;
+    private static readonly ERROR_INVALID_DESERIALIZE;
+    private static readonly ERROR_ADDRESS_MISMATCH;
     /**
      * Creates a new SolanaKeyring instance from a mnemonic phrase.
      * @param mnemonic - The mnemonic phrase (12, 15, 18, 21, or 24 words)
      * @throws Error if the mnemonic is invalid
      */
     constructor(mnemonic: string);
+    /**
+     * Gets or generates the seed for this keyring, using cache when available.
+     * @returns The seed buffer
+     */
+    private getSeed;
     /**
      * Initializes the keyring by generating the seed and creating the first account.
      * @param mnemonic - The mnemonic phrase to initialize from
@@ -23,21 +44,28 @@ export declare class SolanaKeyring {
     /**
      * Derives a Solana keypair at a specific index using BIP-44 derivation.
      * @param seed - The seed buffer to derive from
-     * @param index - The account index to derive (0-based)
+     * @param index - The account index to derive (0-based, must be non-negative integer)
      * @returns The derived Solana keypair
+     * @throws Error if index is invalid
      */
-    private deriveKeypair;
+    private static deriveKeypair;
     /**
      * Adds a new Solana account derived from the mnemonic at the next available index.
      * @returns Promise resolving to the public key address of the newly created account
      * @throws Error if account derivation fails or duplicate address is generated
      */
     addNewAccount(): Promise<string>;
+    /**
+     * Validates a Solana address format.
+     * @param address - The address to validate
+     * @returns True if the address is valid, false otherwise
+     */
+    static isValidAddress(address: string): boolean;
     /**
      * Gets the private key for a given address managed by this keyring.
      * @param address - The account's public key address to get the private key for
      * @returns Promise resolving to the private key as a hex string
-     * @throws Error if the address is not found in this keyring
+     * @throws Error if the address is not found in this keyring or is invalid
      */
     getPrivateKeyForAddress(address: string): Promise<string>;
     /**
@@ -47,9 +75,9 @@ export declare class SolanaKeyring {
     getMnemonic(): string;
     /**
      * Serializes the keyring data for encryption and storage.
-     * @returns An object containing the keyring type and mnemonic
+     * @returns An object containing the keyring type, mnemonic, and accounts
      */
-    serialize(): any;
+    serialize(): SerializedSolanaKeyring;
     /**
      * Deserializes data into a SolanaKeyring instance.
      * @param data - The serialized keyring data
@@ -61,6 +89,7 @@ export declare class SolanaKeyring {
      * Gets the Solana keypair for a given address.
      * @param address - The account's public key address
      * @returns The Solana keypair or undefined if not found
+     * @throws Error if the address format is invalid
      */
     getKeypair(address: string): Keypair | undefined;
     /**
@@ -68,4 +97,20 @@ export declare class SolanaKeyring {
      * @returns Array of all Solana keypairs
      */
     getAllKeypairs(): Keypair[];
+    /**
+     * Clears sensitive data from memory.
+     * This should be called when the keyring is no longer needed to help prevent memory dumps.
+     * Note: This does not clear the seed cache, only instance-specific data.
+     */
+    clearSensitiveData(): void;
+    /**
+     * Clears the seed cache to free up memory.
+     * Call this when you want to clear sensitive data from memory.
+     */
+    static clearSeedCache(): void;
+    /**
+     * Gets the cache size for debugging purposes.
+     * @returns Number of cached seeds
+     */
+    static getSeedCacheSize(): number;
 }

package/dist/keyrings/SolanaKeyring.js

@@ -39,6 +39,7 @@ const ed25519_hd_key_1 = require("ed25519-hd-key");
 const bip39 = __importStar(require("bip39"));
 const buffer_1 = require("buffer");
 const chains_1 = require("../config/chains");
+const EncryptionService_1 = require("../crypto/EncryptionService");
 /**
  * Solana keyring for managing multiple Solana accounts
  * derived from a single mnemonic phrase using BIP-44 derivation paths.
@@ -54,30 +55,56 @@ class SolanaKeyring {
         this.type = 'Solana';
         this.keypairs = new Map();
         this.accounts = [];
-        if (!bip39.validateMnemonic(mnemonic)) {
-            throw new Error('Invalid mnemonic');
+        this.seed = null;
+        if (!EncryptionService_1.EncryptionService.validateMnemonic(mnemonic)) {
+            throw new Error(SolanaKeyring.ERROR_INVALID_MNEMONIC);
         }
         this.mnemonic = mnemonic;
         this.initializeFromMnemonic(mnemonic);
     }
+    /**
+     * Gets or generates the seed for this keyring, using cache when available.
+     * @returns The seed buffer
+     */
+    getSeed() {
+        if (this.seed) {
+            return this.seed;
+        }
+        // Check cache first
+        if (SolanaKeyring.seedCache.has(this.mnemonic)) {
+            this.seed = SolanaKeyring.seedCache.get(this.mnemonic);
+            return this.seed;
+        }
+        // Generate and cache seed
+        this.seed = bip39.mnemonicToSeedSync(this.mnemonic);
+        SolanaKeyring.seedCache.set(this.mnemonic, this.seed);
+        return this.seed;
+    }
     /**
      * Initializes the keyring by generating the seed and creating the first account.
      * @param mnemonic - The mnemonic phrase to initialize from
      */
     initializeFromMnemonic(mnemonic) {
-        const seed = bip39.mnemonicToSeedSync(mnemonic);
-        const firstKeypair = this.deriveKeypair(seed, 0);
+        const seed = this.getSeed();
+        const firstKeypair = SolanaKeyring.deriveKeypair(seed, 0);
         this.keypairs.set(firstKeypair.publicKey.toString(), firstKeypair);
         this.accounts.push(firstKeypair.publicKey.toString());
     }
     /**
      * Derives a Solana keypair at a specific index using BIP-44 derivation.
      * @param seed - The seed buffer to derive from
-     * @param index - The account index to derive (0-based)
+     * @param index - The account index to derive (0-based, must be non-negative integer)
      * @returns The derived Solana keypair
+     * @throws Error if index is invalid
      */
-    deriveKeypair(seed, index) {
-        const path = `${chains_1.DERIVATION_PATHS.SOLANA.slice(0, -1)}${index}'`;
+    static deriveKeypair(seed, index) {
+        if (!Number.isInteger(index) || index < 0) {
+            throw new Error(SolanaKeyring.ERROR_INVALID_INDEX);
+        }
+        // Solana derivation path: m/44'/501'/0'/{index}'
+        // Need to replace the last segment (0') with the account index
+        const basePath = chains_1.DERIVATION_PATHS.SOLANA; // "m/44'/501'/0'/0'"
+        const path = basePath.replace(/\/\d+'$/, `/${index}'`);
         const derivedSeed = (0, ed25519_hd_key_1.derivePath)(path, seed.toString('hex')).key;
         return web3_js_1.Keypair.fromSeed(derivedSeed);
     }
@@ -88,25 +115,46 @@ class SolanaKeyring {
      */
     async addNewAccount() {
         const newIndex = this.accounts.length;
-        const seed = bip39.mnemonicToSeedSync(this.mnemonic);
-        const newKeypair = this.deriveKeypair(seed, newIndex);
-        if (this.accounts.includes(newKeypair.publicKey.toString())) {
-            throw new Error('Duplicate account derived. Please check derivation path logic.');
+        const seed = this.getSeed();
+        const newKeypair = SolanaKeyring.deriveKeypair(seed, newIndex);
+        const newAddress = newKeypair.publicKey.toString();
+        if (this.accounts.includes(newAddress)) {
+            throw new Error(SolanaKeyring.ERROR_DUPLICATE_ACCOUNT);
+        }
+        this.keypairs.set(newAddress, newKeypair);
+        this.accounts.push(newAddress);
+        return newAddress;
+    }
+    /**
+     * Validates a Solana address format.
+     * @param address - The address to validate
+     * @returns True if the address is valid, false otherwise
+     */
+    static isValidAddress(address) {
+        if (!address || typeof address !== 'string') {
+            return false;
+        }
+        try {
+            new web3_js_1.PublicKey(address);
+            return true;
+        }
+        catch {
+            return false;
         }
-        this.keypairs.set(newKeypair.publicKey.toString(), newKeypair);
-        this.accounts.push(newKeypair.publicKey.toString());
-        return newKeypair.publicKey.toString();
     }
     /**
      * Gets the private key for a given address managed by this keyring.
      * @param address - The account's public key address to get the private key for
      * @returns Promise resolving to the private key as a hex string
-     * @throws Error if the address is not found in this keyring
+     * @throws Error if the address is not found in this keyring or is invalid
      */
     async getPrivateKeyForAddress(address) {
+        if (!SolanaKeyring.isValidAddress(address)) {
+            throw new Error(`Invalid Solana address format: ${address}`);
+        }
         const keypair = this.keypairs.get(address);
         if (!keypair) {
-            throw new Error('Address not found in this keyring.');
+            throw new Error(SolanaKeyring.ERROR_ADDRESS_NOT_FOUND);
         }
         return buffer_1.Buffer.from(keypair.secretKey).toString('hex');
     }
@@ -119,12 +167,13 @@ class SolanaKeyring {
     }
     /**
      * Serializes the keyring data for encryption and storage.
-     * @returns An object containing the keyring type and mnemonic
+     * @returns An object containing the keyring type, mnemonic, and accounts
      */
     serialize() {
         return {
             type: this.type,
-            mnemonic: this.mnemonic
+            mnemonic: this.mnemonic,
+            accounts: [...this.accounts] // Return a copy to prevent external modification
         };
     }
     /**
@@ -135,17 +184,53 @@ class SolanaKeyring {
      */
     static async deserialize(data) {
         if (data.type !== 'Solana' || !data.mnemonic) {
-            throw new Error('Invalid data for SolanaKeyring deserialization.');
+            throw new Error(SolanaKeyring.ERROR_INVALID_DESERIALIZE);
         }
-        // Only restore mnemonic, do not restore accounts
-        return new SolanaKeyring(data.mnemonic);
+        // Validate mnemonic before creating keyring
+        if (!EncryptionService_1.EncryptionService.validateMnemonic(data.mnemonic)) {
+            throw new Error(`${SolanaKeyring.ERROR_INVALID_DESERIALIZE}: Invalid mnemonic`);
+        }
+        // Validate accounts array if present
+        if (data.accounts && !Array.isArray(data.accounts)) {
+            throw new Error(`${SolanaKeyring.ERROR_INVALID_DESERIALIZE}: Accounts must be an array`);
+        }
+        const keyring = new SolanaKeyring(data.mnemonic);
+        // If accounts were persisted, restore them. Otherwise, keep the first account from initialization.
+        if (data.accounts && data.accounts.length > 0) {
+            // Clear the first account that was created during initialization
+            keyring.accounts = [];
+            keyring.keypairs.clear();
+            // Restore all accounts by deriving keypairs for each index
+            // Use getSeed() to leverage caching
+            const seed = keyring.getSeed();
+            for (let i = 0; i < data.accounts.length; i++) {
+                const savedAddress = data.accounts[i];
+                // Validate saved address format
+                if (!SolanaKeyring.isValidAddress(savedAddress)) {
+                    throw new Error(`${SolanaKeyring.ERROR_INVALID_DESERIALIZE}: Invalid address at index ${i}: ${savedAddress}`);
+                }
+                const keypair = SolanaKeyring.deriveKeypair(seed, i);
+                const derivedAddress = keypair.publicKey.toString();
+                // Verify that the derived address matches the saved address
+                if (derivedAddress !== savedAddress) {
+                    throw new Error(`${SolanaKeyring.ERROR_ADDRESS_MISMATCH} ${i}. Expected ${savedAddress}, got ${derivedAddress}.`);
+                }
+                keyring.keypairs.set(derivedAddress, keypair);
+                keyring.accounts.push(derivedAddress);
+            }
+        }
+        return keyring;
     }
     /**
      * Gets the Solana keypair for a given address.
      * @param address - The account's public key address
      * @returns The Solana keypair or undefined if not found
+     * @throws Error if the address format is invalid
      */
     getKeypair(address) {
+        if (!SolanaKeyring.isValidAddress(address)) {
+            throw new Error(`Invalid Solana address format: ${address}`);
+        }
         return this.keypairs.get(address);
     }
     /**
@@ -155,5 +240,45 @@ class SolanaKeyring {
     getAllKeypairs() {
         return Array.from(this.keypairs.values());
     }
+    /**
+     * Clears sensitive data from memory.
+     * This should be called when the keyring is no longer needed to help prevent memory dumps.
+     * Note: This does not clear the seed cache, only instance-specific data.
+     */
+    clearSensitiveData() {
+        // Clear keypairs from memory
+        this.keypairs.forEach((keypair) => {
+            // Attempt to zero out secret key (though JavaScript doesn't guarantee this)
+            if (keypair.secretKey) {
+                keypair.secretKey.fill(0);
+            }
+        });
+        this.keypairs.clear();
+        this.seed = null;
+        // Note: We don't clear accounts array as it contains public addresses (not sensitive)
+    }
+    /**
+     * Clears the seed cache to free up memory.
+     * Call this when you want to clear sensitive data from memory.
+     */
+    static clearSeedCache() {
+        SolanaKeyring.seedCache.clear();
+    }
+    /**
+     * Gets the cache size for debugging purposes.
+     * @returns Number of cached seeds
+     */
+    static getSeedCacheSize() {
+        return SolanaKeyring.seedCache.size;
+    }
 }
 exports.SolanaKeyring = SolanaKeyring;
+// Cache to avoid recreating seed
+SolanaKeyring.seedCache = new Map();
+// Error message constants
+SolanaKeyring.ERROR_INVALID_MNEMONIC = 'Invalid mnemonic';
+SolanaKeyring.ERROR_INVALID_INDEX = 'Account index must be a non-negative integer';
+SolanaKeyring.ERROR_DUPLICATE_ACCOUNT = 'Duplicate account derived. Please check derivation path logic.';
+SolanaKeyring.ERROR_ADDRESS_NOT_FOUND = 'Address not found in this keyring.';
+SolanaKeyring.ERROR_INVALID_DESERIALIZE = 'Invalid data for SolanaKeyring deserialization.';
+SolanaKeyring.ERROR_ADDRESS_MISMATCH = 'Account address mismatch at index';

package/dist/services/BatchProcessor.js

@@ -32,6 +32,7 @@ class BatchProcessor {
                     // EVM native token transfer
                     txResult = await chainService.sendTransaction({
                         to: recipient.address,
+                        // @ts-expect-error - ethers v6 parseEther compatibility
                         value: ethers_1.ethers.parseEther(recipient.amount)
                     });
                 }

package/dist/services/MultiTransferService.js

@@ -164,6 +164,7 @@ class MultiTransferService {
         const useChainId = chainId || this.chainId;
         if (isNative) {
             balance = await (0, TokenUtils_1.getNativeBalance)(address, useChainId);
+            // @ts-expect-error - ethers v6 parseEther compatibility
             amountWei = ethers_1.ethers.parseEther(amount);
         }
         else if (tokenAddress) {
@@ -171,13 +172,16 @@ class MultiTransferService {
             // For token transfers, we need to get token decimals to parse amount correctly
             // For now, we'll use a default of 18 decimals (most common)
             // In a real implementation, you'd get this from the token contract
+            // @ts-expect-error - ethers v6 parseUnits compatibility
             amountWei = ethers_1.ethers.parseUnits(amount, 18);
         }
         else {
             throw new Error('Token address required for token balance check');
         }
         if (balance < amountWei) {
+            // @ts-expect-error - ethers v6 formatEther/formatUnits compatibility
             const balanceEth = isNative ? ethers_1.ethers.formatEther(balance) : ethers_1.ethers.formatUnits(balance, 18);
+            // @ts-expect-error - ethers v6 formatEther/formatUnits compatibility
             const amountEth = isNative ? ethers_1.ethers.formatEther(amountWei) : ethers_1.ethers.formatUnits(amountWei, 18);
             throw new Error(`Insufficient balance. Available: ${balanceEth}, Required: ${amountEth}`);
         }
@@ -202,6 +206,7 @@ class MultiTransferService {
                 // Estimate native token transfer
                 const tx = {
                     to: sampleRecipient.address,
+                    // @ts-expect-error - ethers v6 parseEther compatibility
                     value: ethers_1.ethers.parseEther(sampleRecipient.amount)
                 };
                 if (this.chainService instanceof ChainService_1.ChainService) {

package/dist/services/TokenUtils.d.ts

@@ -1,4 +1,5 @@
-import { ethers, TransactionRequest } from 'ethers';
+import { ethers } from 'ethers';
+import type { TransactionRequest } from 'ethers';
 import { ChainId } from '../config/chains';
 import { Vault } from '../Vault';
 /**

package/dist/services/TokenUtils.js

@@ -33,12 +33,14 @@ const ERC20_ABI = [
     "function allowance(address owner, address spender) view returns (uint)"
 ];
 // Provider manager: cache provider per chainId
+// @ts-expect-error - ethers v6 JsonRpcProvider compatibility
 const providerCache = {};
 /**
  * Gets or creates a cached provider for the specified chain.
  * @param chainId - The chain ID (e.g., '1' for Ethereum, '56' for BSC)
  * @returns Cached ethers provider for the chain
  */
+// @ts-expect-error - ethers v6 JsonRpcProvider compatibility
 function getProviderAuto(chainId) {
     if (!providerCache[chainId]) {
         providerCache[chainId] = (0, chains_1.getProvider)(chainId);
@@ -175,12 +177,15 @@ async function signTransactionWithVault(unsignedTx, vault, fromAddress, chainId)
  * const receipt = await approveTokenWithVault(vault, '0xOwner...', '0xToken...', '0xSpender...', '1000', '1');
  * ```
  */
-async function approveTokenWithVault(vault, fromAddress, tokenAddress, spender, amount, chainId) {
+async function approveTokenWithVault(vault, fromAddress, tokenAddress, spender, amount, chainId
+// @ts-expect-error - ethers v6 TransactionResponse compatibility
+) {
     const privateKey = await vault.getPrivateKeyFor(fromAddress);
     const provider = (0, chains_1.getProvider)(chainId);
     const wallet = new ethers_1.Wallet(privateKey, provider);
     const contract = new ethers_1.Contract(tokenAddress, ERC20_ABI, wallet);
     const decimals = await contract.decimals();
+    // @ts-expect-error - ethers v6 parseUnits compatibility
     const parsedAmount = typeof amount === 'string' ? ethers_1.ethers.parseUnits(amount, decimals) : amount;
     const tx = await contract.approve(spender, parsedAmount);
     if (typeof tx.wait === 'function') {
@@ -198,7 +203,9 @@ async function approveTokenWithVault(vault, fromAddress, tokenAddress, spender,
  * const txResponse = await sendTransaction(signedTx, '1');
  * ```
  */
-async function sendTransaction(signedTx, chainId) {
+async function sendTransaction(signedTx, chainId
+// @ts-expect-error - ethers v6 TransactionResponse compatibility
+) {
     const provider = getProviderAuto(chainId);
     return provider.broadcastTransaction(signedTx);
 }
@@ -295,6 +302,7 @@ async function signMessage(message, privateKey) {
  * ```
  */
 async function verifyMessage(message, signature) {
+    // @ts-expect-error - ethers v6 verifyMessage compatibility
     return ethers_1.ethers.verifyMessage(message, signature);
 }
 /**
@@ -323,6 +331,7 @@ async function verifyMessage(message, signature) {
 async function signTypedDataWithVault(typedData, vault, fromAddress) {
     const privateKey = await vault.getPrivateKeyFor(fromAddress);
     const wallet = new ethers_1.Wallet(privateKey);
+    // @ts-expect-error - signTypedData may not be in types but exists in runtime
     return wallet.signTypedData(typedData.domain, typedData.types, typedData.message);
 }
 /**
@@ -344,6 +353,7 @@ async function signTypedDataWithVault(typedData, vault, fromAddress) {
  */
 async function signTypedData(typedData, privateKey) {
     const wallet = new ethers_1.Wallet(privateKey);
+    // @ts-expect-error - signTypedData may not be in types but exists in runtime
     return wallet.signTypedData(typedData.domain, typedData.types, typedData.message);
 }
 /**
@@ -357,6 +367,7 @@ async function signTypedData(typedData, privateKey) {
  * ```
  */
 async function verifyTypedData(typedData, signature) {
+    // @ts-expect-error - ethers v6 verifyTypedData compatibility
     return ethers_1.ethers.verifyTypedData(typedData.domain, typedData.types, typedData.message, signature);
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pwc-sdk-wallet",
-  "version": "0.8.2",
+  "version": "0.8.4",
   "description": "A comprehensive wallet SDK for React Native (pwc), supporting multi-chain and multi-account features.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",