@aastar/sdk 0.16.6 → 0.16.11

package/scripts/20_sdk_full_capability.ts

@@ -1,93 +1,95 @@
 
-import { http, type Hex, parseEther, Address } from 'viem';
+import { createAAStarPublicClient, registryActions } from '../packages/core/src/index.js';
+import { createAdminClient } from '../packages/sdk/src/index.js';
+import { ReputationClient } from '../packages/identity/src/index.js';
+import { FinanceClient } from '../packages/tokens/src/index.js';
+import { DVTClient } from '../packages/dapp/src/index.js';
+
+import { foundry } from 'viem/chains';
 import { privateKeyToAccount } from 'viem/accounts';
-import { 
-    createAdminClient, 
-    createOperatorClient,
-    createCommunityClient,
-    createEndUserClient,
-    CORE_ADDRESSES,
-    TEST_TOKEN_ADDRESSES,
-    parseKey
-} from '../packages/sdk/src/index.ts';
+import { http, type Hex, parseEther } from 'viem';
 import * as dotenv from 'dotenv';
 import * as path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
 
-// Load env
-const NETWORK = process.env.EXPERIMENT_NETWORK || 'anvil';
-const envFile = NETWORK === 'sepolia' ? '.env.sepolia' : '.env.anvil';
-dotenv.config({ path: path.resolve(process.cwd(), envFile) });
+dotenv.config({ path: path.resolve(process.cwd(), '.env.anvil') });
 
-const ADMIN_KEY = (process.env.ADMIN_KEY || process.env.PRIVATE_KEY_JASON) as Hex;
-const RPC_URL = process.env.RPC_URL || (NETWORK === 'sepolia' ? process.env.SEPOLIA_RPC_URL : "http://127.0.0.1:8545");
+const ADMIN_KEY = process.env.ADMIN_KEY as Hex;
+const RPC_URL = process.env.RPC_URL || 'http://127.0.0.1:8545';
+const REGISTRY_ADDR = process.env.REGISTRY_ADDR as Hex;
+const REPUTATION_ADDR = process.env.REPUTATION_SYSTEM_ADDR as Hex; // Check env var name
+const PAYMASTER_ADDR = process.env.SUPERPAYMASTER_ADDR as Hex;
+const DVT_ADDR = process.env.DVT_VALIDATOR_ADDR as Hex; // Assuming this might be missing in .env.anvil, check later
 
 async function runFullCapabilityTest() {
-    console.log(`🚀 Running Full Capability SDK Test (Network: ${NETWORK})`);
+    console.log("🚀 Running Full Capability SDK Test (v1.0 Preview)...");
 
-    if (!ADMIN_KEY) throw new Error("Missing ADMIN_KEY");
-    const account = privateKeyToAccount(parseKey(ADMIN_KEY));
-
-    // 1. Admin Capabilities
-    console.log("\n--- 🔧 Admin Client ---");
-    const admin = createAdminClient({ transport: http(RPC_URL), account });
-    const registryOwner = await admin.readContract({
-        address: CORE_ADDRESSES.registry,
-        abi: [{ name: 'owner', type: 'function', inputs: [], outputs: [{ type: 'address' }], stateMutability: 'view' }],
-        functionName: 'owner'
+    const account = privateKeyToAccount(ADMIN_KEY);
+    const publicClient = createAAStarPublicClient({ chain: foundry, rpcUrl: RPC_URL });
+    const walletClient = createAdminClient({ 
+        chain: foundry, 
+        transport: http(RPC_URL), 
+        account,
+        addresses: {
+            registry: REGISTRY_ADDR,
+            superPaymaster: PAYMASTER_ADDR,
+            gTokenStaking: process.env.GTOKEN_STAKING_ADDR as Hex
+        }
     });
-    console.log(`   Registry Owner: ${registryOwner}`);
 
-    // 2. Operator Capabilities
-    console.log("\n--- 🏭 Operator Client ---");
-    const operator = createOperatorClient({ transport: http(RPC_URL), account });
-    const status = await operator.getOperatorStatus(account.address);
-    console.log(`   Is Simple Operator: ${status.isOperator}`);
-    console.log(`   Is Super Operator: ${status.isSuperPaymaster}`);
-    if (status.paymasterV4) {
-        console.log(`   Paymaster V4: ${status.paymasterV4.address}`);
-    }
+    // 1. Registry
+    console.log("   📜 Testing Registry (Credit Check)...");
+    const regActions = registryActions(REGISTRY_ADDR)(publicClient);
+    const credit = await regActions.getCreditLimit({ user: account.address });
+    console.log(`      Credit Limit: ${credit}`);
 
-    // 3. Community Capabilities
-    console.log("\n--- 🤝 Community Client ---");
-    const community = createCommunityClient({ transport: http(RPC_URL), account }); // Note: reuse account for simplicity in this demo
-    // Checking a community status (can be self or another)
-    const isComm = await admin.readContract({
-         address: CORE_ADDRESSES.registry,
-         abi: [{ name: 'hasRole', type: 'function', inputs: [{type:'bytes32'}, {type:'address'}], outputs: [{type:'bool'}], stateMutability: 'view' }],
-         functionName: 'hasRole',
-         args: ['0x0000000000000000000000000000000000000000000000000000000000000001' as Hex, account.address] // ROLE_COMMUNITY
-    });
-    console.log(`   Is Community: ${isComm}`);
+    // 2. Reputation
+    if (REPUTATION_ADDR) {
+        console.log("   ⭐ Testing Reputation (Compute Score)...");
+        const repClient = new ReputationClient(publicClient, REPUTATION_ADDR);
+        // Checking score with empty arrays (mock)
+        const score = await repClient.computeScore(account.address, [], [], []);
+        console.log(`      Reputation Score: ${score}`);
+    } else {
+        console.warn("      ⚠️ REPUTATION_ADDR missing, skipping.");
+    }
 
-    // 4. End User Capabilities
-    console.log("\n--- 👤 End User Client ---");
-    const user = createEndUserClient({ transport: http(RPC_URL), account });
-    const { accountAddress } = await user.createSmartAccount({
-        owner: account.address,
-        salt: 1337n
-    });
-    console.log(`   SA Address (Salt 1337): ${accountAddress}`);
+    // 3. Finance
+    console.log("   💰 Testing Finance (Paymaster Deposit)...");
+    // 3. Finance
+    console.log("   💰 Testing Finance (Paymaster Deposit)...");
+    // Use XPNTS or APNTS address from env, fallback to GTOKEN if missing but likely XPNTS is correct for Paymaster collateral
+    const TOKEN_ADDR = (process.env.APNTS || process.env.XPNTS_ADDR || process.env.GTOKEN_ADDRESS || process.env.GAS_TOKEN_ADDRESS) as Hex;
+    
+    if (TOKEN_ADDR) {
+        console.log(`      Using Token: ${TOKEN_ADDR}`);
+        // For xPNTs, we must use Push pattern (transferAndCall)
+        // No approval needed for transferAndCall usually, but we assume we have balance.
+        try {
+            const hash = await FinanceClient.depositViaTransferAndCall(walletClient, TOKEN_ADDR, PAYMASTER_ADDR, parseEther("0.1"));
+            console.log(`      Deposit (Push) Tx: ${hash}`);
+        } catch (e: any) {
+             console.error(`      Deposit Failed: ${e.message}`);
+        }
+    } else {
+        console.warn("      ⚠️ TOKEN Address missing. Skipping Deposit.");
+    }
 
-    // 5. Gasless Execution Demo (Dry Run style)
-    console.log("\n--- ⚡ Gasless Execution (Simulation) ---");
-    try {
-        console.log(`   Simulating gasless transfer...`);
-        // This will attempt to build and estimate. If PMs aren't setup it might fail, which is okay for full capability test to show error reporting.
-        const result = await user.executeGasless({
-            target: account.address,
-            data: '0x',
-            value: 0n
-        });
-        console.log(`   ✅ Execution Hash: ${result.hash}`);
-    } catch (e: any) {
-        console.log(`   ℹ️ Gasless demo skipped/failed (expected if PM not ready): ${e.message.split('\n')[0]}`);
+    // 4. DVT
+    if (DVT_ADDR) {
+        console.log("   🛡️ Testing DVT (Validator Reg)...");
+        // Mock BLS Key
+        const blsKey = "0x12345678" as Hex; // Dummy
+        try {
+            // This might revert if logic checks BLS formatting, but validates route exists
+            await DVTClient.registerValidator(walletClient, DVT_ADDR, blsKey);
+        } catch (e: any) {
+            console.log(`      DVT Call Reached (Reverted as expected for dummy key): ${e.shortMessage || e.message}`);
+        }
+    } else {
+        console.warn("      ⚠️ DVT_ADDR (Validation) missing, skipping.");
     }
 
-    console.log("\n✅ Full Capability Test Complete.");
+    console.log("✅ Full Capability Test Complete.");
 }
 
-main().catch(console.error);
+runFullCapabilityTest().catch(console.error);

package/scripts/analyze_abi_coverage.ts

@@ -25,7 +25,8 @@ function getAllContracts(): ContractAnalysis[] {
     const files = fs.readdirSync(ABIS_DIR).filter(f => f.endsWith('.json') && f !== 'index.ts');
     
     return files.map(file => {
-        const content = JSON.parse(fs.readFileSync(path.join(ABIS_DIR, file), 'utf8'));
+        const rawContent = JSON.parse(fs.readFileSync(path.join(ABIS_DIR, file), 'utf8'));
+        const content = Array.isArray(rawContent) ? rawContent : (rawContent.abi || []);
         const functions = content
             .filter((item: any) => item.type === 'function')
             .map((item: any) => item.name)
@@ -53,8 +54,7 @@ function analyzeActionsCoverage(contracts: ContractAnalysis[]): ContractAnalysis
         'xPNTs': 'tokens.ts',
         'xPNTsToken': 'tokens.ts',
         'SuperPaymaster': 'superPaymaster.ts',
-        'PaymasterV4_2': 'paymasterV4.ts',
-        'Paymaster': 'paymasterV4.ts',
+        'Paymaster': 'paymaster.ts',
         'MySBT': 'sbt.ts',
         'ReputationSystem': 'reputation.ts',
         'PaymasterFactory': 'factory.ts',
@@ -104,7 +104,7 @@ function generateReport(contracts: ContractAnalysis[]) {
         ['aPNTs', 'xPNTs', 'xPNTsToken', 'xPNTsFactory'].includes(c.contract)
     );
     const paymasterContracts = contracts.filter(c => 
-        ['PaymasterV4_2', 'Paymaster', 'PaymasterFactory'].includes(c.contract)
+        ['Paymaster', 'PaymasterFactory'].includes(c.contract)
     );
     const aaContracts = contracts.filter(c => 
         c.contract.includes('Account') || c.contract.includes('EntryPoint')

package/scripts/analyze_missing_functions.ts

@@ -0,0 +1,136 @@
+#!/usr/bin/env tsx
+/**
+ * Missing Functions Analysis Script - для достижения 95% покрытия
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+const ABIS_DIR = path.join(process.cwd(), 'packages/core/src/abis');
+const ACTIONS_DIR = path.join(process.cwd(), 'packages/core/src/actions');
+
+// Mapping contracts to action files
+const MAPPING: Record<string, string> = {
+    'Registry': 'registry.ts',
+    'GTokenStaking': 'staking.ts',
+    'GToken': 'tokens.ts',
+    'aPNTs': 'tokens.ts',
+    'xPNTs': 'tokens.ts',
+    'xPNTsToken': 'tokens.ts',
+    'SuperPaymaster': 'superPaymaster.ts',
+    'Paymaster': 'paymaster.ts',
+    'MySBT': 'sbt.ts',
+    'ReputationSystem': 'reputation.ts',
+    'PaymasterFactory': 'factory.ts',
+    'xPNTsFactory': 'factory.ts',
+    'DVTValidator': 'dvt.ts',
+    'BLSValidator': 'aggregator.ts',
+    'BLSAggregator': 'aggregator.ts',
+};
+
+interface FunctionInfo {
+    name: string;
+    inputs: any[];
+    outputs: any[];
+    stateMutability: string;
+}
+
+function loadABI(contractName: string): FunctionInfo[] {
+    const abiPath = path.join(ABIS_DIR, `${contractName}.json`);
+    if (!fs.existsSync(abiPath)) return [];
+    
+    const rawContent = JSON.parse(fs.readFileSync(abiPath, 'utf8'));
+    const abi = Array.isArray(rawContent) ? rawContent : (rawContent.abi || []);
+    
+    return abi
+        .filter((item: any) => item.type === 'function')
+        .map((item: any) => ({
+            name: item.name,
+            inputs: item.inputs || [],
+            outputs: item.outputs || [],
+            stateMutability: item.stateMutability || 'nonpayable'
+        }));
+}
+
+function getCoveredFunctions(contractName: string): Set<string> {
+    const actionFile = MAPPING[contractName];
+    if (!actionFile) return new Set();
+    
+    const actionPath = path.join(ACTIONS_DIR, actionFile);
+    if (!fs.existsSync(actionPath)) return new Set();
+    
+    const content = fs.readFileSync(actionPath, 'utf8');
+    const covered = new Set<string>();
+    
+    // Match functionName: 'xxx' or functionName: "xxx"
+    const matches = content.matchAll(/functionName:\s*['"]([^'"]+)['"]/g);
+    for (const match of matches) {
+        covered.add(match[1]);
+    }
+    
+    return covered;
+}
+
+function analyzeMissingFunctions(contractName: string) {
+    const allFunctions = loadABI(contractName);
+    const covered = getCoveredFunctions(contractName);
+    
+    const missing = allFunctions.filter(f => !covered.has(f.name));
+    const coveragePercent = allFunctions.length > 0 
+        ? Math.round((covered.size / allFunctions.length) * 100)
+        : 0;
+    
+    return {
+        contractName,
+        actionFile: MAPPING[contractName] || 'N/A',
+        total: allFunctions.length,
+        covered: covered.size,
+        coveragePercent,
+        missing,
+        needsImprovement: coveragePercent < 95
+    };
+}
+
+// Analyze all core business contracts (官方SuperPaymaster contracts)
+const coreContracts = [
+    'ReputationSystem',
+    'GToken',
+    'SuperPaymaster',
+    'GTokenStaking',
+    'xPNTsToken',
+    'xPNTsFactory',
+    'Paymaster',
+    'PaymasterFactory',
+    'MySBT',
+    'Registry',
+    // Validators (自研合约)
+    'BLSAggregator',
+    'DVTValidator',
+    'BLSValidator'
+];
+
+console.log('\n=== Missing Functions Analysis for 95% Coverage ===\n');
+
+const results = coreContracts.map(analyzeMissingFunctions);
+
+for (const result of results) {
+    if (!result.needsImprovement) {
+        console.log(`✅ ${result.contractName}: ${result.coveragePercent}% (${result.covered}/${result.total}) - OK`);
+        continue;
+    }
+    
+    console.log(`\n🔧 ${result.contractName}: ${result.coveragePercent}% (${result.covered}/${result.total})`);
+    console.log(`   Action File: ${result.actionFile}`);
+    console.log(`   Missing Functions (${result.missing.length}):`);
+    
+    for (const fn of result.missing) {
+        const params = fn.inputs.map((p: any) => `${p.name}: ${p.type}`).join(', ');
+        const returns = fn.outputs.length > 0 
+            ? ` → ${fn.outputs.map((o: any) => o.type).join(', ')}` 
+            : '';
+        const mutability = fn.stateMutability !== 'nonpayable' ? ` [${fn.stateMutability}]` : '';
+        console.log(`     - ${fn.name}(${params})${returns}${mutability}`);
+    }
+}
+
+console.log('\n');

package/scripts/canary-bundler.ts

@@ -0,0 +1,47 @@
+import { BundlerClient } from '../packages/sdk/src/index.js';
+import * as dotenv from 'dotenv';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+dotenv.config({ path: path.resolve(__dirname, '../.env.sepolia') });
+
+async function main() {
+    const bundlerUrl = process.env.SEPOLIA_RPC_URL || '';
+    const entryPoint = '0x0000000071727De22E5E9d8BAf0edAc6f37da032'; // Sepolia v0.7
+    
+    // 1. Initialize Parallel Client
+    const client = new BundlerClient(bundlerUrl, entryPoint as `0x${string}`);
+    console.log('🚀 BundlerClient Canary Started');
+
+    // 2. Test getUserOperationByHash
+    // Use the hash from the previous milestone run
+    const hash = '0x97ca3690efb759218325e46aa8d48e1b3ff97bcb8adb2770ca2ce1a36ad00651' as `0x${string}`;
+    console.log(`\n🔍 Querying UserOp: ${hash}`);
+    
+    try {
+        const userOp = await client.getUserOperationByHash(hash);
+        console.log('✅ UserOp Found:', JSON.stringify(userOp, null, 2).slice(0, 200) + '...');
+        
+        const receipt = await client.getUserOperationReceipt(hash);
+        console.log('✅ Receipt Found:', receipt ? 'Yes' : 'No');
+        if (receipt) {
+            console.log(`   Transaction Hash: ${receipt.receipt?.transactionHash || 'N/A'}`);
+        }
+    } catch (e: any) {
+        console.error('❌ Query failed:', e.message);
+    }
+
+    // 3. Test Retry Logic (Using a bad URL)
+    console.log('\n🔄 Testing Retry Logic with invalid URL...');
+    const badClient = new BundlerClient('https://invalid-bundler-url.abc', entryPoint as `0x${string}`);
+    
+    try {
+        await badClient.getUserOperationByHash(hash);
+    } catch (e: any) {
+        console.log('✅ Retry Logic caught failure (Check console for retry logs above this line)');
+    }
+}
+
+main().catch(console.error);

package/scripts/check-chainlink.ts

@@ -0,0 +1,28 @@
+import { createPublicClient, http, parseAbi } from 'viem';
+import { sepolia } from 'viem/chains';
+import * as dotenv from 'dotenv';
+
+dotenv.config({ path: '.env.sepolia' });
+
+const publicClient = createPublicClient({ chain: sepolia, transport: http(process.env.RPC_URL_SEPOLIA!) });
+const priceFeed = '0x694AA1769357215DE4FAC081bf1f309aDC325306';
+
+async function main() {
+    const data = await publicClient.readContract({
+        address: priceFeed,
+        abi: parseAbi(['function latestRoundData() view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)']),
+        functionName: 'latestRoundData'
+    }) as [bigint, bigint, bigint, bigint, bigint];
+    
+    const now = Math.floor(Date.now() / 1000);
+    const age = now - Number(data[3]);
+    
+    console.log('📊 Chainlink ETH/USD Feed (Sepolia):');
+    console.log(`   Price: $${Number(data[1]) / 1e8}`);
+    console.log(`   UpdatedAt: ${data[3]} (${new Date(Number(data[3]) * 1000).toISOString()})`);
+    console.log(`   Age: ${age} seconds (${(age / 3600).toFixed(1)} hours)`);
+    console.log(`   Threshold: 3600 seconds (1 hour)`);
+    console.log(`   Status: ${age > 3600 ? '❌ STALE' : '✅ Fresh'}`);
+}
+
+main().catch(console.error);

package/scripts/check-jason-status.ts

@@ -1,184 +1,85 @@
 
-import { createPublicClient, createWalletClient, http, parseAbi, keccak256, formatEther, parseEther, toBytes } from 'viem';
-import { privateKeyToAccount } from 'viem/accounts';
+import { createPublicClient, http, parseAbi, type Address, formatEther } from 'viem';
 import { sepolia } from 'viem/chains';
 import * as dotenv from 'dotenv';
-import * as fs from 'fs';
 import * as path from 'path';
+import { fileURLToPath } from 'url';
+import * as fs from 'fs';
 
-// Load env
-dotenv.config({ path: '.env.sepolia' });
-
-const CONFIG_PATH = path.resolve(process.cwd(), 'config.sepolia.json');
-const STATE_PATH = path.resolve(process.cwd(), 'scripts/l4-state.json');
-
-// ABIs
-const REGISTRY_ABI = parseAbi([
-    'function hasRole(bytes32 roleId, address user) view returns (bool)',
-    'function roleMetadata(bytes32 roleId, address user) view returns (bytes)',
-    'function registerRole(bytes32 roleId, address user, bytes roleData)',
-    'function registerRoleSelf(bytes32 roleId, bytes roleData)'
-]);
-
-const FACTORY_ABI = parseAbi([
-    'function getTokenAddress(address community) view returns (address)',
-    'function deployxPNTsToken(string name, string symbol, string communityName, string communityENS, uint256 exchangeRate, address paymasterAOA) returns (address)'
-]);
-
-const TOKEN_ABI = parseAbi([
-    'function name() view returns (string)',
-    'function symbol() view returns (string)'
-]);
-
-const ROLE_COMMUNITY = keccak256(toBytes('COMMUNITY'));
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+dotenv.config({ path: path.resolve(__dirname, '../.env.sepolia') });
 
 async function main() {
-    console.log('🔍 Checking Jason Account Status...');
-
-    // 1. Load Config & State
-    const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
-    const state = JSON.parse(fs.readFileSync(STATE_PATH, 'utf8'));
-
-    // Jason's Address
-    const jasonAddress = state.operators.jason.address;
-    const jasonKey = process.env.PRIVATE_KEY_JASON;
-    
-    if (!jasonAddress || !jasonKey) {
-        throw new Error('Jason address or private key not found');
-    }
-
-    console.log(`👤 Jason Address: ${jasonAddress}`);
+    const statePath = path.resolve(__dirname, '../scripts/l4-state.json');
+    const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
 
-    // Clients
-    const client = createPublicClient({ chain: sepolia, transport: http(process.env.RPC_URL) });
-    const wallet = createWalletClient({ 
-        account: privateKeyToAccount(jasonKey as `0x${string}`), 
-        chain: sepolia, 
-        transport: http(process.env.RPC_URL) 
+    const rpcUrl = process.env.SEPOLIA_RPC_URL || process.env.RPC_URL;
+    const client = createPublicClient({
+        chain: sepolia,
+        transport: http(rpcUrl)
     });
 
-    const registryAddr = config.registry;
-    const factoryAddr = config.xPNTsFactory;
+    const epAddr = '0x0000000071727De22E5E9d8BAf0edAc6f37da032' as Address;
 
-    // 2. Check Registry Role
-    console.log('\n🏛️  Checking Registry Status...');
-    const hasRole = await client.readContract({
-        address: registryAddr,
-        abi: REGISTRY_ABI,
-        functionName: 'hasRole',
-        args: [ROLE_COMMUNITY, jasonAddress]
-    });
+    for (const [name, op] of Object.entries(state.operators)) {
+        const o: any = op;
+        if (!o.paymasterV4 || o.paymasterV4 === 'N/A (Super)' || o.paymasterV4 === 'None') continue;
 
-    if (hasRole) {
-        console.log('✅ Jason IS registered as COMMUNITY.');
-        // Try to decode metadata (simple string decode for name if possible, complex decode is hard without full ABI)
-        // We'll skip metadata decoding for now unless critical
-    } else {
-        console.log('❌ Jason is NOT registered as COMMUNITY.');
-        console.log('🛠️  Attempting to register Jason as Community...');
+        console.log(`\n🔍 Checking Paymaster Status for ${name.toUpperCase()}...`);
+        console.log(`🏦 Paymaster: ${o.paymasterV4}`);
         
-        try {
-             // Encode RoleData: (name, ens, website, desc, logo, stake)
-             // string, string, string, string, string, uint256
-             // We use 'viem' encodeAbiParameters
-             const { encodeAbiParameters, parseAbiParameters } = await import('viem');
-             
-             const roleData = encodeAbiParameters(
-                parseAbiParameters('string, string, string, string, string, uint256'),
-                ['Jason Community', '', 'https://jason.com', 'Jason Tech Community', '', 30000000000000000000n] // 30 GTokens
-             );
-
-             // Note: This requires Jason to have GTokens and Approve Staking!
-             // Assuming Jason has enough GTokens (he usually does in tests)
-             // We need to approve Staking first
-             const STAKING = config.gTokenStaking;
-             const GTOKEN = config.gToken;
-
-             console.log('   Approving Staking...');
-             const approveHash = await wallet.writeContract({
-                 address: GTOKEN,
-                 abi: parseAbi(['function approve(address,uint256) returns (bool)']),
-                 functionName: 'approve',
-                 args: [STAKING, parseEther('1000')] // Plenty
-             });
-             await client.waitForTransactionReceipt({ hash: approveHash });
-             console.log('   ✅ Approved.');
-
-             console.log('   Registering Community...');
-             const txHash = await wallet.writeContract({
-                 address: registryAddr,
-                 abi: REGISTRY_ABI,
-                 functionName: 'registerRoleSelf',
-                 args: [ROLE_COMMUNITY, roleData]
-             });
-             await client.waitForTransactionReceipt({ hash: txHash });
-             console.log(`   ✅ Community Registered! Tx: ${txHash}`);
-        } catch (e: any) {
-            console.error(`   ❌ Registration Failed: ${e.message}`);
-            return;
+        const aaMatch = state.aaAccounts.find((a: any) => a.opName.toLowerCase().includes(name.toLowerCase()));
+        if (!aaMatch) {
+            console.log(`❌ No AA account found for operator ${name}`);
+            continue;
         }
-    }
+        const aaAddr = aaMatch.address;
+        const tokenAddr = o.tokenAddress;
 
-    // 3. Check xPNTs Token
-    console.log('\n🪙  Checking xPNTs Token Status...');
-    const tokenAddr = await client.readContract({
-        address: factoryAddr,
-        abi: FACTORY_ABI,
-        functionName: 'getTokenAddress',
-        args: [jasonAddress]
-    });
-
-    if (tokenAddr && tokenAddr !== '0x0000000000000000000000000000000000000000') {
-        const [name, symbol] = await Promise.all([
-            client.readContract({ address: tokenAddr, abi: TOKEN_ABI, functionName: 'name' }),
-            client.readContract({ address: tokenAddr, abi: TOKEN_ABI, functionName: 'symbol' })
-        ]);
-        console.log(`✅ Jason has Token: ${tokenAddr}`);
-        console.log(`   Name: ${name}`);
-        console.log(`   Symbol: ${symbol}`);
-        
-        if (symbol === 'dPNTs' || symbol.includes('cPNTs')) {
-            console.log(`   ℹ️  Note: "dPNTs (cPNTs)" confusion likely due to symbol naming.`);
-        }
-    } else {
-        console.log('❌ Jason has NO Token deployed.');
-        console.log('🛠️  Deploying Token for Jason...');
+        console.log(`👤 AA Account: ${aaAddr}`);
+        console.log(`🪙  Token:      ${tokenAddr} (${o.symbol})`);
 
         try {
-            // function deployxPNTsToken(string name, string symbol, string communityName, string communityENS, uint256 exchangeRate, address paymasterAOA)
-            const txHash = await wallet.writeContract({
-                address: factoryAddr,
-                abi: FACTORY_ABI,
-                functionName: 'deployxPNTsToken',
-                args: [
-                    'Jason Community Token',
-                    'cPNTs', // Let's use cPNTs to curb confusion
-                    'Jason Community',
-                    '',
-                    parseEther('1'), // 1:1 Exchange Rate
-                    state.operators.jason.paymasterV4 // Link to his AOA Paymaster
-                ]
+            // 1. EntryPoint
+            const pmEntryPoint = await client.readContract({
+                address: o.paymasterV4,
+                abi: parseAbi(['function entryPoint() view returns (address)']),
+                functionName: 'entryPoint'
             });
-            console.log(`   🚀 Use deploy tx: ${txHash}`);
-            const receipt = await client.waitForTransactionReceipt({ hash: txHash });
-            console.log(`   ✅ Token Deployed!`);
+            console.log(`⚙️  EntryPoint:  ${pmEntryPoint.toLowerCase() === epAddr.toLowerCase() ? '✅ Matches' : '❌ MISMATCH (' + pmEntryPoint + ')'}`);
+
+            // 2. Token Price
+            const tokenPrice = await client.readContract({
+                address: o.paymasterV4,
+                abi: parseAbi(['function tokenPrices(address) view returns (uint256)']),
+                functionName: 'tokenPrices',
+                args: [tokenAddr]
+            }) as bigint;
+            console.log(`💰 Token Price: ${tokenPrice > 0n ? '✅ ' + tokenPrice : '❌ NOT SET'}`);
+
+            // 3. AA Internal Balance
+            const internalBalance = await client.readContract({
+                address: o.paymasterV4,
+                abi: parseAbi(['function balances(address,address) view returns (uint256)']),
+                functionName: 'balances',
+                args: [aaAddr, tokenAddr]
+            }) as bigint;
+            console.log(`💳 AA Balance:  ${internalBalance > 0n ? '✅ ' + formatEther(internalBalance) : '❌ ZERO'} ${o.symbol}`);
+
+            // 4. EP Balance
+            const epBalance = await client.readContract({
+                address: epAddr,
+                abi: parseAbi(['function balanceOf(address) view returns (uint256)']),
+                functionName: 'balanceOf',
+                args: [o.paymasterV4]
+            }) as bigint;
+            console.log(`⛽ EP Balance:  ${Number(epBalance) / 1e18} ETH`);
 
-            // Read the new token address? 
-            // We can just rely on user re-running check, or fetch it again.
-            // Let's fetch it for verification.
-            const newToken = await client.readContract({
-                address: factoryAddr,
-                abi: FACTORY_ABI,
-                functionName: 'getTokenAddress',
-                args: [jasonAddress]
-            });
-            console.log(`   📍 New Token Address: ${newToken}`);
         } catch (e: any) {
-            console.error(`   ❌ Deployment Failed: ${e.message}`);
+            console.error(`❌ Error checking ${name}:`, e.message);
         }
     }
-
-    console.log('\n🏁 Done.');
 }
 
-main().catch(console.error);
+main();