@aastar/sdk 0.16.6 → 0.16.11

package/packages/core/src/actions/faucet.ts

@@ -3,117 +3,125 @@ import {
     type WalletClient, 
     type PublicClient, 
     parseEther, 
-    parseAbi, 
-    createPublicClient,
-    http,
     formatEther,
     zeroAddress,
-    encodeAbiParameters
+    type Account,
+    type Hash
 } from 'viem';
-import { sepolia } from 'viem/chains';
-import { registryActions } from './registry';
-import { paymasterV4Actions } from './paymasterV4';
+import { registryActions } from './registry.js';
+import { gTokenActions } from './tokens.js';
+import { paymasterActions } from './paymaster.js';
+import { validateAddress, validateAmount, validateRequired } from '../validators/index.js';
+import { AAStarError } from '../errors/index.js';
 
-// Standard ERC20 ABI for minting/approving
-const ERC20_ABI = parseAbi([
-    'function mint(address to, uint256 amount) external',
-    'function approve(address spender, uint256 amount) external returns (bool)',
-    'function balanceOf(address account) external view returns (uint256)',
-    'function allowance(address owner, address spender) external view returns (uint256)',
-    'function transfer(address to, uint256 amount) external returns (bool)'
-]);
+export type FaucetPreparationResult = {
+    ethFunded: boolean;
+    roleRegistered: boolean;
+    tokenMinted: boolean;
+    paymasterDeposited: boolean;
+};
 
-const PAYMASTER_ABI = parseAbi([
-    'function depositFor(address target, uint256 amount) external',
-    'function deposit() external payable'
-]); 
+export type FaucetConfig = {
+    targetAA: Address;
+    token: Address;
+    registry: Address;
+    paymasterV4?: Address;
+    ethAmount?: bigint; // Default 0.1 ETH
+    tokenAmount?: bigint; // Default 1000 Tokens
+};
 
+/**
+ * SepoliaFaucetAPI provides orchestration for setting up test accounts on Sepolia/Anvil.
+ */
 export class SepoliaFaucetAPI {
     
     /**
      * Orchestrates the complete setup for a test account.
      * 1. Funds ETH
      * 2. Registers ENDUSER role
-     * 3. Mints potential Paymaster Tokens (cPNTs/dPNTs)
+     * 3. Mints GTokens to user
      * 4. Deposits to Paymaster V4 (if address provided) using Admin's tokens
      */
     static async prepareTestAccount(
         adminWallet: WalletClient, 
         publicClient: PublicClient,
-        config: {
-            targetAA: Address;
-            token: Address;
-            registry: Address;
-            paymasterV4?: Address;
-            superPaymaster?: Address; // Just for context, no specific action needed if user holds token
-            ethAmount?: bigint; // Default 0.1 ETH
-            tokenAmount?: bigint; // Default 1000 Tokens
-            community?: Address;
-        }
-    ) {
-        console.log(`\n🚰 SepoliaFaucetAPI: Preparing ${config.targetAA}...`);
-        const results = {
-            ethFunded: false,
-            roleRegistered: false,
-            tokenMinted: false,
-            paymasterDeposited: false
-        };
+        config: FaucetConfig
+    ): Promise<FaucetPreparationResult> {
+        try {
+            validateRequired(adminWallet, 'adminWallet');
+            validateRequired(publicClient, 'publicClient');
+            validateAddress(config.targetAA, 'targetAA');
+            validateAddress(config.token, 'token');
+            validateAddress(config.registry, 'registry');
 
-        // 1. Fund ETH
-        const ethAmount = config.ethAmount ?? parseEther('0.1');
-        results.ethFunded = await this.fundETH(adminWallet, publicClient, config.targetAA, ethAmount);
+            console.log(`\n🚰 SepoliaFaucetAPI: Preparing ${config.targetAA}...`);
+            const results: FaucetPreparationResult = {
+                ethFunded: false,
+                roleRegistered: false,
+                tokenMinted: false,
+                paymasterDeposited: false
+            };
 
-        // 2. Register EndUser
-        results.roleRegistered = await this.registerEndUser(adminWallet, publicClient, config.registry, config.targetAA, config.token, config.community);
+            // 1. Fund ETH
+            const ethAmount = config.ethAmount ?? parseEther('0.1');
+            results.ethFunded = await this.fundETH(adminWallet, publicClient, config.targetAA, ethAmount);
 
-        // 3. Mint Tokens (User Holding Logic - for SuperPaymaster)
-        // If SuperPaymaster is involved, User needs to HOLD the token.
-        // If Paymaster V4 is involved, User might need to HOLD (Pull mode) or Admin Deposits (Push mode).
-        // Strategy: Always mint some to User for flexibility.
-        const tokenAmount = config.tokenAmount ?? parseEther('1000');
-        results.tokenMinted = await this.mintTestTokens(adminWallet, publicClient, config.token, config.targetAA, tokenAmount);
+            // 2. Register EndUser
+            results.roleRegistered = await this.registerEndUser(adminWallet, publicClient, config.registry, config.targetAA, config.token);
 
-        // 4. Admin Deposit for User (Paymaster V4 Logic)
-        if (config.paymasterV4) {
-            results.paymasterDeposited = await this.adminDepositForUser(
-                adminWallet, 
-                publicClient, 
-                config.paymasterV4, 
-                config.targetAA, 
-                config.token, 
-                parseEther('10') // Deposit 10 Tokens for testing
-            );
-        }
+            // 3. Mint Tokens
+            const tokenAmount = config.tokenAmount ?? parseEther('1000');
+            results.tokenMinted = await this.mintTestTokens(adminWallet, publicClient, config.token, config.targetAA, tokenAmount);
+
+            // 4. Admin Deposit for User (Paymaster V4 Logic)
+            if (config.paymasterV4) {
+                validateAddress(config.paymasterV4, 'paymasterV4');
+                results.paymasterDeposited = await this.adminDepositForUser(
+                    adminWallet, 
+                    publicClient, 
+                    config.paymasterV4, 
+                    config.targetAA, 
+                    config.token, 
+                    parseEther('10') // Deposit 10 Tokens for testing
+                );
+            }
 
-        console.log(`✅ Preparation Complete!`, results);
-        return results;
+            console.log(`✅ Preparation Complete!`, results);
+            return results;
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'prepareTestAccount');
+        }
     }
 
     /**
      * Funds the target with ETH if balance is below threshold.
      */
     static async fundETH(adminWallet: WalletClient, publicClient: PublicClient, target: Address, amount: bigint): Promise<boolean> {
-        const balance = await publicClient.getBalance({ address: target });
-        // Threshold: 50% of target amount
-        if (balance < (amount / 2n)) {
-            console.log(`   💰 Funding ETH... (Before: ${formatEther(balance)})`);
-            const hash = await adminWallet.sendTransaction({
-                to: target,
-                value: amount,
-                chain: sepolia,
-                account: adminWallet.account! 
-            });
-            await publicClient.waitForTransactionReceipt({ hash, timeout: 300000 });
-            console.log(`      -> Sent ${formatEther(amount)} ETH. Tx: ${hash}`);
-            return true;
+        try {
+            validateAddress(target, 'target');
+            validateAmount(amount, 'amount');
+            
+            const balance = await publicClient.getBalance({ address: target });
+            // Threshold: 50% of target amount
+            if (balance < (amount / 2n)) {
+                console.log(`   💰 Funding ETH... (Before: ${formatEther(balance)})`);
+                const hash = await adminWallet.sendTransaction({
+                    to: target,
+                    value: amount,
+                    account: adminWallet.account!,
+                    chain: adminWallet.chain
+                });
+                await publicClient.waitForTransactionReceipt({ hash, timeout: 120000 });
+                console.log(`      -> Sent ${formatEther(amount)} ETH. Tx: ${hash}`);
+                return true;
+            }
+            console.log(`   ✅ ETH Balance adequate (${formatEther(balance)} ETH).`);
+            return false;
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'fundETH');
         }
-        console.log(`   ✅ ETH Balance adequate (${formatEther(balance)} ETH).`);
-        return false;
     }
 
-    /**
-     * Registers the ENDUSER role via Registry.
-     */
     /**
      * Registers the ENDUSER role using Sponsor Mode (Admin pays stake).
      */
@@ -122,154 +130,62 @@ export class SepoliaFaucetAPI {
         publicClient: PublicClient, 
         registryAddr: Address, 
         target: Address,
-        gasToken: Address, // Re-using the 'token' passed in config which is GToken
-        community?: Address
+        gasToken: Address
     ): Promise<boolean> {
-        // ENDUSER Hash: keccak256("ENDUSER")
-        const ENDUSER_ROLE = '0x0c34ecc75d3bf122e0609d2576e167f53fb42429262ce8c9b33cab91ff670e3a';
-        
-        // 1. Check if already registered
-        const hasRole = await publicClient.readContract({
-            address: registryAddr,
-            abi: parseAbi(['function hasRole(bytes32 role, address account) view returns (bool)']),
-            functionName: 'hasRole',
-            args: [ENDUSER_ROLE as `0x${string}`, target]
-        });
-
-        if (hasRole) {
-            console.log(`   ✅ ENDUSER Role already held.`);
-            return false;
-        }
-
-        console.log(`   👤 Registering ENDUSER role (Sponsor Mode)...`);
-
         try {
-            // 2. Get Staking Contract Address
-            const stakingAddr = await publicClient.readContract({
-                address: registryAddr,
-                abi: parseAbi(['function GTOKEN_STAKING() view returns (address)']),
-                functionName: 'GTOKEN_STAKING'
-            }) as Address;
+            validateAddress(registryAddr, 'registryAddr');
+            validateAddress(target, 'target');
+            validateAddress(gasToken, 'gasToken');
 
-            // Fetch the actual GToken required by Staking
-            const stakingToken = await publicClient.readContract({
-                address: stakingAddr,
-                abi: parseAbi(['function GTOKEN() view returns (address)']),
-                functionName: 'GTOKEN'
-            }) as Address;
+            const registry = registryActions(registryAddr)(publicClient);
+            const walletRegistry = registryActions(registryAddr)(adminWallet);
+            const token = gTokenActions(gasToken)(publicClient);
+            const walletToken = gTokenActions(gasToken)(adminWallet);
 
-            // 3. Admin Approves Staking Contract (if needed)
-            const adminAddr = adminWallet.account!.address;
-            console.log(`      🔎 Debug Staking: Registry=${registryAddr}, Staking=${stakingAddr}`);
-            console.log(`      🔎 Debug Token: Contract=${stakingToken}`);
+            // 1. Get ENDUSER Role ID
+            const ENDUSER_ROLE = await registry.ROLE_ENDUSER();
             
-            // Check allowance for the STAKING TOKEN
-            const allowance = await publicClient.readContract({
-                address: stakingToken,
-                abi: ERC20_ABI,
-                functionName: 'allowance',
-                args: [adminAddr, stakingAddr]
-            });
-            console.log(`      🔎 Debug Allowance: ${formatEther(allowance)} (Needed: >0.5)`);
+            // 2. Check if already registered
+            const hasRole = await registry.hasRole({ roleId: ENDUSER_ROLE, user: target });
 
-            // Approve if needed (standard stake ~0.3 ETH, verify enough)
-            const approveAmount = parseEther('1000'); // A sufficiently large amount
-            if (allowance < parseEther('500')) {
-                console.log('      🔓 Approving Staking Contract (Core Token)...');
-                const hashApprove = await adminWallet.writeContract({
-                    address: stakingToken,
-                    abi: ERC20_ABI,
-                    functionName: 'approve',
-                    args: [stakingAddr, approveAmount],
-                    chain: sepolia,
-                    account: adminWallet.account!
-                });
-                await publicClient.waitForTransactionReceipt({ hash: hashApprove, timeout: 300000 });
-                console.log(`      🔓 Approving Staking Contract... ${hashApprove}`);
+            if (hasRole) {
+                console.log(`   ✅ ENDUSER Role already held.`);
+                return false;
+            }
 
-                // Ensure Admin has GTokens (Staking Token) balance
-                const adminGBal = await publicClient.readContract({
-                    address: stakingToken,
-                    abi: ERC20_ABI,
-                    functionName: 'balanceOf',
-                    args: [adminAddr]
-                }) as bigint;
+            console.log(`   👤 Registering ENDUSER role (Sponsor Mode)...`);
 
-                if (adminGBal < parseEther('100')) {
-                    console.log(`      🪙 Minting GTokens (Staking Token) to Admin...`);
-                    try {
-                        const hashGMint = await adminWallet.writeContract({
-                            address: stakingToken,
-                            abi: ERC20_ABI,
-                            functionName: 'mint',
-                            args: [adminAddr, parseEther('1000')],
-                            chain: sepolia,
-                            account: adminWallet.account!
-                        });
-                        await publicClient.waitForTransactionReceipt({ hash: hashGMint, timeout: 300000 });
-                        console.log(`      ✅ GTokens Minted. Tx: ${hashGMint}`);
-                    } catch (e) {
-                        console.warn(`      ⚠️ Failed to mint GTokens (Admin might not be minter):`, e);
-                    }
-                }
-            }
+            // 3. Get Staking Contract Address
+            const stakingAddr = await registry.GTOKEN_STAKING();
 
-            // ALSO Approve Registry (just in case it pulls first)
-            const allowReg = await publicClient.readContract({
-                address: stakingToken,
-                abi: ERC20_ABI,
-                functionName: 'allowance',
-                args: [adminAddr, registryAddr]
-            });
-            if (allowReg < parseEther('500')) {
-                console.log('      🔓 Approving Registry Contract...');
-                const hash = await adminWallet.writeContract({
-                    address: stakingToken,
-                    abi: ERC20_ABI,
-                    functionName: 'approve',
-                    args: [registryAddr, parseEther('1000')],
-                    chain: sepolia,
-                    account: adminWallet.account!
+            // 4. Admin Approves Staking Contract (if needed)
+            const adminAddr = adminWallet.account!.address;
+            const allowance = await token.allowance({ token: gasToken, owner: adminAddr, spender: stakingAddr });
+
+            if (allowance < parseEther('500')) {
+                console.log(`      🔓 Approving Staking Contract...`);
+                const hashApprove = await walletToken.approve({ 
+                    token: gasToken,
+                    spender: stakingAddr, 
+                    amount: parseEther('1000') 
                 });
-                await publicClient.waitForTransactionReceipt({ hash, timeout: 300000 });
-                console.log(`      ✅ Approved Registry. Tx: ${hash}`);
-            } else {
-                 console.log('      ✅ Allowance sufficient.');
+                await publicClient.waitForTransactionReceipt({ hash: hashApprove });
             }
 
-            // 5. Register Role (registerRole)
-            // EndUser Role Data: (address account, address community, string avatarURI, string ensName, uint256 stakeAmount)
-            const userData = encodeAbiParameters(
-                [
-                    { name: 'account', type: 'address' },
-                    { name: 'community', type: 'address' },
-                    { name: 'avatarURI', type: 'string' },
-                    { name: 'ensName', type: 'string' },
-                    { name: 'stakeAmount', type: 'uint256' }
-                ],
-                // Stake Amount 0, relying on Registry to enforce minStake and charge msg.sender
-                [target, community || zeroAddress, '', '', 0n] 
-            ); 
-            
-            const hashMint = await adminWallet.writeContract({
-                address: registryAddr,
-                abi: parseAbi([
-                    'function safeMintForRole(bytes32 roleId, address user, bytes calldata data) external returns (uint256)',
-                    'error InvalidParameter(string message)'
-                ]),
-                functionName: 'safeMintForRole',
-                args: [ENDUSER_ROLE as `0x${string}`, target, userData],
-                chain: sepolia,
-                account: adminWallet.account!
+            // 5. SafeMint (Sponsor)
+            const userData = '0x'; 
+            const hashMint = await walletRegistry.safeMintForRole({ 
+                roleId: ENDUSER_ROLE, 
+                user: target, 
+                data: userData 
             });
             
-            await publicClient.waitForTransactionReceipt({ hash: hashMint, timeout: 300000 });
+            await publicClient.waitForTransactionReceipt({ hash: hashMint, timeout: 120000 });
             console.log(`      -> Role Sponsored & Granted. Tx: ${hashMint}`);
             return true;
 
         } catch (error) {
-            console.warn(`      ⚠️ Failed to sponsor ENDUSER role. Error:`, error);
-            return false;
+            throw AAStarError.fromViemError(error as Error, 'registerEndUser');
         }
     }
 
@@ -279,142 +195,85 @@ export class SepoliaFaucetAPI {
     static async mintTestTokens(
         adminWallet: WalletClient, 
         publicClient: PublicClient, 
-        token: Address, 
+        tokenAddr: Address, 
         target: Address, 
         amount: bigint
     ): Promise<boolean> {
-        const balance = await publicClient.readContract({
-            address: token,
-            abi: ERC20_ABI,
-            functionName: 'balanceOf',
-            args: [target]
-        });
+        try {
+            validateAddress(tokenAddr, 'tokenAddr');
+            validateAddress(target, 'target');
+            validateAmount(amount, 'amount');
 
-        if (balance < amount) {
-            console.log(`   🪙 Funding Tokens... (Current: ${formatEther(balance)})`);
-            const adminAddr = adminWallet.account!.address;
-            
-            // 1. Try Transfer from Admin (if Admin has balance)
-            const adminBal = await publicClient.readContract({
-                address: token,
-                abi: ERC20_ABI,
-                functionName: 'balanceOf',
-                args: [adminAddr]
-            });
+            const token = gTokenActions(tokenAddr)(publicClient);
+            const walletToken = gTokenActions(tokenAddr)(adminWallet);
 
-            if (adminBal >= amount) {
-                 console.log(`      💸 Transferring from Admin...`);
-                 const hash = await adminWallet.writeContract({
-                     address: token,
-                     abi: ERC20_ABI,
-                     functionName: 'transfer',
-                     args: [target, amount],
-                     chain: sepolia,
-                     account: adminWallet.account!
-                 });
-                 await publicClient.waitForTransactionReceipt({ hash, timeout: 300000 });
-                 console.log(`      ✅ Transferred ${formatEther(amount)}. Tx: ${hash}`);
-                 return true;
-            }
+            const balance = await token.balanceOf({ token: tokenAddr, account: target });
 
-            // 2. Try Mint (Assuming Admin has Minter Role or is Owner)
-            console.log(`      🪙 Admin balance low. Attempting Mint...`);
-            try {
-                const hash = await adminWallet.writeContract({
-                    address: token,
-                    abi: ERC20_ABI,
-                    functionName: 'mint',
-                    args: [target, amount],
-                    chain: sepolia,
-                    account: adminWallet.account!
-                });
-                await publicClient.waitForTransactionReceipt({ hash, timeout: 300000 });
-                console.log(`      ✅ Minted ${formatEther(amount)}. Tx: ${hash}`);
+            if (balance < amount) {
+                console.log(`   🪙 Minting Tokens... (Current: ${formatEther(balance)})`);
+                const hash = await walletToken.mint({ token: tokenAddr, to: target, amount });
+                await publicClient.waitForTransactionReceipt({ hash, timeout: 120000 });
+                console.log(`      -> Minted ${formatEther(amount)}. Tx: ${hash}`);
                 return true;
-            } catch (e) {
-                console.warn(`      ⚠️ Failed to mint/transfer tokens. Check Admin permissions/balance.`, e);
-                return false;
             }
+            console.log(`   ✅ Token Balance adequate.`);
+            return false;
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'mintTestTokens');
         }
-        console.log(`   ✅ Token Balance adequate.`);
-        return false;
     }
 
     /**
-     * Complex Flow:
-     * 1. Admin mints tokens to SELF.
-     * 2. Admin approves Paymaster.
-     * 3. Admin calls depositFor(target) on Paymaster.
+     * Admin mints tokens to self, approves Paymaster, and deposits FOR user.
      */
     static async adminDepositForUser(
         adminWallet: WalletClient, 
         publicClient: PublicClient, 
-        paymaster: Address, 
+        paymasterAddr: Address, 
         target: Address, 
-        token: Address, 
+        tokenAddr: Address, 
         amount: bigint
     ): Promise<boolean> {
-        // 1. Mint to Admin First
-        const adminAddr = adminWallet.account!.address;
-        const adminBal = await publicClient.readContract({
-            address: token,
-            abi: ERC20_ABI,
-            functionName: 'balanceOf',
-            args: [adminAddr]
-        });
+        try {
+            validateAddress(paymasterAddr, 'paymasterAddr');
+            validateAddress(target, 'target');
+            validateAddress(tokenAddr, 'tokenAddr');
+            validateAmount(amount, 'amount');
 
-        if (adminBal < amount) {
-            console.log(`   🏧 Admin Minting to Self (for deposit)...`);
-            const hash = await adminWallet.writeContract({
-                address: token,
-                abi: ERC20_ABI,
-                functionName: 'mint',
-                args: [adminAddr, amount * 10n], // bulk mint
-                chain: sepolia,
-                account: adminWallet.account!
-            });
-            await publicClient.waitForTransactionReceipt({ hash, timeout: 300000 });
-            console.log(`      -> Admin Minted. Tx: ${hash}`);
-        }
+            const token = gTokenActions(tokenAddr)(publicClient);
+            const walletToken = gTokenActions(tokenAddr)(adminWallet);
+            const paymaster = paymasterActions(paymasterAddr)(adminWallet);
 
-        // 2. Approve Paymaster
-        const allowance = await publicClient.readContract({
-            address: token,
-            abi: ERC20_ABI,
-            functionName: 'allowance',
-            args: [adminAddr, paymaster]
-        });
-        
-        if (allowance < amount) {
-            console.log(`   🔓 Admin Approving Paymaster...`);
-            const hash = await adminWallet.writeContract({
-                address: token,
-                abi: ERC20_ABI,
-                functionName: 'approve',
-                args: [paymaster, 115792089237316195423570985008687907853269984665640564039457584007913129639935n], // Max Uint
-                chain: sepolia,
-                account: adminWallet.account!
-            });
-            await publicClient.waitForTransactionReceipt({ hash, timeout: 300000 });
-            console.log(`      -> Approved Paymaster. Tx: ${hash}`);
-        }
+            const adminAddr = adminWallet.account!.address;
+            const adminBal = await token.balanceOf({ token: tokenAddr, account: adminAddr });
 
-        // 3. Deposit For
-        console.log(`   🏦 Depositing FOR User...`);
-        try {
-            const hash = await adminWallet.writeContract({
-                address: paymaster,
-                abi: PAYMASTER_ABI,
-                functionName: 'depositFor',
-                args: [target, amount],
-                chain: sepolia,
-                account: adminWallet.account!
-            });
-            await publicClient.waitForTransactionReceipt({ hash, timeout: 300000 });
+            if (adminBal < amount) {
+                console.log(`   🏧 Admin Minting to Self (for deposit)...`);
+                const hash = await walletToken.mint({ token: tokenAddr, to: adminAddr, amount: amount * 10n });
+                await publicClient.waitForTransactionReceipt({ hash });
+            }
+
+            const allowance = await token.allowance({ token: tokenAddr, owner: adminAddr, spender: paymasterAddr });
+            
+            if (allowance < amount) {
+                console.log(`   🔓 Admin Approving Paymaster...`);
+                // Use a large but finite amount instead of max uint for safety/clarity if desired, 
+                // but max uint is common in faucets.
+                const hashApprove = await walletToken.approve({ 
+                    token: tokenAddr,
+                    spender: paymasterAddr, 
+                    amount: parseEther('10000') 
+                });
+                await publicClient.waitForTransactionReceipt({ hash: hashApprove });
+            }
+
+            console.log(`   🏦 Depositing FOR User...`);
+            const hash = await paymaster.depositFor({ user: target, token: tokenAddr, amount });
+            await publicClient.waitForTransactionReceipt({ hash, timeout: 120000 });
             console.log(`      -> Deposited ${formatEther(amount)} to PM. Tx: ${hash}`);
             return true;
-        } catch (e) {
-            console.warn(`      ⚠️ Deposit Failed (Maybe not supported on this PM?):`, e);
+        } catch (error) {
+            console.warn(`      ⚠️ Deposit Failed (Maybe not supported on this PM?):`, error);
             return false;
         }
     }

package/packages/core/src/actions/index.ts

@@ -2,17 +2,14 @@ export * from './registry.js';
 export * from './staking.js';
 export * from './sbt.js';
 export * from './superPaymaster.js';
-export * from './paymasterV4.js';
+export * from './paymaster.js';
 export * from './reputation.js';
 export * from './tokens.js';
 export * from './entryPoint.js';
-export * from './gtokenExtended.js';
 export * from './StateValidator.js';
 export * from './dvt.js';
 export * from './factory.js';
 export * from './aggregator.js';
 export * from './account.js';
 export * from './faucet.js';
-// validators.ts merged into dvt.js and aggregator.js
-// validators.ts merged into dvt.js and aggregator.js
-
+// validators.ts legacy removed