@aastar/core 0.16.8 → 0.16.11

package/dist/actions/faucet.d.ts

@@ -1,48 +1,44 @@
 import { type Address, type WalletClient, type PublicClient } from 'viem';
+export type FaucetPreparationResult = {
+    ethFunded: boolean;
+    roleRegistered: boolean;
+    tokenMinted: boolean;
+    paymasterDeposited: boolean;
+};
+export type FaucetConfig = {
+    targetAA: Address;
+    token: Address;
+    registry: Address;
+    paymasterV4?: Address;
+    ethAmount?: bigint;
+    tokenAmount?: bigint;
+};
+/**
+ * SepoliaFaucetAPI provides orchestration for setting up test accounts on Sepolia/Anvil.
+ */
 export declare 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 prepareTestAccount(adminWallet: WalletClient, publicClient: PublicClient, config: {
-        targetAA: Address;
-        token: Address;
-        registry: Address;
-        paymasterV4?: Address;
-        superPaymaster?: Address;
-        ethAmount?: bigint;
-        tokenAmount?: bigint;
-        community?: Address;
-    }): Promise<{
-        ethFunded: boolean;
-        roleRegistered: boolean;
-        tokenMinted: boolean;
-        paymasterDeposited: boolean;
-    }>;
+    static prepareTestAccount(adminWallet: WalletClient, publicClient: PublicClient, config: FaucetConfig): Promise<FaucetPreparationResult>;
     /**
      * Funds the target with ETH if balance is below threshold.
      */
     static fundETH(adminWallet: WalletClient, publicClient: PublicClient, target: Address, amount: bigint): Promise<boolean>;
-    /**
-     * Registers the ENDUSER role via Registry.
-     */
     /**
      * Registers the ENDUSER role using Sponsor Mode (Admin pays stake).
      */
-    static registerEndUser(adminWallet: WalletClient, publicClient: PublicClient, registryAddr: Address, target: Address, gasToken: Address, // Re-using the 'token' passed in config which is GToken
-    community?: Address): Promise<boolean>;
+    static registerEndUser(adminWallet: WalletClient, publicClient: PublicClient, registryAddr: Address, target: Address, gasToken: Address): Promise<boolean>;
     /**
      * Mints tokens directly to the target.
      */
-    static mintTestTokens(adminWallet: WalletClient, publicClient: PublicClient, token: Address, target: Address, amount: bigint): Promise<boolean>;
+    static mintTestTokens(adminWallet: WalletClient, publicClient: PublicClient, tokenAddr: Address, target: Address, amount: bigint): Promise<boolean>;
     /**
-     * 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 adminDepositForUser(adminWallet: WalletClient, publicClient: PublicClient, paymaster: Address, target: Address, token: Address, amount: bigint): Promise<boolean>;
+    static adminDepositForUser(adminWallet: WalletClient, publicClient: PublicClient, paymasterAddr: Address, target: Address, tokenAddr: Address, amount: bigint): Promise<boolean>;
 }

package/dist/actions/faucet.js

@@ -1,336 +1,197 @@
-import { parseEther, parseAbi, formatEther, zeroAddress, encodeAbiParameters } from 'viem';
-import { sepolia } from 'viem/chains';
-// 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)'
-]);
-const PAYMASTER_ABI = parseAbi([
-    'function depositFor(address target, uint256 amount) external',
-    'function deposit() external payable'
-]);
+import { parseEther, formatEther } from 'viem';
+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';
+/**
+ * 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, publicClient, config) {
-        console.log(`\n🚰 SepoliaFaucetAPI: Preparing ${config.targetAA}...`);
-        const results = {
-            ethFunded: false,
-            roleRegistered: false,
-            tokenMinted: false,
-            paymasterDeposited: false
-        };
-        // 1. Fund ETH
-        const ethAmount = config.ethAmount ?? parseEther('0.1');
-        results.ethFunded = await this.fundETH(adminWallet, publicClient, config.targetAA, ethAmount);
-        // 2. Register EndUser
-        results.roleRegistered = await this.registerEndUser(adminWallet, publicClient, config.registry, config.targetAA, config.token, config.community);
-        // 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);
-        // 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
-            );
+        try {
+            validateRequired(adminWallet, 'adminWallet');
+            validateRequired(publicClient, 'publicClient');
+            validateAddress(config.targetAA, 'targetAA');
+            validateAddress(config.token, 'token');
+            validateAddress(config.registry, 'registry');
+            console.log(`\n🚰 SepoliaFaucetAPI: Preparing ${config.targetAA}...`);
+            const results = {
+                ethFunded: false,
+                roleRegistered: false,
+                tokenMinted: false,
+                paymasterDeposited: false
+            };
+            // 1. Fund ETH
+            const ethAmount = config.ethAmount ?? parseEther('0.1');
+            results.ethFunded = await this.fundETH(adminWallet, publicClient, config.targetAA, ethAmount);
+            // 2. Register EndUser
+            results.roleRegistered = await this.registerEndUser(adminWallet, publicClient, config.registry, config.targetAA, config.token);
+            // 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;
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'prepareTestAccount');
         }
-        console.log(`✅ Preparation Complete!`, results);
-        return results;
     }
     /**
      * Funds the target with ETH if balance is below threshold.
      */
     static async fundETH(adminWallet, publicClient, target, 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,
-                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, '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).
      */
-    static async registerEndUser(adminWallet, publicClient, registryAddr, target, gasToken, // Re-using the 'token' passed in config which is GToken
-    community) {
-        // 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, target]
-        });
-        if (hasRole) {
-            console.log(`   ✅ ENDUSER Role already held.`);
-            return false;
-        }
-        console.log(`   👤 Registering ENDUSER role (Sponsor Mode)...`);
+    static async registerEndUser(adminWallet, publicClient, registryAddr, target, gasToken) {
         try {
-            // 2. Get Staking Contract Address
-            const stakingAddr = await publicClient.readContract({
-                address: registryAddr,
-                abi: parseAbi(['function GTOKEN_STAKING() view returns (address)']),
-                functionName: 'GTOKEN_STAKING'
-            });
-            // Fetch the actual GToken required by Staking
-            const stakingToken = await publicClient.readContract({
-                address: stakingAddr,
-                abi: parseAbi(['function GTOKEN() view returns (address)']),
-                functionName: 'GTOKEN'
-            });
-            // 3. Admin Approves Staking Contract (if needed)
+            validateAddress(registryAddr, 'registryAddr');
+            validateAddress(target, 'target');
+            validateAddress(gasToken, 'gasToken');
+            const registry = registryActions(registryAddr)(publicClient);
+            const walletRegistry = registryActions(registryAddr)(adminWallet);
+            const token = gTokenActions(gasToken)(publicClient);
+            const walletToken = gTokenActions(gasToken)(adminWallet);
+            // 1. Get ENDUSER Role ID
+            const ENDUSER_ROLE = await registry.ROLE_ENDUSER();
+            // 2. Check if already registered
+            const hasRole = await registry.hasRole({ roleId: ENDUSER_ROLE, user: target });
+            if (hasRole) {
+                console.log(`   ✅ ENDUSER Role already held.`);
+                return false;
+            }
+            console.log(`   👤 Registering ENDUSER role (Sponsor Mode)...`);
+            // 3. Get Staking Contract Address
+            const stakingAddr = await registry.GTOKEN_STAKING();
+            // 4. 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}`);
-            // 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)`);
-            // Approve if needed (standard stake ~0.3 ETH, verify enough)
-            const approveAmount = parseEther('1000'); // A sufficiently large amount
+            const allowance = await token.allowance({ token: gasToken, owner: adminAddr, spender: stakingAddr });
             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}`);
-                // Ensure Admin has GTokens (Staking Token) balance
-                const adminGBal = await publicClient.readContract({
-                    address: stakingToken,
-                    abi: ERC20_ABI,
-                    functionName: 'balanceOf',
-                    args: [adminAddr]
-                });
-                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);
-                    }
-                }
-            }
-            // 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
+                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, 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, 'registerEndUser');
         }
     }
     /**
      * Mints tokens directly to the target.
      */
-    static async mintTestTokens(adminWallet, publicClient, token, target, amount) {
-        const balance = await publicClient.readContract({
-            address: token,
-            abi: ERC20_ABI,
-            functionName: 'balanceOf',
-            args: [target]
-        });
-        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]
-            });
-            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;
-            }
-            // 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}`);
+    static async mintTestTokens(adminWallet, publicClient, tokenAddr, target, amount) {
+        try {
+            validateAddress(tokenAddr, 'tokenAddr');
+            validateAddress(target, 'target');
+            validateAmount(amount, 'amount');
+            const token = gTokenActions(tokenAddr)(publicClient);
+            const walletToken = gTokenActions(tokenAddr)(adminWallet);
+            const balance = await token.balanceOf({ token: tokenAddr, account: target });
+            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, '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, publicClient, paymaster, target, token, amount) {
-        // 1. Mint to Admin First
-        const adminAddr = adminWallet.account.address;
-        const adminBal = await publicClient.readContract({
-            address: token,
-            abi: ERC20_ABI,
-            functionName: 'balanceOf',
-            args: [adminAddr]
-        });
-        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}`);
-        }
-        // 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}`);
-        }
-        // 3. Deposit For
-        console.log(`   🏦 Depositing FOR User...`);
+    static async adminDepositForUser(adminWallet, publicClient, paymasterAddr, target, tokenAddr, amount) {
         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 });
+            validateAddress(paymasterAddr, 'paymasterAddr');
+            validateAddress(target, 'target');
+            validateAddress(tokenAddr, 'tokenAddr');
+            validateAmount(amount, 'amount');
+            const token = gTokenActions(tokenAddr)(publicClient);
+            const walletToken = gTokenActions(tokenAddr)(adminWallet);
+            const paymaster = paymasterActions(paymasterAddr)(adminWallet);
+            const adminAddr = adminWallet.account.address;
+            const adminBal = await token.balanceOf({ token: tokenAddr, account: adminAddr });
+            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/dist/actions/index.d.ts

@@ -2,11 +2,10 @@ 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';

package/dist/actions/index.js

@@ -2,16 +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