@aastar/sdk 0.14.3 → 0.16.6

package/packages/sdk/src/clients/community.ts

@@ -11,23 +11,27 @@ import {
     type PublicActions,
     type WalletActions,
     type Address,
-    keccak256,
-    stringToBytes,
-    erc20Abi
 } from 'viem';
 
 import { 
     registryActions, 
-    RegistryABI, 
+    RegistryABI,
+    xPNTsFactoryABI, 
     sbtActions,
+    reputationActions,
     type RegistryActions,
     type SBTActions,
+    type ReputationActions,
     CORE_ADDRESSES,
-    TEST_TOKEN_ADDRESSES
+    TEST_TOKEN_ADDRESSES,
+    validateAddress
 } from '@aastar/core';
+import { AAStarError, AAStarErrorCode as AAStarErrorType, createError } from '../errors/AAStarError.js';
 import { RoleDataFactory, RoleIds } from '../utils/roleData.js';
+import { decodeContractError } from '../errors/decoder.js';
+import { decodeContractEvents, logDecodedEvents, type DecodedEvent } from '../utils/eventDecoder.js';
 
-export type CommunityClient = Client<Transport, Chain, Account | undefined> & PublicActions<Transport, Chain, Account | undefined> & WalletActions<Chain, Account | undefined> & RegistryActions & SBTActions & {
+export type CommunityClient = Client<Transport, Chain, Account | undefined> & PublicActions<Transport, Chain, Account | undefined> & WalletActions<Chain, Account | undefined> & RegistryActions & SBTActions & ReputationActions & {
     /**
      * Query community registration status and token information
      * Returns null if not registered, otherwise returns community details
@@ -52,9 +56,14 @@ export type CommunityClient = Client<Transport, Chain, Account | undefined> & Pu
         description?: string;
         logoURI?: string;
         website?: string;
-    }) => Promise<{ tokenAddress: Address; txs: Hex[] }>;
+        governance?: {
+            minStake?: bigint;
+            initialReputationRule?: boolean;
+        }
+    }) => Promise<{ tokenAddress: Address; results: { hash: Hash, events: DecodedEvent[] }[] }>;
 };
 
+
 export function createCommunityClient({ 
     chain, 
     transport, 
@@ -78,6 +87,8 @@ export function createCommunityClient({
 
     const registryActionsObj = registryActions(usedAddresses.registry)(client as any);
     const sbtActionsObj = sbtActions(usedAddresses.mySBT)(client as any);
+    const reputationActionsObj = reputationActions(usedAddresses.reputationSystem)(client as any);
+
 
     const launch = async (args: {
         name: string;
@@ -86,144 +97,75 @@ export function createCommunityClient({
         description?: string;
         logoURI?: string;
         website?: string;
-    }): Promise<{ tokenAddress: Address; txs: Hex[] }> => {
-        try {
-            console.log(`🚀 Launching community: ${args.name}`);
-            
-            if (!account) {
-                throw new Error('Account is required for launch()');
-            }
+        governance?: {
+            minStake?: bigint;
+            initialReputationRule?: boolean;
+        }
+    }) => {
+        if (!account) throw createError.validation("Account", "Account required for launch");
+        
+        // Input Validation
+        if (!args.name) throw new AAStarError("Community Name is required", AAStarErrorType.VALIDATION_ERROR);
+        if (args.name.length > 50) throw new AAStarError("Community Name must be ≤ 50 characters", AAStarErrorType.VALIDATION_ERROR);
+        if (!args.tokenName) throw new AAStarError("Token Name is required", AAStarErrorType.VALIDATION_ERROR);
+        if (args.tokenName.length > 50) throw new AAStarError("Token Name must be ≤ 50 characters", AAStarErrorType.VALIDATION_ERROR);
+        if (!args.tokenSymbol) throw new AAStarError("Token Symbol is required", AAStarErrorType.VALIDATION_ERROR);
+        if (args.tokenSymbol.length > 10) throw new AAStarError("Token Symbol must be ≤ 10 characters", AAStarErrorType.VALIDATION_ERROR);
+
+        const results: { hash: Hash, events: DecodedEvent[] }[] = [];
+        let tokenAddress: Address = '0x0000000000000000000000000000000000000000';
 
-            // Generate unique community name with timestamp
-            const uniqueName = `${args.name}_${Date.now()}`;
-            console.log(`   📝 Unique name: ${uniqueName}`);
+        try {
+            console.log(`🚀 Launching Community "${args.name}"...`);
 
-            // Generate roleData using RoleDataFactory
-            const roleData = RoleDataFactory.community({
-                name: uniqueName,
+            // 1. Register Role (Community)
+            // Using helper logic to reuse data encoding
+            const communityRoleData = {
+                name: args.name,
                 ensName: '',
                 website: args.website || '',
                 description: args.description || '',
                 logoURI: args.logoURI || '',
-                stakeAmount: 0n
-            });
-            console.log(`   ✅ RoleData generated:`, roleData);
-            console.log(`   📊 RoleData type:`, typeof roleData);
-            console.log(`   📏 RoleData length:`, roleData?.length);
-
-            // 1. Check if already has role
-            const hasRole = await client.readContract({
-                address: usedAddresses.registry,
-                abi: RegistryABI,
-                functionName: 'hasRole',
-                args: [RoleIds.COMMUNITY, account.address]
-            }) as boolean;
+                stakeAmount: args.governance?.minStake || 0n
+            };
 
-            let registerTx: Hex | undefined;
+            const roleDataHex = RoleDataFactory.community(communityRoleData);
+            
+            // Register Role (with idempotent check)
+            console.log('   Registry: Checking Role...');
+            const hasRole = await registryActionsObj.registryHasRole({
+                user: account.address,
+                roleId: RoleIds.COMMUNITY
+            });
 
             if (hasRole) {
-                console.log(`   ℹ️  Account already has COMMUNITY role. Skipping registration.`);
+                console.log('   ✅ Role already registered, skipping.');
             } else {
-                // 2. Check GToken Allowance and Balance
-                if (usedAddresses.gToken && usedAddresses.gTokenStaking) {
-                    console.log(`   💰 Checking GToken allowance...`);
-                    const balance = await client.readContract({
-                        address: usedAddresses.gToken,
-                        abi: erc20Abi,
-                        functionName: 'balanceOf',
-                        args: [account.address]
-                    }) as bigint;
-
-                    if (balance < 50000000000000000000n) { // 50 GT assumption, should ideally check minStake
-                         console.warn(`   ⚠️ Warning: Low GToken balance (${balance}). Registration may fail if minStake > balance.`);
-                    }
-
-                    const allowance = await client.readContract({
-                        address: usedAddresses.gToken,
-                        abi: erc20Abi,
-                        functionName: 'allowance',
-                        args: [account.address, usedAddresses.gTokenStaking]
-                    }) as bigint;
-
-                    if (allowance < 50000000000000000000n) {
-                        console.log(`   🔓 Approving GToken for Staking...`);
-                        const approveTx = await client.writeContract({
-                            address: usedAddresses.gToken,
-                            abi: erc20Abi,
-                            functionName: 'approve',
-                            args: [usedAddresses.gTokenStaking, 115792089237316195423570985008687907853269984665640564039457584007913129639935n], // MaxUint256
-                            account: account
-                        });
-                        console.log(`   ✅ Approved: ${approveTx}`);
-                        await client.waitForTransactionReceipt({ hash: approveTx });
-                    }
-                }
-
-                // Register community role
-                console.log(`   📤 Registering community role...`);
+                console.log('   Registry: Registering Role...');
                 try {
-                    registerTx = await registryActionsObj.registerRole({
+                    const regTx = await registryActionsObj.registryRegisterRoleSelf({
                         roleId: RoleIds.COMMUNITY,
-                        user: account.address,
-                        data: roleData,
-                        account: account
+                        data: roleDataHex,
+                        account
                     });
-                    console.log(`   ✅ Community registered: ${registerTx}`);
+                    console.log(`   ✅ Registered: ${regTx}`);
+                    const receipt = await client.waitForTransactionReceipt({ hash: regTx });
+                    const events = decodeContractEvents(receipt.logs);
+                    logDecodedEvents(events);
+                    results.push({ hash: regTx, events });
                 } catch (e: any) {
-                     // Check for RoleAlreadyGranted (just in case hasRole returned false but race condition or cache)
-                     const isRoleError = e.message?.includes('RoleAlreadyGranted') || 
-                                        (e.cause as any)?.data?.errorName === 'RoleAlreadyGranted' ||
-                                        (e as any).name === 'RoleAlreadyGranted' || 
-                                        (e as any).name === 'RoleAlreadyGranted';
-
-                    if (isRoleError) {
-                        console.log(`   ℹ️  Role already granted (caught in tx). Skipping.`);
-                    } else {
-                        throw e;
-                    }
+                    // Fallback in case of race condition
+                    console.log('   ℹ️ Role registration check:', e.message || 'Already registered');
                 }
             }
 
-            // Deploy xPNTs token if factory is available
-            let tokenAddress: Address = '0x0000000000000000000000000000000000000000' as Address;
-            const txs: Hex[] = [];
-            if (registerTx) txs.push(registerTx);
-
+            // 2. Deploy xPNTs Token via Factory
             if (usedAddresses.xPNTsFactory) {
-                if (!client.account) {
-                    throw new Error("Client account is required for token deployment");
-                }
-
-                // ABI from xPNTsFactory.sol
-                const factoryAbi = [
-                    {
-                        type: 'function',
-                        name: 'deployxPNTsToken',
-                        inputs: [
-                            { name: 'name', type: 'string' },
-                            { name: 'symbol', type: 'string' },
-                            { name: 'communityName', type: 'string' },
-                            { name: 'communityENS', type: 'string' },
-                            { name: 'exchangeRate', type: 'uint256' },
-                            { name: 'paymasterAOA', type: 'address' }
-                        ],
-                        outputs: [{ name: 'token', type: 'address' }],
-                        stateMutability: 'nonpayable'
-                    },
-                    {
-                        type: 'function',
-                        name: 'getTokenAddress',
-                        inputs: [{ name: 'community', type: 'address' }],
-                        outputs: [{ name: 'token', type: 'address' }],
-                        stateMutability: 'view'
-                    }
-                ] as const;
-
-                // 1. Check if token already exists
+                // Check if token already exists
                 try {
                     const existingToken = await client.readContract({
                         address: usedAddresses.xPNTsFactory,
-                        abi: factoryAbi,
+                        abi: xPNTsFactoryABI,
                         functionName: 'getTokenAddress',
                         args: [account.address]
                     }) as Address;
@@ -231,82 +173,81 @@ export function createCommunityClient({
                     if (existingToken && existingToken !== '0x0000000000000000000000000000000000000000') {
                         console.log(`   ℹ️  Found existing token at ${existingToken}`);
                         tokenAddress = existingToken;
-                        // Return early or continue? Logic expects result.
-                        // If we found it, we don't need to deploy.
-                        return { tokenAddress, txs };
+                    } else {
+                        console.log(`   🏭 Deploying Token via Factory: ${usedAddresses.xPNTsFactory}`);
+                        
+                        // deployxPNTsToken(name, symbol, communityName, communityENS, exchangeRate, paymasterAOA)
+                        const { request } = await client.simulateContract({
+                            address: usedAddresses.xPNTsFactory,
+                            abi: xPNTsFactoryABI,
+                            functionName: 'deployxPNTsToken',
+                            args: [
+                                args.tokenName, 
+                                args.tokenSymbol, 
+                                args.name, // communityName
+                                args.website || '', // communityENS (mapping website to ENS param for now)
+                                1000000000000000000n, // exchangeRate 1e18 (1:1)
+                                '0x0000000000000000000000000000000000000000' // paymasterAOA (optional)
+                            ],
+                            account: client.account
+                        } as any);
+
+                        const deployTx = await client.writeContract(request as any);
+                        console.log(`   📤 Deploy Token Tx: ${deployTx}`);
+                        const receipt = await client.waitForTransactionReceipt({ hash: deployTx });
+                        const events = decodeContractEvents(receipt.logs);
+                        logDecodedEvents(events);
+                        results.push({ hash: deployTx, events });
+                        
+                        // After deployment, fetch the address again
+                        tokenAddress = await client.readContract({
+                            address: usedAddresses.xPNTsFactory,
+                            abi: xPNTsFactoryABI,
+                            functionName: 'getTokenAddress',
+                            args: [account.address]
+                        }) as Address;
+                        
+                        console.log(`   🪙 Token Deployed: ${tokenAddress}`);
                     }
                 } catch (e) {
-                    console.warn(`   ⚠️ Failed to check for existing token:`, e);
+                    console.warn(`   ⚠️ Token deployment step issues:`, e);
                 }
+            } else {
+                console.warn(`   ⚠️ xPNTsFactory address missing, skipping token deployment.`);
+            }
 
-                console.log(`   🏭 Deploying Token via Factory: ${usedAddresses.xPNTsFactory}`);
-                
+            // 3. Setup Governance (Reputation Rule) - Pattern logic
+            if (args.governance?.initialReputationRule) {
+                console.log('⚖️ Setting up Governance Rules...');
                 try {
-                    // deployxPNTsToken(name, symbol, communityName, communityENS, exchangeRate, paymasterAOA)
-                    const { request } = await client.simulateContract({
-                        address: usedAddresses.xPNTsFactory,
-                        abi: factoryAbi,
-                        functionName: 'deployxPNTsToken',
-                        args: [
-                            args.tokenName, 
-                            args.tokenSymbol, 
-                            args.name, // communityName
-                            args.website || '', // communityENS (mapping website to ENS param for now)
-                            1000000000000000000n, // exchangeRate 1e18 (1:1)
-                            '0x0000000000000000000000000000000000000000' // paymasterAOA (optional)
-                        ],
-                        account: client.account
-                    } as any);
-
-                    const deployTx = await client.writeContract(request as any);
-                    console.log(`   📤 Deploy Token Tx: ${deployTx}`);
-                    txs.push(deployTx);
-                    
-                    const receipt = await client.waitForTransactionReceipt({ hash: deployTx });
-                    
-                    // After deployment, fetch the address again
-                    const newTokenAddress = await client.readContract({
-                        address: usedAddresses.xPNTsFactory,
-                        abi: factoryAbi,
-                        functionName: 'getTokenAddress',
-                        args: [account.address]
-                    }) as Address;
-                    
-                    if (newTokenAddress) {
-                        tokenAddress = newTokenAddress;
-                        console.log(`   🪙 Token Deployed: ${tokenAddress}`);
-                    }
-
-                } catch (deployError) {
-                    console.warn('   ⚠️ Failed to deploy token, but community registered:', deployError);
+                    const ruleId = '0x0000000000000000000000000000000000000000000000000000000000000001' as Hex; // Default Rule ID 1
+                    const ruleConfig = {
+                        topic: '0x0000000000000000000000000000000000000000' as Address, // Topic 0
+                        weight: 100n,
+                        maxScore: 1000n,
+                        customData: '0x' as Hex
+                    };
+                    const govTx = await reputationActionsObj.setReputationRule({
+                        ruleId,
+                        rule: ruleConfig,
+                        account
+                    });
+                    console.log(`   ✅ Reputation Rule Set: ${govTx}`);
+                    const receipt = await client.waitForTransactionReceipt({ hash: govTx });
+                    const events = decodeContractEvents(receipt.logs);
+                    logDecodedEvents(events);
+                    results.push({ hash: govTx, events });
+                } catch (e) {
+                    console.warn('   ⚠️ Failed to set reputation rule:', e);
                 }
             }
 
-            return { tokenAddress, txs };
+            return { tokenAddress, results };
         } catch (error: any) {
-            console.error('❌ Error in launch():', error);
-            
-            // 检查是否是 RoleAlreadyGranted 错误
-            const errorMessage = error.message || '';
-            const errorData = error.data?.errorName || '';
-            const errorString = JSON.stringify(error);
-            
-            if (errorMessage.includes('RoleAlreadyGranted') || 
-                errorData === 'RoleAlreadyGranted' ||
-                errorString.includes('RoleAlreadyGranted')) {
-                throw new Error(`Account ${account?.address || 'unknown'} already has COMMUNITY role. Please use a different account or exit the role first.`);
-            }
-            
-            // 检查其他常见错误
-            if (errorMessage.includes('InsufficientStake')) {
-                throw new Error('Insufficient stake. Please ensure you have enough GToken staked.');
-            }
-            
-            if (errorMessage.includes('RoleNotConfigured')) {
-                throw new Error('COMMUNITY role is not configured in the Registry contract.');
+            const decodedMsg = decodeContractError(error);
+            if (decodedMsg) {
+                throw new AAStarError(`Community Launch Failed: ${decodedMsg}`, AAStarErrorType.CONTRACT_ERROR);
             }
-            
-            // 重新抛出原始错误
             throw error;
         }
     };
@@ -314,6 +255,8 @@ export function createCommunityClient({
     // State query method - check before operations
     const getCommunityInfo = async (accountAddress: Address) => {
         try {
+            validateAddress(accountAddress, 'Account Address');
+
             // 1. Check if account has COMMUNITY role
             const hasRole = await client.readContract({
                 address: usedAddresses.registry,
@@ -331,62 +274,53 @@ export function createCommunityClient({
             }
 
             // 2. Get token address from factory
-            const factoryAbi = [
-                {
-                    inputs: [{ name: 'community', type: 'address' }],
-                    name: 'getTokenAddress',
-                    outputs: [{ name: '', type: 'address' }],
-                    stateMutability: 'view',
-                    type: 'function'
-                }
-            ] as const;
-
-            const tokenAddress = await client.readContract({
-                address: usedAddresses.xPNTsFactory!,
-                abi: factoryAbi,
-                functionName: 'getTokenAddress',
-                args: [accountAddress]
-            }) as Address;
+            let tokenAddress: Address | null = null;
+            if (usedAddresses.xPNTsFactory) {
+                 tokenAddress = await client.readContract({
+                    address: usedAddresses.xPNTsFactory,
+                    abi: xPNTsFactoryABI,
+                    functionName: 'getTokenAddress',
+                    args: [accountAddress]
+                }) as Address;
+            }
 
             // 3. Get community metadata from Registry
-        const metadata = await client.readContract({
-            address: usedAddresses.registry,
-            abi: RegistryABI,
-            functionName: 'roleMetadata',
-            args: [RoleIds.COMMUNITY, accountAddress]
-        }) as Hex;
+            const metadata = await client.readContract({
+                address: usedAddresses.registry,
+                abi: RegistryABI,
+                functionName: 'roleMetadata',
+                args: [RoleIds.COMMUNITY, accountAddress]
+            }) as Hex;
 
-        let communityData = {
-            name: 'Community',
-            ensName: '',
-            website: '',
-            description: '',
-            logoURI: ''
-        };
+            let communityData = {
+                name: 'Community',
+                ensName: '',
+                website: '',
+                description: '',
+                logoURI: ''
+            };
 
-        if (metadata && metadata !== '0x') {
-            try {
-                // RoleMetadata is encoded as CommunityRoleData struct:
-                // (string name, string ensName, string website, string description, string logoURI, uint256 stakeAmount)
-                const decoded = RoleDataFactory.decodeCommunity(metadata);
-                communityData = {
-                    name: decoded.name || 'Community',
-                    ensName: decoded.ensName || '',
-                    website: decoded.website || '',
-                    description: decoded.description || '',
-                    logoURI: decoded.logoURI || ''
-                };
-            } catch (e) {
-                console.warn('   ⚠️ Failed to decode community metadata:', e);
+            if (metadata && metadata !== '0x') {
+                try {
+                    const decoded = RoleDataFactory.decodeCommunity(metadata);
+                    communityData = {
+                        name: decoded.name || 'Community',
+                        ensName: decoded.ensName || '',
+                        website: decoded.website || '',
+                        description: decoded.description || '',
+                        logoURI: decoded.logoURI || ''
+                    };
+                } catch (e) {
+                    console.warn('   ⚠️ Failed to decode community metadata:', e);
+                }
             }
-        }
 
-        return {
-            hasRole: true,
-            tokenAddress: tokenAddress !== '0x0000000000000000000000000000000000000000' ? tokenAddress : null,
-            communityData: tokenAddress !== '0x0000000000000000000000000000000000000000' ? communityData : null
-        };
-    } catch (error) {
+            return {
+                hasRole: true,
+                tokenAddress: (tokenAddress && tokenAddress !== '0x0000000000000000000000000000000000000000') ? tokenAddress : null,
+                communityData: (metadata && metadata !== '0x') ? communityData : null
+            };
+        } catch (error) {
             console.error('Error fetching community info:', error);
             return {
                 hasRole: false,
@@ -396,7 +330,7 @@ export function createCommunityClient({
         }
     };
 
-    return Object.assign(client, registryActionsObj, sbtActionsObj, { 
+    return Object.assign(client, registryActionsObj, sbtActionsObj, reputationActionsObj, { 
         launch,
         getCommunityInfo
     }) as CommunityClient;