@aastar/sdk 0.16.6 → 0.16.11

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

@@ -1,28 +1,54 @@
 import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
 import { ReputationSystemABI } from '../abis/index.js';
+import { validateAddress, validateRequired, validateAmount } from '../validators/index.js';
+import { AAStarError } from '../errors/index.js';
+
+export type ReputationRule = {
+    baseScore: bigint;
+    activityBonus: bigint;
+    maxBonus: bigint;
+    description: string;
+};
+
+export type ReputationBreakdown = {
+    baseScore: bigint;
+    nftBonus: bigint;
+    activityBonus: bigint;
+    multiplier: bigint;
+};
 
 export type ReputationActions = {
-    // 规则配置
-    setReputationRule: (args: { ruleId: Hex, rule: any, account?: Account | Address }) => Promise<Hash>;
-    getReputationRule: (args: { ruleId: Hex }) => Promise<any>;
+    // Rule Configuration
+    setReputationRule: (args: { ruleId: Hex, rule: ReputationRule, account?: Account | Address }) => Promise<Hash>;
+    getReputationRule: (args: { ruleId: Hex }) => Promise<ReputationRule>;
     enableRule: (args: { ruleId: Hex, account?: Account | Address }) => Promise<Hash>;
     disableRule: (args: { ruleId: Hex, account?: Account | Address }) => Promise<Hash>;
     isRuleActive: (args: { ruleId: Hex }) => Promise<boolean>;
     getActiveRules: (args: { community: Address }) => Promise<Hex[]>;
     getRuleCount: () => Promise<bigint>;
+    setRule: (args: { ruleId: Hex, base: bigint, bonus: bigint, max: bigint, desc: string, account?: Account | Address }) => Promise<Hash>;
+    communityRules: (args: { community: Address, ruleId: Hex }) => Promise<ReputationRule>;
+    communityActiveRules: (args: { community: Address, index: bigint }) => Promise<Hex>;
+    defaultRule: () => Promise<ReputationRule>;
     
-    // 积分计算
-    computeScore: (args: { user: Address, community: Address }) => Promise<bigint>;
+    // Score Calculation
+    computeScore: (args: { user: Address, communities: Address[], ruleIds: Hex[][], activities: bigint[][] }) => Promise<bigint>;
+    calculateReputation: (args: { user: Address, community: Address, timestamp: bigint }) => Promise<{ communityScore: bigint, globalScore: bigint }>;
+    getReputationBreakdown: (args: { user: Address, community: Address, timestamp: bigint }) => Promise<ReputationBreakdown>;
     getUserScore: (args: { user: Address }) => Promise<bigint>;
     getCommunityScore: (args: { community: Address }) => Promise<bigint>;
-    communityReputations: (args: { community: Address, user: Address }) => Promise<bigint>; // Public mapping getter
+    communityReputations: (args: { community: Address, user: Address }) => Promise<bigint>;
+    setCommunityReputation: (args: { community: Address, user: Address, score: bigint, account?: Account | Address }) => Promise<Hash>;
     
-    // Missing Critical Actions
-    setRule: (args: { ruleId: Hex, rule: any, account?: Account | Address }) => Promise<Hash>; // Alias for setReputationRule
-    calculateReputation: (args: { user: Address, community: Address }) => Promise<bigint>; // Alias for computeScore or specific calculation
+    // NFT Boost
+    setNFTBoost: (args: { collection: Address, boost: bigint, account?: Account | Address }) => Promise<Hash>;
     nftCollectionBoost: (args: { collection: Address }) => Promise<bigint>;
+    nftHoldStart: (args: { user: Address, collection: Address }) => Promise<bigint>;
+    updateNFTHoldStart: (args: { collection: Address, account?: Account | Address }) => Promise<Hash>;
+    boostedCollections: (args: { index: bigint }) => Promise<Address>;
+    entropyFactors: (args: { community: Address }) => Promise<bigint>;
     
-    // 批量操作
+    // Batch Operations
     batchUpdateScores: (args: { users: Address[], scores: bigint[], account?: Account | Address }) => Promise<Hash>;
     batchSyncToRegistry: (args: { users: Address[], account?: Account | Address }) => Promise<Hash>;
     syncToRegistry: (args: { 
@@ -37,342 +63,606 @@ export type ReputationActions = {
     
     // Admin & Config
     setRegistry: (args: { registry: Address, account?: Account | Address }) => Promise<Hash>;
-    setEntropyFactor: (args: { factor: bigint, account?: Account | Address }) => Promise<Hash>;
+    setEntropyFactor: (args: { community: Address, factor: bigint, account?: Account | Address }) => Promise<Hash>;
     getEntropyFactor: () => Promise<bigint>;
     
     // Constants
     REGISTRY: () => Promise<Address>;
     
     // Ownership
-    reputationOwner: () => Promise<Address>;
-    transferReputationOwnership: (args: { newOwner: Address, account?: Account | Address }) => Promise<Hash>;
-    renounceReputationOwnership: (args: { account?: Account | Address }) => Promise<Hash>;
-    
-    // Admin & Config (Missing)
-    setCommunityReputation: (args: { community: Address, reputation: bigint, account?: Account | Address }) => Promise<Hash>;
-    updateNFTHoldStart: (args: { user: Address, collection: Address, start: bigint, account?: Account | Address }) => Promise<Hash>;
-    
-    // Views (Missing)
-    communityRules: (args: { community: Address, ruleId: Hex }) => Promise<boolean>;
-    defaultRule: () => Promise<Hex>;
-    entropyFactors: (args: { factorId: bigint }) => Promise<bigint>;
-    nftHoldStart: (args: { user: Address, collection: Address }) => Promise<bigint>;
-    boostedCollections: (args: { collection: Address }) => Promise<bigint>;
-    communityActiveRules: (args: { community: Address, ruleId: Hex }) => Promise<boolean>;
-    getReputationBreakdown: (args: { user: Address, community: Address }) => Promise<any>;
-    setNFTBoost: (args: { collection: Address, boost: bigint, account?: Account | Address }) => Promise<Hash>;
+    owner: () => Promise<Address>;
+    transferOwnership: (args: { newOwner: Address, account?: Account | Address }) => Promise<Hash>;
+    renounceOwnership: (args: { account?: Account | Address }) => Promise<Hash>;
     
     // Version
-    reputationVersion: () => Promise<string>;
+    version: () => Promise<string>;
 };
 
 export const reputationActions = (address: Address) => (client: PublicClient | WalletClient): ReputationActions => ({
-    // 规则配置
+    // Rule Configuration
     async setReputationRule({ ruleId, rule, account }) {
-        return (client as any).writeContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'setReputationRule',
-            args: [ruleId, rule],
-            account: account as any,
-            chain: (client as any).chain
-        });
+        try {
+            validateRequired(ruleId, 'ruleId');
+            validateRequired(rule, 'rule');
+            return await (client as any).writeContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'setReputationRule',
+                args: [ruleId, rule],
+                account: account as any,
+                chain: (client as any).chain
+            });
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'setReputationRule');
+        }
     },
 
     async getReputationRule({ ruleId }) {
-        return (client as PublicClient).readContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'getReputationRule',
-            args: [ruleId]
-        });
+        try {
+            validateRequired(ruleId, 'ruleId');
+            const result = await (client as PublicClient).readContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'getReputationRule',
+                args: [ruleId]
+            }) as any;
+
+            if (Array.isArray(result)) {
+                return {
+                    baseScore: result[0],
+                    activityBonus: result[1],
+                    maxBonus: result[2],
+                    description: result[3]
+                };
+            }
+            return result as ReputationRule;
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'getReputationRule');
+        }
     },
 
     async enableRule({ ruleId, account }) {
-        return (client as any).writeContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'enableRule',
-            args: [ruleId],
-            account: account as any,
-            chain: (client as any).chain
-        });
+        try {
+            validateRequired(ruleId, 'ruleId');
+            return await (client as any).writeContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'enableRule',
+                args: [ruleId],
+                account: account as any,
+                chain: (client as any).chain
+            });
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'enableRule');
+        }
     },
 
     async disableRule({ ruleId, account }) {
-        return (client as any).writeContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'disableRule',
-            args: [ruleId],
-            account: account as any,
-            chain: (client as any).chain
-        });
+        try {
+            validateRequired(ruleId, 'ruleId');
+            return await (client as any).writeContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'disableRule',
+                args: [ruleId],
+                account: account as any,
+                chain: (client as any).chain
+            });
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'disableRule');
+        }
     },
 
     async isRuleActive({ ruleId }) {
-        return (client as PublicClient).readContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'isRuleActive',
-            args: [ruleId]
-        }) as Promise<boolean>;
+        try {
+            validateRequired(ruleId, 'ruleId');
+            return await (client as PublicClient).readContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'isRuleActive',
+                args: [ruleId]
+            }) as boolean;
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'isRuleActive');
+        }
     },
 
     async getActiveRules({ community }) {
-        return (client as PublicClient).readContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'getActiveRules',
-            args: [community]
-        }) as Promise<Hex[]>;
+        try {
+            validateAddress(community, 'community');
+            return await (client as PublicClient).readContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'getActiveRules',
+                args: [community]
+            }) as Hex[];
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'getActiveRules');
+        }
     },
 
     async getRuleCount() {
-        return (client as PublicClient).readContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'getRuleCount',
-            args: []
-        }) as Promise<bigint>;
-    },
-
-    // 积分计算
-    async computeScore({ user, community }) {
-        return (client as PublicClient).readContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'computeScore',
-            args: [user, community]
-        }) as Promise<bigint>;
+        try {
+            return await (client as PublicClient).readContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'getRuleCount',
+                args: []
+            }) as bigint;
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'getRuleCount');
+        }
+    },
+
+    // Score Calculation
+    async computeScore({ user, communities, ruleIds, activities }) {
+        try {
+            validateAddress(user, 'user');
+            validateRequired(communities, 'communities');
+            validateRequired(ruleIds, 'ruleIds');
+            validateRequired(activities, 'activities');
+            return await (client as PublicClient).readContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'computeScore',
+                args: [user, communities, ruleIds, activities]
+            }) as bigint;
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'computeScore');
+        }
+    },
+
+    async calculateReputation({ user, community, timestamp }) {
+        try {
+            validateAddress(user, 'user');
+            validateAddress(community, 'community');
+            const result = await (client as PublicClient).readContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'calculateReputation',
+                args: [user, community, timestamp]
+            }) as any;
+
+            if (Array.isArray(result)) {
+                return { communityScore: result[0], globalScore: result[1] };
+            }
+            return result as { communityScore: bigint, globalScore: bigint };
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'calculateReputation');
+        }
+    },
+
+    async getReputationBreakdown({ user, community, timestamp }) {
+        try {
+            validateAddress(user, 'user');
+            validateAddress(community, 'community');
+            const result = await (client as PublicClient).readContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'getReputationBreakdown',
+                args: [user, community, timestamp]
+            }) as any;
+
+            if (Array.isArray(result)) {
+                return {
+                    baseScore: result[0],
+                    nftBonus: result[1],
+                    activityBonus: result[2],
+                    multiplier: result[3]
+                };
+            }
+            return result as ReputationBreakdown;
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'getReputationBreakdown');
+        }
     },
 
     async getUserScore({ user }) {
-        return (client as PublicClient).readContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'getUserScore',
-            args: [user]
-        }) as Promise<bigint>;
+        try {
+            validateAddress(user, 'user');
+            return await (client as PublicClient).readContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'getUserScore',
+                args: [user]
+            }) as bigint;
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'getUserScore');
+        }
     },
 
     async getCommunityScore({ community }) {
-        return (client as PublicClient).readContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'getCommunityScore',
-            args: [community]
-        }) as Promise<bigint>;
+        try {
+            validateAddress(community, 'community');
+            return await (client as PublicClient).readContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'getCommunityScore',
+                args: [community]
+            }) as bigint;
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'getCommunityScore');
+        }
     },
 
-    // Public mapping getter
     async communityReputations({ community, user }) {
-        return (client as PublicClient).readContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'communityReputations',
-            args: [community, user]
-        }) as Promise<bigint>;
+        try {
+            validateAddress(community, 'community');
+            validateAddress(user, 'user');
+            return await (client as PublicClient).readContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'communityReputations',
+                args: [community, user]
+            }) as bigint;
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'communityReputations');
+        }
+    },
+
+    async setCommunityReputation({ community, user, score, account }) {
+        try {
+            validateAddress(community, 'community');
+            validateAddress(user, 'user');
+            validateAmount(score, 'score');
+            return await (client as any).writeContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'setCommunityReputation',
+                args: [community, user, score],
+                account: account as any,
+                chain: (client as any).chain
+            });
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'setCommunityReputation');
+        }
+    },
+
+    async setRule({ ruleId, base, bonus, max, desc, account }) {
+        try {
+            validateRequired(ruleId, 'ruleId');
+            validateAmount(base, 'base');
+            validateAmount(bonus, 'bonus');
+            validateAmount(max, 'max');
+            validateRequired(desc, 'desc');
+            return await (client as any).writeContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'setRule',
+                args: [ruleId, base, bonus, max, desc],
+                account: account as any,
+                chain: (client as any).chain
+            });
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'setRule');
+        }
     },
 
-    // Missing Critical Actions
-    async setRule(args) {
-        return this.setReputationRule(args);
+    async communityRules({ community, ruleId }) {
+        try {
+            validateAddress(community, 'community');
+            validateRequired(ruleId, 'ruleId');
+            const result = await (client as PublicClient).readContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'communityRules',
+                args: [community, ruleId]
+            }) as any;
+
+            if (Array.isArray(result)) {
+                return {
+                    baseScore: result[0],
+                    activityBonus: result[1],
+                    maxBonus: result[2],
+                    description: result[3]
+                };
+            }
+            return result as ReputationRule;
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'communityRules');
+        }
+    },
+
+    async communityActiveRules({ community, index }) {
+        try {
+            validateAddress(community, 'community');
+            validateRequired(index, 'index');
+            return await (client as PublicClient).readContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'communityActiveRules',
+                args: [community, index]
+            }) as Hex;
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'communityActiveRules');
+        }
     },
 
-    async calculateReputation(args) {
-        // Assuming calculateReputation calls computeScore or check if dedicated function exists
-        // Report said calculateReputation matches ABI.
-        return (client as PublicClient).readContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'calculateReputation', // If this fails, it means calculateReputation is NOT in ABI and tool was confused? But report said it IS in ABI.
-            args: [args.user, args.community]
-        }) as Promise<bigint>;
+    async defaultRule() {
+        try {
+            const result = await (client as PublicClient).readContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'defaultRule',
+                args: []
+            }) as any;
+
+            if (Array.isArray(result)) {
+                return {
+                    baseScore: result[0],
+                    activityBonus: result[1],
+                    maxBonus: result[2],
+                    description: result[3]
+                };
+            }
+            return result as ReputationRule;
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'defaultRule');
+        }
+    },
+
+    // NFT Boost
+    async setNFTBoost({ collection, boost, account }) {
+        try {
+            validateAddress(collection, 'collection');
+            validateAmount(boost, 'boost');
+            return await (client as any).writeContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'setNFTBoost',
+                args: [collection, boost],
+                account: account as any,
+                chain: (client as any).chain
+            });
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'setNFTBoost');
+        }
     },
 
     async nftCollectionBoost({ collection }) {
-        return (client as PublicClient).readContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'nftCollectionBoost',
-            args: [collection]
-        }) as Promise<bigint>;
+        try {
+            validateAddress(collection, 'collection');
+            return await (client as PublicClient).readContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'nftCollectionBoost',
+                args: [collection]
+            }) as bigint;
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'nftCollectionBoost');
+        }
     },
 
-    // 批量操作
+    async nftHoldStart({ user, collection }) {
+        try {
+            validateAddress(user, 'user');
+            validateAddress(collection, 'collection');
+            return await (client as PublicClient).readContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'nftHoldStart',
+                args: [user, collection]
+            }) as bigint;
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'nftHoldStart');
+        }
+    },
+
+    async updateNFTHoldStart({ collection, account }) {
+        try {
+            validateAddress(collection, 'collection');
+            return await (client as any).writeContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'updateNFTHoldStart',
+                args: [collection],
+                account: account as any,
+                chain: (client as any).chain
+            });
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'updateNFTHoldStart');
+        }
+    },
+
+    async boostedCollections({ index }) {
+        try {
+            validateRequired(index, 'index');
+            return await (client as PublicClient).readContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'boostedCollections',
+                args: [index]
+            }) as Address;
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'boostedCollections');
+        }
+    },
+
+    async entropyFactors({ community }) {
+        try {
+            validateAddress(community, 'community');
+            return await (client as PublicClient).readContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'entropyFactors',
+                args: [community]
+            }) as bigint;
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'entropyFactors');
+        }
+    },
+
+    // Batch Operations
     async batchUpdateScores({ users, scores, account }) {
-        return (client as any).writeContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'batchUpdateScores',
-            args: [users, scores],
-            account: account as any,
-            chain: (client as any).chain
-        });
+        try {
+            validateRequired(users, 'users');
+            validateRequired(scores, 'scores');
+            return await (client as any).writeContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'batchUpdateScores',
+                args: [users, scores],
+                account: account as any,
+                chain: (client as any).chain
+            });
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'batchUpdateScores');
+        }
     },
 
     async batchSyncToRegistry({ users, account }) {
-        return (client as any).writeContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'batchSyncToRegistry',
-            args: [users],
-            account: account as any,
-            chain: (client as any).chain
-        });
+        try {
+            validateRequired(users, 'users');
+            return await (client as any).writeContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'batchSyncToRegistry',
+                args: [users],
+                account: account as any,
+                chain: (client as any).chain
+            });
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'batchSyncToRegistry');
+        }
     },
 
     async syncToRegistry({ user, communities, ruleIds, activities, epoch, proof, account }) {
-        return (client as any).writeContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'syncToRegistry',
-            args: [user, communities, ruleIds, activities, epoch, proof],
-            account: account as any,
-            chain: (client as any).chain
-        });
+        try {
+            validateAddress(user, 'user');
+            validateRequired(communities, 'communities');
+            validateRequired(ruleIds, 'ruleIds');
+            validateRequired(activities, 'activities');
+            validateAmount(epoch, 'epoch');
+            validateRequired(proof, 'proof');
+            return await (client as any).writeContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'syncToRegistry',
+                args: [user, communities, ruleIds, activities, epoch, proof],
+                account: account as any,
+                chain: (client as any).chain
+            });
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'syncToRegistry');
+        }
     },
 
     // Admin & Config
     async setRegistry({ registry, account }) {
-        return (client as any).writeContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'setRegistry',
-            args: [registry],
-            account: account as any,
-            chain: (client as any).chain
-        });
-    },
-
-    async setEntropyFactor({ factor, account }) {
-        return (client as any).writeContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'setEntropyFactor',
-            args: [factor],
-            account: account as any,
-            chain: (client as any).chain
-        });
+        try {
+            validateAddress(registry, 'registry');
+            return await (client as any).writeContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'setRegistry',
+                args: [registry],
+                account: account as any,
+                chain: (client as any).chain
+            });
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'setRegistry');
+        }
+    },
+
+    async setEntropyFactor({ community, factor, account }) {
+        try {
+            validateAddress(community, 'community');
+            validateAmount(factor, 'factor');
+            return await (client as any).writeContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'setEntropyFactor',
+                args: [community, factor],
+                account: account as any,
+                chain: (client as any).chain
+            });
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'setEntropyFactor');
+        }
     },
 
     async getEntropyFactor() {
-        return (client as PublicClient).readContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'getEntropyFactor',
-            args: []
-        }) as Promise<bigint>;
+        try {
+            return await (client as PublicClient).readContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'getEntropyFactor',
+                args: []
+            }) as bigint;
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'getEntropyFactor');
+        }
     },
 
     // Constants
     async REGISTRY() {
-        return (client as PublicClient).readContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'REGISTRY',
-            args: []
-        }) as Promise<Address>;
+        try {
+            return await (client as PublicClient).readContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'REGISTRY',
+                args: []
+            }) as Address;
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'REGISTRY');
+        }
     },
 
     // Ownership
-    async reputationOwner() {
-        return (client as PublicClient).readContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'owner',
-            args: []
-        }) as Promise<Address>;
-    },
-
-    async renounceReputationOwnership({ account }: { account?: Account | Address } = {}) {
-        return (client as any).writeContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'renounceOwnership',
-            args: [],
-            account: account as any,
-            chain: (client as any).chain
-        });
-    },
-
-    async transferReputationOwnership({ newOwner, account }: { newOwner: Address, account?: Account | Address }) {
-        return (client as any).writeContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'transferOwnership',
-            args: [newOwner],
-            account: account as any,
-            chain: (client as any).chain
-        });
-    },
-
-    async setCommunityReputation({ community, reputation, account }) {
-        return (client as any).writeContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'setCommunityReputation',
-            args: [community, reputation],
-            account: account as any,
-            chain: (client as any).chain
-        });
-    },
-
-    async updateNFTHoldStart({ user, collection, start, account }) {
-        return (client as any).writeContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'updateNFTHoldStart',
-            args: [user, collection, start],
-            account: account as any,
-            chain: (client as any).chain
-        });
-    },
-
-    // Views
-    async communityRules({ community, ruleId }) {
-        return (client as PublicClient).readContract({ address, abi: ReputationSystemABI, functionName: 'communityRules', args: [community, ruleId] }) as Promise<boolean>;
-    },
-    async defaultRule() {
-        return (client as PublicClient).readContract({ address, abi: ReputationSystemABI, functionName: 'defaultRule', args: [] }) as Promise<Hex>;
-    },
-    async entropyFactors({ factorId }) {
-        return (client as PublicClient).readContract({ address, abi: ReputationSystemABI, functionName: 'entropyFactors', args: [factorId] }) as Promise<bigint>;
-    },
-    async nftHoldStart({ user, collection }) {
-        return (client as PublicClient).readContract({ address, abi: ReputationSystemABI, functionName: 'nftHoldStart', args: [user, collection] }) as Promise<bigint>;
-    },
-    async boostedCollections({ collection }) {
-        return (client as PublicClient).readContract({ address, abi: ReputationSystemABI, functionName: 'boostedCollections', args: [collection] }) as Promise<bigint>;
-    },
-
-    async communityActiveRules({ community, ruleId }) {
-         return (client as PublicClient).readContract({ address, abi: ReputationSystemABI, functionName: 'communityActiveRules', args: [community, ruleId] }) as Promise<boolean>;
-    },
-
-    async getReputationBreakdown({ user, community }) {
-         return (client as PublicClient).readContract({ address, abi: ReputationSystemABI, functionName: 'getReputationBreakdown', args: [user, community] });
-    },
-
-    async setNFTBoost({ collection, boost, account }) {
-          return (client as any).writeContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'setNFTBoost',
-            args: [collection, boost],
-            account: account as any,
-            chain: (client as any).chain
-        });
-    },
-
-    // Version
-    async reputationVersion() {
-        return (client as PublicClient).readContract({
-            address,
-            abi: ReputationSystemABI,
-            functionName: 'version',
-            args: []
-        }) as Promise<string>;
+    async owner() {
+        try {
+            return await (client as PublicClient).readContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'owner',
+                args: []
+            }) as Promise<Address>;
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'owner');
+        }
+    },
+
+    async transferOwnership({ newOwner, account }) {
+        try {
+            validateAddress(newOwner, 'newOwner');
+            return await (client as any).writeContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'transferOwnership',
+                args: [newOwner],
+                account: account as any,
+                chain: (client as any).chain
+            });
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'transferOwnership');
+        }
+    },
+
+    async renounceOwnership({ account }) {
+        try {
+            return await (client as any).writeContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'renounceOwnership',
+                args: [],
+                account: account as any,
+                chain: (client as any).chain
+            });
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'renounceOwnership');
+        }
+    },
+
+    async version() {
+        try {
+            return await (client as PublicClient).readContract({
+                address,
+                abi: ReputationSystemABI,
+                functionName: 'version',
+                args: []
+            }) as Promise<string>;
+        } catch (error) {
+            throw AAStarError.fromViemError(error as Error, 'version');
+        }
     }
 });