pwc-sdk-wallet 0.6.3

package/dist/keyrings/SolanaKeyring.d.ts

@@ -0,0 +1,71 @@
+import { Keypair } from '@solana/web3.js';
+/**
+ * Solana keyring for managing multiple Solana accounts
+ * derived from a single mnemonic phrase using BIP-44 derivation paths.
+ * Supports Solana blockchain with Ed25519 keypairs.
+ */
+export declare class SolanaKeyring {
+    readonly type = "Solana";
+    private keypairs;
+    accounts: string[];
+    private mnemonic;
+    /**
+     * 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);
+    /**
+     * Initializes the keyring by generating the seed and creating the first account.
+     * @param mnemonic - The mnemonic phrase to initialize from
+     */
+    private initializeFromMnemonic;
+    /**
+     * 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)
+     * @returns The derived Solana keypair
+     */
+    private 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>;
+    /**
+     * 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
+     */
+    getPrivateKeyForAddress(address: string): Promise<string>;
+    /**
+     * Returns the mnemonic phrase. USE WITH CAUTION - this exposes sensitive data.
+     * @returns The mnemonic phrase as a string
+     */
+    getMnemonic(): string;
+    /**
+     * Serializes the keyring data for encryption and storage.
+     * @returns An object containing the keyring type and mnemonic
+     */
+    serialize(): any;
+    /**
+     * Deserializes data into a SolanaKeyring instance.
+     * @param data - The serialized keyring data
+     * @returns Promise resolving to a new SolanaKeyring instance
+     * @throws Error if the data is invalid or missing required fields
+     */
+    static deserialize(data: any): Promise<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
+     */
+    getKeypair(address: string): Keypair | undefined;
+    /**
+     * Gets all keypairs managed by this keyring.
+     * @returns Array of all Solana keypairs
+     */
+    getAllKeypairs(): Keypair[];
+}

package/dist/keyrings/SolanaKeyring.js

@@ -0,0 +1,159 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaKeyring = void 0;
+const web3_js_1 = require("@solana/web3.js");
+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");
+/**
+ * Solana keyring for managing multiple Solana accounts
+ * derived from a single mnemonic phrase using BIP-44 derivation paths.
+ * Supports Solana blockchain with Ed25519 keypairs.
+ */
+class SolanaKeyring {
+    /**
+     * 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) {
+        this.type = 'Solana';
+        this.keypairs = new Map();
+        this.accounts = [];
+        if (!bip39.validateMnemonic(mnemonic)) {
+            throw new Error('Invalid mnemonic');
+        }
+        this.mnemonic = mnemonic;
+        this.initializeFromMnemonic(mnemonic);
+    }
+    /**
+     * 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);
+        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)
+     * @returns The derived Solana keypair
+     */
+    deriveKeypair(seed, index) {
+        const path = `${chains_1.DERIVATION_PATHS.SOLANA.slice(0, -1)}${index}'`;
+        const derivedSeed = (0, ed25519_hd_key_1.derivePath)(path, seed.toString('hex')).key;
+        return web3_js_1.Keypair.fromSeed(derivedSeed);
+    }
+    /**
+     * 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
+     */
+    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.');
+        }
+        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
+     */
+    async getPrivateKeyForAddress(address) {
+        const keypair = this.keypairs.get(address);
+        if (!keypair) {
+            throw new Error('Address not found in this keyring.');
+        }
+        return buffer_1.Buffer.from(keypair.secretKey).toString('hex');
+    }
+    /**
+     * Returns the mnemonic phrase. USE WITH CAUTION - this exposes sensitive data.
+     * @returns The mnemonic phrase as a string
+     */
+    getMnemonic() {
+        return this.mnemonic;
+    }
+    /**
+     * Serializes the keyring data for encryption and storage.
+     * @returns An object containing the keyring type and mnemonic
+     */
+    serialize() {
+        return {
+            type: this.type,
+            mnemonic: this.mnemonic
+        };
+    }
+    /**
+     * Deserializes data into a SolanaKeyring instance.
+     * @param data - The serialized keyring data
+     * @returns Promise resolving to a new SolanaKeyring instance
+     * @throws Error if the data is invalid or missing required fields
+     */
+    static async deserialize(data) {
+        if (data.type !== 'Solana' || !data.mnemonic) {
+            throw new Error('Invalid data for SolanaKeyring deserialization.');
+        }
+        // Chỉ khôi phục mnemonic, không khôi phục lại accounts
+        return new SolanaKeyring(data.mnemonic);
+    }
+    /**
+     * 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
+     */
+    getKeypair(address) {
+        return this.keypairs.get(address);
+    }
+    /**
+     * Gets all keypairs managed by this keyring.
+     * @returns Array of all Solana keypairs
+     */
+    getAllKeypairs() {
+        return Array.from(this.keypairs.values());
+    }
+}
+exports.SolanaKeyring = SolanaKeyring;

package/dist/services/BatchProcessor.d.ts

@@ -0,0 +1,42 @@
+import { ChainService } from '../chain/ChainService';
+import { SolanaChainService } from '../chain/SolanaChainService';
+import { Recipient, BatchResult } from '../types/multiTransfer';
+/**
+ * Handles batch processing of transfers for both native tokens and ERC-20/SPL tokens.
+ * Processes transfers in batches to optimize gas usage and provide progress tracking.
+ */
+export declare class BatchProcessor {
+    /**
+     * Processes a batch of native token transfers.
+     * @param chainService - The chain service instance (EVM or Solana)
+     * @param recipients - Array of recipients to transfer to
+     * @param onProgress - Optional progress callback
+     * @returns Promise resolving to batch processing results
+     */
+    static processNativeTokenBatch(chainService: ChainService | SolanaChainService, recipients: Recipient[], onProgress?: (completed: number, total: number, txHash: string) => void): Promise<BatchResult>;
+    /**
+     * Processes a batch of ERC-20/SPL token transfers.
+     * @param chainService - The chain service instance (EVM or Solana)
+     * @param tokenAddress - The token contract address
+     * @param recipients - Array of recipients to transfer to
+     * @param onProgress - Optional progress callback
+     * @returns Promise resolving to batch processing results
+     */
+    static processTokenBatch(chainService: ChainService | SolanaChainService, tokenAddress: string, recipients: Recipient[], onProgress?: (completed: number, total: number, txHash: string) => void): Promise<BatchResult>;
+    /**
+     * Splits recipients into batches of specified size.
+     * @param recipients - Array of all recipients
+     * @param batchSize - Size of each batch
+     * @returns Array of recipient batches
+     */
+    static splitIntoBatches(recipients: Recipient[], batchSize: number): Recipient[][];
+    /**
+     * Validates recipient addresses and amounts.
+     * @param recipients - Array of recipients to validate
+     * @returns Validation result
+     */
+    static validateRecipients(recipients: Recipient[]): {
+        isValid: boolean;
+        errors: string[];
+    };
+}

package/dist/services/BatchProcessor.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchProcessor = void 0;
+const ChainService_1 = require("../chain/ChainService");
+const SolanaChainService_1 = require("../chain/SolanaChainService");
+const ethers_1 = require("ethers");
+/**
+ * Handles batch processing of transfers for both native tokens and ERC-20/SPL tokens.
+ * Processes transfers in batches to optimize gas usage and provide progress tracking.
+ */
+class BatchProcessor {
+    /**
+     * Processes a batch of native token transfers.
+     * @param chainService - The chain service instance (EVM or Solana)
+     * @param recipients - Array of recipients to transfer to
+     * @param onProgress - Optional progress callback
+     * @returns Promise resolving to batch processing results
+     */
+    static async processNativeTokenBatch(chainService, recipients, onProgress) {
+        const transactions = [];
+        const failed = [];
+        let totalGasUsed = BigInt(0);
+        for (let i = 0; i < recipients.length; i++) {
+            const recipient = recipients[i];
+            try {
+                let txResult;
+                if (chainService instanceof SolanaChainService_1.SolanaChainService) {
+                    // Solana native token transfer
+                    txResult = await chainService.sendTransaction(recipient.address, recipient.amount);
+                }
+                else {
+                    // EVM native token transfer
+                    txResult = await chainService.sendTransaction({
+                        to: recipient.address,
+                        value: ethers_1.ethers.parseEther(recipient.amount)
+                    });
+                }
+                transactions.push(txResult);
+                // Update gas used (only for EVM chains that support it)
+                if (chainService instanceof ChainService_1.ChainService && txResult && typeof txResult === 'object' && 'gasUsed' in txResult) {
+                    const gasUsed = txResult.gasUsed;
+                    if (gasUsed && typeof gasUsed === 'bigint') {
+                        totalGasUsed += gasUsed;
+                    }
+                }
+                // Progress callback
+                if (onProgress) {
+                    onProgress(i + 1, recipients.length, txResult.hash);
+                }
+                // Small delay to prevent rate limiting
+                if (i < recipients.length - 1) {
+                    await new Promise(resolve => setTimeout(resolve, 100));
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                failed.push({
+                    recipient,
+                    error: new Error(`Failed to transfer to ${recipient.address}: ${errorMessage}`)
+                });
+                // Still call progress callback for failed transfers
+                if (onProgress) {
+                    onProgress(i + 1, recipients.length, 'FAILED');
+                }
+            }
+        }
+        return {
+            transactions,
+            failed,
+            gasUsed: totalGasUsed
+        };
+    }
+    /**
+     * Processes a batch of ERC-20/SPL token transfers.
+     * @param chainService - The chain service instance (EVM or Solana)
+     * @param tokenAddress - The token contract address
+     * @param recipients - Array of recipients to transfer to
+     * @param onProgress - Optional progress callback
+     * @returns Promise resolving to batch processing results
+     */
+    static async processTokenBatch(chainService, tokenAddress, recipients, onProgress) {
+        const transactions = [];
+        const failed = [];
+        let totalGasUsed = BigInt(0);
+        for (let i = 0; i < recipients.length; i++) {
+            const recipient = recipients[i];
+            try {
+                let txResult;
+                if (chainService instanceof SolanaChainService_1.SolanaChainService) {
+                    // Solana SPL token transfer
+                    txResult = await chainService.sendToken(tokenAddress, recipient.address, recipient.amount);
+                }
+                else {
+                    // EVM ERC-20 token transfer
+                    txResult = await chainService.sendToken(tokenAddress, recipient.address, recipient.amount);
+                }
+                transactions.push(txResult);
+                // Update gas used (only for EVM chains that support it)
+                if (chainService instanceof ChainService_1.ChainService && txResult && typeof txResult === 'object' && 'gasUsed' in txResult) {
+                    const gasUsed = txResult.gasUsed;
+                    if (gasUsed && typeof gasUsed === 'bigint') {
+                        totalGasUsed += gasUsed;
+                    }
+                }
+                // Progress callback
+                if (onProgress) {
+                    onProgress(i + 1, recipients.length, txResult.hash);
+                }
+                // Small delay to prevent rate limiting
+                if (i < recipients.length - 1) {
+                    await new Promise(resolve => setTimeout(resolve, 100));
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                failed.push({
+                    recipient,
+                    error: new Error(`Failed to transfer token to ${recipient.address}: ${errorMessage}`)
+                });
+                // Still call progress callback for failed transfers
+                if (onProgress) {
+                    onProgress(i + 1, recipients.length, 'FAILED');
+                }
+            }
+        }
+        return {
+            transactions,
+            failed,
+            gasUsed: totalGasUsed
+        };
+    }
+    /**
+     * Splits recipients into batches of specified size.
+     * @param recipients - Array of all recipients
+     * @param batchSize - Size of each batch
+     * @returns Array of recipient batches
+     */
+    static splitIntoBatches(recipients, batchSize) {
+        const batches = [];
+        for (let i = 0; i < recipients.length; i += batchSize) {
+            batches.push(recipients.slice(i, i + batchSize));
+        }
+        return batches;
+    }
+    /**
+     * Validates recipient addresses and amounts.
+     * @param recipients - Array of recipients to validate
+     * @returns Validation result
+     */
+    static validateRecipients(recipients) {
+        const errors = [];
+        if (!recipients || recipients.length === 0) {
+            errors.push('No recipients provided');
+            return { isValid: false, errors };
+        }
+        if (recipients.length > 100) {
+            errors.push('Maximum 100 recipients allowed per operation');
+        }
+        const addresses = new Set();
+        recipients.forEach((recipient, index) => {
+            // Validate address
+            if (!recipient.address || recipient.address.trim() === '') {
+                errors.push(`Recipient ${index + 1}: Invalid address`);
+            }
+            else if (addresses.has(recipient.address.toLowerCase())) {
+                errors.push(`Recipient ${index + 1}: Duplicate address ${recipient.address}`);
+            }
+            else {
+                addresses.add(recipient.address.toLowerCase());
+            }
+            // Validate amount
+            if (!recipient.amount || recipient.amount.trim() === '') {
+                errors.push(`Recipient ${index + 1}: Invalid amount`);
+            }
+            else {
+                const amount = parseFloat(recipient.amount);
+                if (isNaN(amount) || amount <= 0) {
+                    errors.push(`Recipient ${index + 1}: Amount must be a positive number`);
+                }
+            }
+        });
+        return {
+            isValid: errors.length === 0,
+            errors
+        };
+    }
+}
+exports.BatchProcessor = BatchProcessor;

package/dist/services/MultiTransferService.d.ts

@@ -0,0 +1,78 @@
+import { Vault } from '../Vault';
+import { ChainService } from '../chain/ChainService';
+import { SolanaChainService } from '../chain/SolanaChainService';
+import { Recipient, MultiTransferOptions, MultiTransferResult } from '../types/multiTransfer';
+import { ChainId } from '../config/chains';
+/**
+ * Service for handling multi-transfer operations across different blockchain networks.
+ * Supports both native tokens and ERC-20/SPL tokens with batch processing and progress tracking.
+ */
+export declare class MultiTransferService {
+    private vault;
+    private chainService;
+    private chainId;
+    /**
+     * Creates a new MultiTransferService instance.
+     * @param vault - The vault instance containing the accounts
+     * @param chainService - The chain service for the target blockchain
+     * @param chainId - The chain ID for all operations
+     */
+    constructor(vault: Vault, chainService: ChainService | SolanaChainService, chainId: ChainId);
+    /**
+     * Transfers native tokens to multiple recipients.
+     * @param fromAddress - The sender's address
+     * @param recipients - Array of recipients with addresses and amounts
+     * @param chainId - The chain ID for the transfer
+     * @param options - Optional configuration for the transfer operation
+     * @returns Promise resolving to the multi-transfer result
+     * @throws Error if validation fails or insufficient balance
+     */
+    transferNativeTokens(fromAddress: string, recipients: Recipient[], chainId: ChainId, options?: MultiTransferOptions): Promise<MultiTransferResult>;
+    /**
+     * Transfers ERC-20/SPL tokens to multiple recipients.
+     * @param fromAddress - The sender's address
+     * @param tokenAddress - The token contract address
+     * @param recipients - Array of recipients with addresses and amounts
+     * @param chainId - The chain ID for the transfer
+     * @param options - Optional configuration for the transfer operation
+     * @returns Promise resolving to the multi-transfer result
+     * @throws Error if validation fails or insufficient balance
+     */
+    transferTokens(fromAddress: string, tokenAddress: string, recipients: Recipient[], chainId: ChainId, options?: MultiTransferOptions): Promise<MultiTransferResult>;
+    /**
+     * Validates transfer inputs including recipients and amounts.
+     * @param fromAddress - The sender's address
+     * @param recipients - Array of recipients to validate
+     * @param options - Transfer options
+     * @returns Validation result with errors and total amount
+     */
+    private validateTransferInputs;
+    /**
+     * Checks if the account has sufficient balance for the transfer.
+     * @param address - The account address to check
+     * @param amount - The amount to transfer
+     * @param isNative - Whether checking native token balance
+     * @param tokenAddress - Token address (for non-native tokens)
+     * @param chainId - The chain ID for the check
+     * @throws Error if insufficient balance
+     */
+    private checkBalance;
+    /**
+     * Estimates gas cost for a multi-transfer operation.
+     * @param recipients - Array of recipients to estimate gas for
+     * @param chainId - The chain ID for the estimation
+     * @param isNative - Whether estimating for native tokens (default: true)
+     * @param tokenAddress - Token contract address (required for non-native tokens)
+     * @returns Promise resolving to estimated gas cost in wei
+     */
+    estimateGasCost(recipients: Recipient[], chainId: ChainId, isNative?: boolean, tokenAddress?: string): Promise<bigint>;
+    /**
+     * Factory method: Create MultiTransferService from vault, fromAddress, and chainId.
+     * Handles private key and chainService creation internally for simplicity.
+     * @param vault - The vault instance
+     * @param fromAddress - The sender's address
+     * @param chainId - The chain ID
+     * @returns Promise resolving to a MultiTransferService instance
+     */
+    static fromVault(vault: Vault, fromAddress: string, chainId: ChainId): Promise<MultiTransferService>;
+}