@deserialize/multi-vm-wallet 1.4.12 → 1.5.0

package/dist/svm/svm.js

@@ -8,9 +8,11 @@ const web3_js_1 = require("@solana/web3.js");
 const walletBip32_1 = require("../walletBip32");
 const vm_1 = require("../vm");
 const IChainWallet_1 = require("../IChainWallet");
+const vm_validation_1 = require("../vm-validation");
 const utils_1 = require("./utils");
 const bn_js_1 = __importDefault(require("bn.js"));
 const tweetnacl_1 = __importDefault(require("tweetnacl"));
+const bs58_1 = __importDefault(require("bs58"));
 const price_1 = require("../price");
 const transactionParsing_1 = require("./transactionParsing");
 class SVMVM extends vm_1.VM {
@@ -25,7 +27,7 @@ class SVMVM extends vm_1.VM {
             return false;
         }
     }
-    derivationPath = "m/44'/501'/"; // Default SVM derivation path
+    derivationPath = "m/44'/501'/";
     constructor(seed) {
         super(seed, "SVM");
     }
@@ -46,45 +48,286 @@ class SVMVM extends vm_1.VM {
         return web3_js_1.Keypair.fromSeed(Buffer.from(entropy));
     };
     generatePrivateKey(index, seed, mnemonic, derivationPath = this.derivationPath) {
+        vm_validation_1.VMValidation.validateIndex(index, 'Wallet index');
+        vm_validation_1.VMValidation.validateDerivationPath(derivationPath + index + "'", 'SVM');
         let _seed;
         if (seed) {
+            vm_validation_1.VMValidation.validateSeed(seed);
             _seed = seed;
         }
         else if (mnemonic) {
+            vm_validation_1.VMValidation.validateMnemonic(mnemonic);
             _seed = vm_1.VM.mnemonicToSeed(mnemonic);
         }
         else {
+            this.checkNotDisposed();
             _seed = this.seed;
         }
         const privateKey = (0, walletBip32_1.SVMDeriveChildPrivateKey)(_seed, index, derivationPath);
         return { privateKey, index };
     }
-    /**
-     * Derive a savings account using BIP-44 account index
-     *
-     * Uses the pattern: m/44'/501'/accountIndex'/0/0
-     * - Main wallet: m/44'/501'/0'/0/0 (account index 0)
-     * - Savings 1: m/44'/501'/1'/0/0 (account index 1)
-     * - Savings 2: m/44'/501'/2'/0/0 (account index 2)
-     *
-     * @param accountIndex - The BIP-44 account index (0 for main, 1+ for savings)
-     * @returns Object containing privateKey (Keypair), address (PublicKey), and derivation path
-     */
+    static fromMnemonic(mnemonic) {
+        const seed = vm_1.VM.mnemonicToSeed(mnemonic);
+        return new SVMVM(seed);
+    }
     deriveSavingsAccount(accountIndex) {
-        // Use fixed address index 0 for savings accounts
-        // Vary only the account index (3rd position in BIP-44)
-        const derivationPath = `m/44'/501'/${accountIndex}'/0/0`;
-        // Derive the keypair using the account index in the path
-        const keypair = (0, walletBip32_1.SVMDeriveChildPrivateKey)(this.seed, 0, `m/44'/501'/${accountIndex}'/0/`);
+        const derivationPath = `m/44'/501'/${accountIndex}'/0'`;
+        const keypair = (0, walletBip32_1.SVMDeriveChildPrivateKey)(this.seed, 0, `m/44'/501'/${accountIndex}'/`);
         return {
             privateKey: keypair,
             address: keypair.publicKey,
             derivationPath
         };
     }
-    static fromMnemonic(mnemonic) {
-        const seed = vm_1.VM.mnemonicToSeed(mnemonic);
-        return new SVMVM(seed);
+    async discoverWallets(connection, options) {
+        const startTime = Date.now();
+        const { startIndex = 0, maxIndex = 100, gapLimit = 20, minBalance = BigInt(0), includeZeroBalance = false, includePrivateKeys = false, checkInParallel = true, batchSize = 10, checkDelay = checkInParallel ? 200 : 50, onProgress, onDiscovered } = options || {};
+        const discovered = [];
+        let consecutiveEmpty = 0;
+        let scannedIndices = 0;
+        let stoppedByGapLimit = false;
+        if (checkInParallel) {
+            for (let i = startIndex; i <= maxIndex; i += batchSize) {
+                const batchEnd = Math.min(i + batchSize, maxIndex + 1);
+                const batchPromises = [];
+                for (let j = i; j < batchEnd; j++) {
+                    batchPromises.push(this.checkWalletBalance(j, connection));
+                }
+                const batchResults = await Promise.all(batchPromises);
+                for (let k = 0; k < batchResults.length; k++) {
+                    const index = i + k;
+                    const wallet = batchResults[k];
+                    scannedIndices++;
+                    if (wallet) {
+                        const hasBalance = wallet.nativeBalance.amount > minBalance;
+                        if (hasBalance || includeZeroBalance) {
+                            if (!includePrivateKeys) {
+                                delete wallet.privateKey;
+                            }
+                            discovered.push(wallet);
+                            consecutiveEmpty = 0;
+                            onDiscovered?.(wallet);
+                        }
+                        else {
+                            consecutiveEmpty++;
+                        }
+                    }
+                    else {
+                        consecutiveEmpty++;
+                    }
+                    onProgress?.(scannedIndices, maxIndex - startIndex + 1, discovered.length);
+                    if (consecutiveEmpty >= gapLimit) {
+                        stoppedByGapLimit = true;
+                        break;
+                    }
+                }
+                if (stoppedByGapLimit) {
+                    break;
+                }
+                if (batchEnd <= maxIndex) {
+                    await this.sleep(checkDelay);
+                }
+            }
+        }
+        else {
+            for (let i = startIndex; i <= maxIndex; i++) {
+                const wallet = await this.checkWalletBalance(i, connection);
+                scannedIndices++;
+                if (wallet) {
+                    const hasBalance = wallet.nativeBalance.amount > minBalance;
+                    if (hasBalance || includeZeroBalance) {
+                        if (!includePrivateKeys) {
+                            delete wallet.privateKey;
+                        }
+                        discovered.push(wallet);
+                        consecutiveEmpty = 0;
+                        onDiscovered?.(wallet);
+                    }
+                    else {
+                        consecutiveEmpty++;
+                    }
+                }
+                else {
+                    consecutiveEmpty++;
+                }
+                onProgress?.(scannedIndices, maxIndex - startIndex + 1, discovered.length);
+                if (consecutiveEmpty >= gapLimit) {
+                    stoppedByGapLimit = true;
+                    break;
+                }
+                if (i < maxIndex) {
+                    await this.sleep(checkDelay);
+                }
+            }
+        }
+        const totalBalance = discovered.reduce((sum, wallet) => sum + wallet.nativeBalance.amount, BigInt(0));
+        const duration = Date.now() - startTime;
+        return {
+            discovered,
+            scannedIndices,
+            highestIndex: startIndex + scannedIndices - 1,
+            totalBalance,
+            stoppedByGapLimit,
+            duration
+        };
+    }
+    async checkWalletBalance(index, connection, maxRetries = 3) {
+        const derivationPath = `m/44'/501'/${index}'/0'`;
+        const keypair = (0, walletBip32_1.SVMDeriveChildPrivateKey)(this.seed, 0, `m/44'/501'/${index}'/`);
+        const address = keypair.publicKey;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                const balanceLamports = await connection.getBalance(address);
+                const balanceSOL = balanceLamports / 1_000_000_000;
+                return {
+                    index,
+                    address: address.toString(),
+                    derivationPath,
+                    nativeBalance: {
+                        amount: BigInt(balanceLamports),
+                        formatted: balanceSOL,
+                        symbol: 'SOL'
+                    },
+                    privateKey: bs58_1.default.encode(keypair.secretKey)
+                };
+            }
+            catch (error) {
+                if (attempt === maxRetries - 1) {
+                    console.error(`Failed to check balance for index ${index} after ${maxRetries} attempts:`, error);
+                    return null;
+                }
+                const backoffMs = 1000 * Math.pow(2, attempt);
+                await this.sleep(backoffMs);
+            }
+        }
+        return null;
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    async discoverPockets(connection, options) {
+        const startTime = Date.now();
+        const { startIndex = 0, maxIndex = 100, gapLimit = 20, minBalance = BigInt(0), includeZeroBalance = false, includePrivateKeys = false, checkInParallel = true, batchSize = 10, checkDelay = checkInParallel ? 200 : 50, onProgress, onDiscovered, walletIndex = 0, } = options || {};
+        const discovered = [];
+        let consecutiveEmpty = 0;
+        let scannedIndices = 0;
+        let stoppedByGapLimit = false;
+        if (checkInParallel) {
+            for (let i = startIndex; i <= maxIndex; i += batchSize) {
+                const batchEnd = Math.min(i + batchSize, maxIndex + 1);
+                const batchPromises = [];
+                for (let j = i; j < batchEnd; j++) {
+                    batchPromises.push(this.checkPocketBalance(j, walletIndex, connection));
+                }
+                const batchResults = await Promise.all(batchPromises);
+                for (let k = 0; k < batchResults.length; k++) {
+                    const index = i + k;
+                    const pocket = batchResults[k];
+                    scannedIndices++;
+                    if (pocket) {
+                        const hasBalance = pocket.nativeBalance.amount > minBalance;
+                        if (hasBalance || includeZeroBalance) {
+                            if (!includePrivateKeys) {
+                                delete pocket.privateKey;
+                            }
+                            discovered.push(pocket);
+                            consecutiveEmpty = 0;
+                            onDiscovered?.(pocket);
+                        }
+                        else {
+                            consecutiveEmpty++;
+                        }
+                    }
+                    else {
+                        consecutiveEmpty++;
+                    }
+                    onProgress?.(scannedIndices, maxIndex - startIndex + 1, discovered.length);
+                    if (consecutiveEmpty >= gapLimit) {
+                        stoppedByGapLimit = true;
+                        break;
+                    }
+                }
+                if (stoppedByGapLimit) {
+                    break;
+                }
+                if (batchEnd <= maxIndex) {
+                    await this.sleep(checkDelay);
+                }
+            }
+        }
+        else {
+            for (let i = startIndex; i <= maxIndex; i++) {
+                const pocket = await this.checkPocketBalance(i, walletIndex, connection);
+                scannedIndices++;
+                if (pocket) {
+                    const hasBalance = pocket.nativeBalance.amount > minBalance;
+                    if (hasBalance || includeZeroBalance) {
+                        if (!includePrivateKeys) {
+                            delete pocket.privateKey;
+                        }
+                        discovered.push(pocket);
+                        consecutiveEmpty = 0;
+                        onDiscovered?.(pocket);
+                    }
+                    else {
+                        consecutiveEmpty++;
+                    }
+                }
+                else {
+                    consecutiveEmpty++;
+                }
+                onProgress?.(scannedIndices, maxIndex - startIndex + 1, discovered.length);
+                if (consecutiveEmpty >= gapLimit) {
+                    stoppedByGapLimit = true;
+                    break;
+                }
+                if (i < maxIndex) {
+                    await this.sleep(checkDelay);
+                }
+            }
+        }
+        const totalBalance = discovered.reduce((sum, pocket) => sum + pocket.nativeBalance.amount, BigInt(0));
+        const duration = Date.now() - startTime;
+        return {
+            discovered,
+            scannedIndices,
+            highestIndex: startIndex + scannedIndices - 1,
+            totalBalance,
+            stoppedByGapLimit,
+            duration
+        };
+    }
+    async checkPocketBalance(accountIndex, walletIndex, connection, maxRetries = 3) {
+        const pocketIndex = accountIndex + 1;
+        const derivationPath = `m/44'/501'/${pocketIndex}'/0'`;
+        const keypair = (0, walletBip32_1.SVMDeriveChildPrivateKey)(this.seed, 0, `m/44'/501'/${pocketIndex}'/`);
+        const address = keypair.publicKey;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                const balanceLamports = await connection.getBalance(address);
+                const balanceSOL = balanceLamports / 1_000_000_000;
+                return {
+                    index: accountIndex,
+                    address: address.toString(),
+                    derivationPath,
+                    nativeBalance: {
+                        amount: BigInt(balanceLamports),
+                        formatted: balanceSOL,
+                        symbol: 'SOL'
+                    },
+                    privateKey: bs58_1.default.encode(keypair.secretKey)
+                };
+            }
+            catch (error) {
+                if (attempt === maxRetries - 1) {
+                    console.error(`Failed to check pocket at account ${accountIndex} after ${maxRetries} attempts:`, error);
+                    return null;
+                }
+                const backoffMs = 1000 * Math.pow(2, attempt);
+                await this.sleep(backoffMs);
+            }
+        }
+        return null;
     }
 }
 exports.SVMVM = SVMVM;
@@ -102,31 +345,25 @@ class SVMChainWallet extends IChainWallet_1.ChainWallet {
         return web3_js_1.Keypair.fromSeed(Buffer.from(entropy));
     };
     async getNativeBalance() {
-        // Implement native balance retrieval logic here
         return await SVMVM.getNativeBalance(this.address, this.connection);
     }
     async getTokenBalance(tokenAddress) {
-        // Implement token balance retrieval logic here
         return await SVMVM.getTokenBalance(this.address, (tokenAddress), this.connection);
     }
     async discoverToken() {
-        // Implement token discovery logic here
         const tokens = await (0, utils_1.discoverTokens)(this.address, this.connection);
         return tokens;
     }
     async discoverNFT() {
-        // Implement NFT discovery logic here
         const nfts = await (0, utils_1.fetchWalletNfts)(this.address, this.connection);
         return nfts;
     }
     async transferNative(to, amount) {
-        // Implement native transfer logic here
         const transaction = await (0, utils_1.getTransferNativeTransaction)(this.privateKey, to, amount, this.connection);
         const hash = await SVMVM.signAndSendTransaction(transaction, this.connection, this.privateKey);
         return { success: true, hash };
     }
     async transferToken(token, to, amount) {
-        // Implement token transfer logic here
         const transaction = await (0, utils_1.getTransferTokenTransaction)(this.privateKey, new web3_js_1.PublicKey(to), token, amount, this.connection);
         const hash = await SVMVM.signAndSendTransaction(transaction, this.connection, this.privateKey);
         return { success: true, hash };
@@ -176,26 +413,7 @@ class SVMChainWallet extends IChainWallet_1.ChainWallet {
             }
             const fromTokenMint = new web3_js_1.PublicKey(fromToken.address);
             const toTokenMint = toToken;
-            // const validation = await validateJupiterTokens(
-            //     fromTokenMint.toString(),
-            //     toTokenMint.toString()
-            // );
-            // if (!validation.valid) {
-            //     return {
-            //         success: false,
-            //         hash: "",
-            //         error: validation.message || "Token validation failed"
-            //     };
-            // }
             const baseAmount = (0, utils_1.uiAmountToBaseUnits)(amount, fromToken.decimals);
-            // const balance = await this.getTokenBalance(fromTokenMint);
-            // if (balance.balance.lt(new BN(baseAmount))) {
-            //     return {
-            //         success: false,
-            //         hash: "",
-            //         error: "Insufficient balance for swap"
-            //     };
-            // }
             const swapResult = await (0, utils_1.executeJupiterSwap)({
                 fromToken: fromTokenMint,
                 toToken: toTokenMint,
@@ -251,4 +469,3 @@ class SVMChainWallet extends IChainWallet_1.ChainWallet {
     };
 }
 exports.SVMChainWallet = SVMChainWallet;
-//# sourceMappingURL=svm.js.map

package/dist/svm/transactionParsing.d.ts

@@ -18,11 +18,4 @@ export interface TransactionHistoryOptions {
     before?: string;
     until?: string;
 }
-/**
- * Fetches and parses transaction history for a Solana wallet address
- * @param connection - Solana RPC connection
- * @param walletAddress - Public key of the wallet (string or PublicKey)
- * @param options - Optional parameters for pagination and filtering
- * @returns Array of parsed transaction history items
- */
 export declare function getSVMTransactionHistory(connection: Connection, walletAddress: PublicKey, options?: TransactionHistoryOptions): Promise<SVMTransactionHistoryItem[]>;

package/dist/svm/transactionParsing.js

@@ -3,36 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSVMTransactionHistory = getSVMTransactionHistory;
 const web3_js_1 = require("@solana/web3.js");
 const constant_1 = require("../constant");
-/**
- * Fetches and parses transaction history for a Solana wallet address
- * @param connection - Solana RPC connection
- * @param walletAddress - Public key of the wallet (string or PublicKey)
- * @param options - Optional parameters for pagination and filtering
- * @returns Array of parsed transaction history items
- */
 async function getSVMTransactionHistory(connection, walletAddress, options = {}) {
     const { limit = 50, before, until } = options;
     const publicKey = typeof walletAddress === 'string'
         ? new web3_js_1.PublicKey(walletAddress)
         : walletAddress;
     try {
-        // Fetch signature info
         const signatures = await connection.getSignaturesForAddress(publicKey, {
             limit,
             before,
             until,
         });
         console.log(`Found ${signatures.length} transactions`);
-        // Fetch and parse transactions in batches to avoid rate limits
-        const transactions = await fetchTransactionsInBatches(connection, signatures, 5 // batch size
-        );
-        // Parse transactions into a user-friendly format
+        const transactions = await fetchTransactionsInBatches(connection, signatures, 5);
         const history = [];
         for (let i = 0; i < transactions.length; i++) {
             const tx = transactions[i];
             const sigInfo = signatures[i];
             if (!tx) {
-                // Transaction might be null if it's not available
                 history.push({
                     hash: sigInfo.signature,
                     timestamp: sigInfo.blockTime,
@@ -63,9 +51,6 @@ async function getSVMTransactionHistory(connection, walletAddress, options = {})
         throw error;
     }
 }
-/**
- * Fetches transactions in batches to avoid overwhelming the RPC
- */
 async function fetchTransactionsInBatches(connection, signatures, batchSize) {
     const transactions = [];
     for (let i = 0; i < signatures.length; i += batchSize) {
@@ -75,23 +60,16 @@ async function fetchTransactionsInBatches(connection, signatures, batchSize) {
         }));
         const batchResults = await Promise.all(batchPromises);
         transactions.push(...batchResults);
-        // Small delay to avoid rate limiting
         if (i + batchSize < signatures.length) {
             await new Promise(resolve => setTimeout(resolve, 100));
         }
     }
     return transactions;
 }
-/**
- * Parses a transaction into a simplified format
- */
 function parseTransaction(tx, walletAddress) {
     const fee = tx.meta?.fee || 0;
-    // Try to determine transaction type and extract relevant info
     const instructions = tx.transaction.message.instructions;
-    // Check for token transfers
     if (tx.meta?.preTokenBalances && tx.meta?.postTokenBalances) {
-        // console.log('tx.meta: ', tx.meta);
         const tokenTransfer = findTokenTransfer(tx.meta.preTokenBalances, tx.meta.postTokenBalances, walletAddress);
         if (tokenTransfer) {
             return {
@@ -104,7 +82,6 @@ function parseTransaction(tx, walletAddress) {
             };
         }
     }
-    // Check for SOL transfers
     if (tx.meta?.preBalances && tx.meta?.postBalances) {
         const solTransfer = findSolTransfer(tx.meta.preBalances, tx.meta.postBalances, tx.transaction.message.accountKeys, walletAddress);
         if (solTransfer) {
@@ -118,9 +95,7 @@ function parseTransaction(tx, walletAddress) {
             };
         }
     }
-    // Check for memo
     const memo = extractMemo(instructions);
-    // Determine general type based on instructions
     const type = determineTransactionType(instructions);
     return {
         fee,
@@ -128,9 +103,6 @@ function parseTransaction(tx, walletAddress) {
         memo,
     };
 }
-/**
- * Finds token transfers in the transaction
- */
 function findTokenTransfer(preBalances, postBalances, walletAddress) {
     for (let i = 0; i < postBalances.length; i++) {
         const post = postBalances[i];
@@ -158,27 +130,21 @@ function findTokenTransfer(preBalances, postBalances, walletAddress) {
     }
     return null;
 }
-/**
- * Finds SOL transfers in the transaction
- */
 function findSolTransfer(preBalances, postBalances, accountKeys, walletAddress) {
     for (let i = 0; i < preBalances.length; i++) {
         const diff = postBalances[i] - preBalances[i];
         const account = accountKeys[i];
         const accountPubkey = typeof account === 'string' ? account : account.pubkey.toBase58();
-        if (Math.abs(diff) > 5000 && accountPubkey === walletAddress) { // Ignore fee-only changes
+        if (Math.abs(diff) > 5000 && accountPubkey === walletAddress) {
             return {
                 from: diff < 0 ? accountPubkey : 'unknown',
                 to: diff > 0 ? accountPubkey : 'unknown',
-                amount: Math.abs(diff) / 1e9, // Convert lamports to SOL
+                amount: Math.abs(diff) / 1e9,
             };
         }
     }
     return null;
 }
-/**
- * Extracts memo from transaction instructions
- */
 function extractMemo(instructions) {
     for (const instruction of instructions) {
         if (instruction.program === 'spl-memo' || instruction.programId?.toBase58() === 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr') {
@@ -187,9 +153,6 @@ function extractMemo(instructions) {
     }
     return undefined;
 }
-/**
- * Determines the general type of transaction
- */
 function determineTransactionType(instructions) {
     if (instructions.length === 0)
         return constant_1.TRANSACTION_TYPE.UNKNOWN;
@@ -204,4 +167,3 @@ function determineTransactionType(instructions) {
         return constant_1.TRANSACTION_TYPE.STAKING;
     return constant_1.TRANSACTION_TYPE.PROGRAM_INTERACTION;
 }
-//# sourceMappingURL=transactionParsing.js.map

package/dist/svm/transactionSender.js

@@ -31,8 +31,6 @@ async function transactionSenderAndConfirmationWaiter({ connection, serializedTr
     try {
         abortableResender();
         const lastValidBlockHeight = blockhashWithExpiryBlockHeight.lastValidBlockHeight - 150;
-        // this would throw TransactionExpiredBlockheightExceededError
-        // console.log("conforming the transaction ....")
         const res = await Promise.race([
             connection.confirmTransaction({
                 ...blockhashWithExpiryBlockHeight,
@@ -41,7 +39,6 @@ async function transactionSenderAndConfirmationWaiter({ connection, serializedTr
                 abortSignal,
             }, "confirmed"),
             new Promise(async (resolve) => {
-                // in case ws socket died
                 while (!abortSignal.aborted) {
                     await wait(2_000);
                     const tx = await connection.getSignatureStatus(txid, {
@@ -56,20 +53,15 @@ async function transactionSenderAndConfirmationWaiter({ connection, serializedTr
         console.log('res: ', res);
     }
     catch (e) {
-        // console.log('e: ', e);
         if (e instanceof web3_js_1.TransactionExpiredBlockheightExceededError) {
-            // we consume this error and getTransaction would return null
-            // return null;
         }
         else {
-            // invalid state from web3.js
             throw e;
         }
     }
     finally {
         controller.abort();
     }
-    // in case rpc is not synced yet, we add some retries
     const response = (0, promise_retry_1.default)(async (retry) => {
         const response = await connection.getTransaction(txid, {
             commitment: "confirmed",
@@ -85,4 +77,3 @@ async function transactionSenderAndConfirmationWaiter({ connection, serializedTr
     });
     return response;
 }
-//# sourceMappingURL=transactionSender.js.map

package/dist/svm/utils.d.ts

@@ -91,17 +91,5 @@ export declare const validateJupiterTokens: (inputMint: string, outputMint: stri
 }>;
 export declare const transformSolanaNFTToUnified: (nft: SolanaNFT) => NFT;
 export declare const fetchWalletNfts: (walletAddress: PublicKey, connection: Connection) => Promise<NFT[]>;
-/**
- * Get NFT collection details for a specific collection on Solana
- * @param walletAddress - User's wallet public key
- * @param collectionAddress - The NFT collection address (can be collection mint or update authority)
- * @param connection - Solana connection
- * @returns NFTCollection object with collection details and user's NFTs in that collection
- *
- * Note: On Solana, collections can be identified by:
- * - Collection mint address (from collection field in NFT metadata)
- * - Update authority (who can modify the NFT metadata)
- * This function filters by the collection.address field which is typically the collection mint
- */
 export declare const getNFTCollection: (walletAddress: PublicKey, collectionAddress: string, connection: Connection) => Promise<NFTCollection | null>;
 export {};