@aastar/sdk 0.14.3 → 0.16.6

package/scripts/check-admin.ts

@@ -0,0 +1,95 @@
+
+import { createPublicClient, http, parseAbi, type Address } from 'viem';
+import { sepolia } from 'viem/chains';
+import { privateKeyToAccount } from 'viem/accounts';
+import * as dotenv from 'dotenv';
+import { loadNetworkConfig } from '../tests/regression/config.js';
+
+dotenv.config({ path: '.env.sepolia' });
+
+async function main() {
+    const config = loadNetworkConfig('sepolia');
+    const publicClient = createPublicClient({ chain: sepolia, transport: http(config.rpcUrl) });
+    const registryAddr = config.contracts.registry;
+
+    console.log(`\n🔍 Checking Permissions for Registry: ${registryAddr}`);
+
+    // --- 1. Identify Candidate Keys ---
+    const keysToCheck: { name: string, account: any }[] = [];
+    
+    // Add explicitly named keys first for clarity
+    if (process.env.PRIVATE_KEY) keysToCheck.push({ name: 'PRIVATE_KEY', account: privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`) });
+    
+    for (const [key, value] of Object.entries(process.env)) {
+        if (key.startsWith('PRIVATE_KEY') && value && value.startsWith('0x')) {
+            try {
+                const acct = privateKeyToAccount(value as `0x${string}`);
+                // Avoid duplicates
+                if (!keysToCheck.find(k => k.account.address === acct.address)) {
+                    keysToCheck.push({ name: key, account: acct });
+                }
+            } catch (e) {
+                // Ignore parsing errors for non-keys
+            }
+        }
+    }
+    console.log(`   Found ${keysToCheck.length} candidate keys in .env.sepolia`);
+    keysToCheck.forEach(k => console.log(`   - ${k.name.padEnd(20)}: ${k.account.address}`));
+
+    const registryAbi = parseAbi([
+        'function hasRole(bytes32 role, address account) view returns (bool)',
+        'function DEFAULT_ADMIN_ROLE() view returns (bytes32)',
+        'function owner() view returns (address)'
+    ]);
+
+    // --- 2. Check DEFAULT_ADMIN_ROLE (0x00...00) ---
+    const DEFAULT_ADMIN = '0x0000000000000000000000000000000000000000000000000000000000000000' as `0x${string}`;
+    console.log(`\n👑 Checking DEFAULT_ADMIN_ROLE (0x00...00):`);
+    
+    let adminFound = false;
+
+    for (const k of keysToCheck) {
+        try {
+            const isAdmin = await publicClient.readContract({
+                address: registryAddr, abi: registryAbi, functionName: 'hasRole', args: [DEFAULT_ADMIN, k.account.address]
+            });
+            
+            if (isAdmin) {
+                console.log(`   ✅ MATCH! ${k.name} IS AN ADMIN!`);
+                adminFound = true;
+            } else {
+                console.log(`     ${k.name.padEnd(20)}: ❌ NO`);
+            }
+        } catch (e: any) {
+             console.log(`     ${k.name.padEnd(20)}: ⚠️ Error (Revert?) - ${e.shortMessage || e.message}`);
+        }
+    }
+
+    // --- 3. Check Owner (Fallback) ---
+    console.log(`\n🏠 Checking Contract Owner:`);
+    try {
+        const owner = await publicClient.readContract({
+            address: registryAddr, abi: registryAbi, functionName: 'owner'
+        });
+        console.log(`   Registry Owner Address: ${owner}`);
+        
+        const keyOwner = keysToCheck.find(k => k.account.address === owner);
+        if (keyOwner) {
+            console.log(`   ✅ MATCH! ${keyOwner.name} IS THE OWNER!`);
+            adminFound = true;
+        } else {
+             console.log(`   ❌ No match in provided keys.`);
+        }
+    } catch (e: any) {
+        console.log(`   ⚠️ 'owner()' function not supported or reverted.`);
+    }
+
+    if (!adminFound) {
+        console.log(`\n🚨 DIAGNOSTIC RESULT: NO ADMIN KEYS FOUND.`);
+        console.log(`   The Registry at ${registryAddr} is not controlled by any key in .env.sepolia.`);
+    } else {
+        console.log(`\n✅ DIAGNOSTIC RESULT: ADMIN KEY FOUND!`);
+    }
+}
+
+main().catch(console.error);

package/scripts/check-jason-status.ts

@@ -0,0 +1,184 @@
+
+import { createPublicClient, createWalletClient, http, parseAbi, keccak256, formatEther, parseEther, toBytes } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { sepolia } from 'viem/chains';
+import * as dotenv from 'dotenv';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// 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'));
+
+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}`);
+
+    // 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 registryAddr = config.registry;
+    const factoryAddr = config.xPNTsFactory;
+
+    // 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]
+    });
+
+    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...');
+        
+        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;
+        }
+    }
+
+    // 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...');
+
+        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
+                ]
+            });
+            console.log(`   🚀 Use deploy tx: ${txHash}`);
+            const receipt = await client.waitForTransactionReceipt({ hash: txHash });
+            console.log(`   ✅ Token Deployed!`);
+
+            // 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.log('\n🏁 Done.');
+}
+
+main().catch(console.error);

package/scripts/check-roles.ts

@@ -0,0 +1,36 @@
+import { createPublicClient, http } from 'viem';
+import { loadNetworkConfig } from '../tests/regression/config.js';
+import { registryActions } from '../packages/core/dist/index.js';
+import * as dotenv from 'dotenv';
+
+dotenv.config({ path: '.env.sepolia' });
+
+async function checkRoles() {
+    const config = loadNetworkConfig('sepolia');
+    const client = createPublicClient({
+        chain: config.chain,
+        transport: http(config.rpcUrl)
+    });
+
+    const registry = registryActions(config.contracts.registry);
+    const ROLE_COMMUNITY = await registry(client).ROLE_COMMUNITY();
+    const ROLE_PAYMASTER_SUPER = await registry(client).ROLE_PAYMASTER_SUPER();
+
+    const jason = '0xb5600060e6de5E11D3636731964218E53caadf0E';
+    const bob = '0xF7Bf79AcB7F3702b9DbD397d8140ac9DE6Ce642C';
+    const anni = '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC';
+
+    console.log('\n📋 Role Status Check\n');
+    console.log('Jason:');
+    console.log(`  ROLE_COMMUNITY: ${await registry(client).hasRole({ user: jason, roleId: ROLE_COMMUNITY })}`);
+    console.log(`  ROLE_PAYMASTER_SUPER: ${await registry(client).hasRole({ user: jason, roleId: ROLE_PAYMASTER_SUPER })}`);
+    
+    console.log('\nBob:');
+    console.log(`  ROLE_COMMUNITY: ${await registry(client).hasRole({ user: bob, roleId: ROLE_COMMUNITY })}`);
+    
+    console.log('\nAnni:');
+    console.log(`  ROLE_COMMUNITY: ${await registry(client).hasRole({ user: anni, roleId: ROLE_COMMUNITY })}`);
+    console.log(`  ROLE_PAYMASTER_SUPER: ${await registry(client).hasRole({ user: anni, roleId: ROLE_PAYMASTER_SUPER })}`);
+}
+
+checkRoles().catch(console.error);

package/scripts/clear-nonce.ts

@@ -0,0 +1,47 @@
+import { createWalletClient, http, parseEther, createPublicClient } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { sepolia } from 'viem/chains';
+import dotenv from 'dotenv';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+dotenv.config({ path: path.resolve(__dirname, '../.env.sepolia') });
+
+async function clearNonce() {
+    const pk = process.env.PRIVATE_KEY_SUPPLIER;
+    if (!pk) throw new Error("No PK");
+    
+    const account = privateKeyToAccount(pk as `0x${string}`);
+    const client = createWalletClient({
+        account,
+        chain: sepolia,
+        transport: http(process.env.RPC_URL)
+    });
+    
+    const publicClient = createPublicClient({
+        chain: sepolia,
+        transport: http(process.env.RPC_URL)
+    });
+
+    const nonce = 1716;
+    console.log(`🚀 Sending NOP for nonce ${nonce} from ${account.address}...`);
+    
+    // Get current gas price and boost it
+    const gasPrice = await publicClient.getGasPrice();
+    const boostedGasPrice = (gasPrice * 150n) / 100n;
+    
+    const hash = await client.sendTransaction({
+        to: account.address,
+        value: 0n,
+        nonce,
+        gasPrice: boostedGasPrice,
+    });
+    
+    console.log(`✅ NOP Sent: ${hash}`);
+    console.log(`⏳ Waiting for confirmation...`);
+    await publicClient.waitForTransactionReceipt({ hash });
+    console.log(`🎉 Nonce ${nonce} cleared!`);
+}
+
+clearNonce().catch(console.error);

package/scripts/complete-jack-superpaymaster.ts

@@ -0,0 +1,171 @@
+import { createPublicClient, createWalletClient, http, parseEther, type Hex } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { loadNetworkConfig } from '../tests/regression/config.js';
+import { tokenActions, registryActions, superPaymasterActions } from '../packages/core/dist/index.js';
+import * as dotenv from 'dotenv';
+import * as fs from 'fs';
+import * as path from 'path';
+
+dotenv.config({ path: '.env.sepolia' });
+
+const STATE_FILE = path.resolve(process.cwd(), 'scripts/l4-state.json');
+
+async function completeJackSuperPaymasterSetup() {
+    const config = loadNetworkConfig('sepolia');
+    const publicClient = createPublicClient({
+        chain: config.chain,
+        transport: http(config.rpcUrl)
+    });
+
+    const keyJack = process.env.PRIVATE_KEY_JACK as Hex;
+    const jack = privateKeyToAccount(keyJack);
+    const clientJack = createWalletClient({
+        chain: config.chain,
+        transport: http(config.rpcUrl),
+        account: jack
+    });
+
+    console.log('\n🦸 Completing Jack\'s SuperPaymaster Setup\n');
+    console.log(`Jack: ${jack.address}\n`);
+
+    const registry = registryActions(config.contracts.registry);
+    const gToken = tokenActions();
+
+    // Step 1: Register ROLE_PAYMASTER_SUPER
+    console.log('📝 Step 1: Registering ROLE_PAYMASTER_SUPER...');
+    const ROLE_PAYMASTER_SUPER = await registry(publicClient).ROLE_PAYMASTER_SUPER();
+    
+    const hasSuper = await registry(publicClient).hasRole({
+        user: jack.address,
+        roleId: ROLE_PAYMASTER_SUPER
+    });
+    
+    if (!hasSuper) {
+        try {
+            // Check GToken balance
+            const balance = await gToken(publicClient).balanceOf({
+                token: config.contracts.gToken,
+                account: jack.address
+            });
+            console.log(`  Jack's GToken: ${Number(balance) / 1e18} tokens`);
+            
+            const requiredStake = parseEther('50'); // SuperPaymaster requires 50 GToken
+            if (balance < requiredStake) {
+                console.log(`  ⚠️  Insufficient GToken! Need ${Number(requiredStake) / 1e18}, have ${Number(balance) / 1e18}`);
+                
+                // Mint more GToken
+                const supplier = privateKeyToAccount(process.env.PRIVATE_KEY_SUPPLIER as Hex);
+                const clientSupplier = createWalletClient({
+                    chain: config.chain,
+                    transport: http(config.rpcUrl),
+                    account: supplier
+                });
+                
+                const mintAmount = requiredStake - balance + parseEther('20'); // Extra 20 for deposit
+                console.log(`  💰 Minting ${Number(mintAmount) / 1e18} GToken to Jack...`);
+                const mintHash = await gToken(clientSupplier).mint({
+                    token: config.contracts.gToken,
+                    to: jack.address,
+                    amount: mintAmount,
+                    account: supplier
+                });
+                await publicClient.waitForTransactionReceipt({ hash: mintHash });
+                console.log(`  ✅ Minted`);
+            }
+            
+            // Approve GToken to GTokenStaking
+            const allowance = await gToken(publicClient).allowance({
+                token: config.contracts.gToken,
+                owner: jack.address,
+                spender: config.contracts.gTokenStaking
+            });
+            
+            if (allowance < requiredStake) {
+                console.log(`  📝 Approving GToken to GTokenStaking...`);
+                const approveHash = await gToken(clientJack).approve({
+                    token: config.contracts.gToken,
+                    spender: config.contracts.gTokenStaking,
+                    amount: requiredStake * BigInt(2),
+                    account: jack
+                });
+                await publicClient.waitForTransactionReceipt({ hash: approveHash });
+                console.log(`  ✅ Approved`);
+            }
+            
+            // Register role
+            console.log(`  📝 Calling registerRoleSelf...`);
+            const registerHash = await registry(clientJack).registerRoleSelf({
+                roleId: ROLE_PAYMASTER_SUPER,
+                data: '0x',
+                account: jack
+            });
+            await publicClient.waitForTransactionReceipt({ hash: registerHash });
+            console.log(`  ✅ ROLE_PAYMASTER_SUPER granted!`);
+        } catch (e: any) {
+            console.log(`  ❌ Error: ${e.message.split('\n')[0]}`);
+            throw e;
+        }
+    } else {
+        console.log(`  ✅ Already has ROLE_PAYMASTER_SUPER`);
+    }
+
+    // Step 2: Deposit to SuperPaymaster
+    console.log('\n💰 Step 2: Depositing to SuperPaymaster...');
+    const superPaymaster = superPaymasterActions(config.contracts.superPaymaster);
+    
+    try {
+        const currentDeposit = await superPaymaster(publicClient).getOperatorDeposit({ operator: jack.address });
+        console.log(`  Current deposit: ${Number(currentDeposit) / 1e18} GToken`);
+        
+        const depositAmount = parseEther('20');
+        console.log(`  Depositing ${Number(depositAmount) / 1e18} GToken...`);
+        
+        // Approve SuperPaymaster to spend GToken
+        const allowance = await gToken(publicClient).allowance({
+            token: config.contracts.gToken,
+            owner: jack.address,
+            spender: config.contracts.superPaymaster
+        });
+        
+        if (allowance < depositAmount) {
+            const approveHash = await gToken(clientJack).approve({
+                token: config.contracts.gToken,
+                spender: config.contracts.superPaymaster,
+                amount: depositAmount,
+                account: jack
+            });
+            await publicClient.waitForTransactionReceipt({ hash: approveHash });
+        }
+        
+        // Deposit
+        const depositHash = await superPaymaster(clientJack).depositCollateral({
+            amount: depositAmount,
+            account: jack
+        });
+        await publicClient.waitForTransactionReceipt({ hash: depositHash });
+        
+        const newDeposit = await superPaymaster(publicClient).getOperatorDeposit({ operator: jack.address });
+        console.log(`  ✅ Deposited! New balance: ${Number(newDeposit) / 1e18} GToken`);
+    } catch (e: any) {
+        console.log(`  ❌ Deposit error: ${e.message.split('\n')[0]}`);
+    }
+
+    // Update state
+    console.log('\n💾 Updating state...');
+    const state = JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+    if (!state.jack) state.jack = {};
+    state.jack.superPaymasterAddress = config.contracts.superPaymaster;
+    state.jack.roles = ['ROLE_COMMUNITY', 'ROLE_PAYMASTER_SUPER'];
+    fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+    
+    console.log('\n🎉 Jack\'s SuperPaymaster Setup Complete!\n');
+    console.log('Summary:');
+    console.log(`  Owner: Jack (${jack.address})`);
+    console.log(`  Community: Dancing`);
+    console.log(`  Token (dPNTs): ${state.jack.tokenAddress}`);
+    console.log(`  Roles: ROLE_COMMUNITY ✅, ROLE_PAYMASTER_SUPER ✅`);
+    console.log(`  SuperPaymaster: ${config.contracts.superPaymaster} ✅`);
+    console.log('\n✨ Jack can now sponsor gasless transactions for Dancing Community users!');
+}
+
+completeJackSuperPaymasterSetup().catch(console.error);

package/scripts/debug-addr.ts

@@ -0,0 +1,43 @@
+import { privateKeyToAccount } from 'viem/accounts';
+import * as dotenv from 'dotenv';
+import * as path from 'path';
+
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+async function check() {
+    const envPath = path.resolve(__dirname, '../.env.sepolia');
+    dotenv.config({ path: envPath });
+    
+    const pk = process.env.PRIVATE_KEY_SUPPLIER;
+    const pkJason = process.env.PRIVATE_KEY_JASON;
+    
+    if (pk) {
+        const account = privateKeyToAccount(pk as `0x${string}`);
+        console.log(`Supplier Address: ${account.address}`);
+    }
+    
+    if (pkJason) {
+        const accountJason = privateKeyToAccount(pkJason as `0x${string}`);
+        console.log(`Jason Address:    ${accountJason.address}`);
+    }
+
+    const token = '0x60dDD2b4BEb69d9760bBF90e05C34A716736840D';
+    // Use public client to check owner
+    const { createPublicClient, http } = await import('viem');
+    const { sepolia } = await import('viem/chains');
+    const client = createPublicClient({ chain: sepolia, transport: http('https://ethereum-sepolia-rpc.publicnode.com') });
+    
+    try {
+        const owner = await client.readContract({
+            address: token as `0x${string}`,
+            abi: [{ type: 'function', name: 'owner', inputs: [], outputs: [{ type: 'address' }] }],
+            functionName: 'owner'
+        });
+        console.log(`Token Owner:     ${owner}`);
+    } catch (e) {
+        console.log("Failed to fetch owner via viem, check if contract is Ownable");
+    }
+}
+
+check();

package/scripts/debug-community-registration.ts

@@ -0,0 +1,92 @@
+import { createPublicClient, createWalletClient, http, parseEther, encodeAbiParameters, parseAbiParameters, type Hex } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { loadNetworkConfig } from '../tests/regression/config.js';
+import { registryActions, tokenActions } from '../packages/core/dist/index.js';
+import * as dotenv from 'dotenv';
+
+dotenv.config({ path: '.env.sepolia' });
+
+async function debugCommunityRegistration() {
+    const config = loadNetworkConfig('sepolia');
+    const publicClient = createPublicClient({
+        chain: config.chain,
+        transport: http(config.rpcUrl)
+    });
+
+    // Bob's account
+    const keyBob = process.env.PRIVATE_KEY_BOB as Hex;
+    const bob = privateKeyToAccount(keyBob);
+    const clientBob = createWalletClient({
+        chain: config.chain,
+        transport: http(config.rpcUrl),
+        account: bob
+    });
+
+    const registry = registryActions(config.contracts.registry);
+    const gToken = tokenActions();
+
+    console.log('\n🔍 Debugging Community Registration for Bob\n');
+    console.log(`Bob Address: ${bob.address}`);
+
+    // Check Bob's GToken balance
+    const balance = await gToken(publicClient).balanceOf({
+        token: config.contracts.gToken,
+        account: bob.address
+    });
+    console.log(`Bob GToken Balance: ${balance / BigInt(1e18)} tokens`);
+
+    // Check allowance
+    const allowance = await gToken(publicClient).allowance({
+        token: config.contracts.gToken,
+        owner: bob.address,
+        spender: config.contracts.registry
+    });
+    console.log(`Bob Allowance to Registry: ${allowance / BigInt(1e18)} tokens`);
+
+    // Get ROLE_COMMUNITY
+    const ROLE_COMMUNITY = await registry(publicClient).ROLE_COMMUNITY();
+    console.log(`ROLE_COMMUNITY: ${ROLE_COMMUNITY}`);
+
+    // Check if Bob already has role
+    const hasRole = await registry(publicClient).hasRole({
+        user: bob.address,
+        roleId: ROLE_COMMUNITY
+    });
+    console.log(`Bob has ROLE_COMMUNITY: ${hasRole}`);
+
+    if (!hasRole) {
+        // Encode CommunityRoleData
+        const communityData = encodeAbiParameters(
+            parseAbiParameters('string, string, string, string, string, uint256'),
+            [
+                'Bread', // Community name
+                '', // ensName (optional)
+                '', // website (optional)
+                'Bread Community', // description
+                '', // logoURI (optional)
+                parseEther('30') // stakeAmount (30 GToken)
+            ]
+        );
+        console.log(`\nEncoded Community Data: ${communityData}`);
+
+        // Try to register with detailed error
+        console.log('\n📝 Attempting registerRoleSelf...');
+        try {
+            const hash = await registry(clientBob).registerRoleSelf({
+                roleId: ROLE_COMMUNITY,
+                data: communityData,
+                account: bob
+            });
+            await publicClient.waitForTransactionReceipt({ hash });
+            console.log('✅ Registration successful!');
+            console.log(`Transaction: ${hash}`);
+        } catch (e: any) {
+            console.log(`❌ Registration failed:`);
+            console.log(`Error message: ${e.message}`);
+            console.log(`\nFull error:`);
+            console.log(e);
+        }
+    }
+}
+
+debugCommunityRegistration().catch(console.error);