@aastar/core 0.16.8 → 0.16.12

package/dist/actions/registry.js

@@ -1,667 +1,868 @@
 import { RegistryABI } from '../abis/index.js';
+import { validateAddress, validateRequired, validateAmount } from '../validators/index.js';
+import { AAStarError } from '../errors/index.js';
 export const registryActions = (address) => (client) => ({
     // Role Management
-    async registryConfigureRole({ roleId, config, account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'configureRole',
-            args: [roleId, config],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async registryRegisterRole({ roleId, user, data, account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'registerRole',
-            args: [roleId, user, data],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async registryRegisterRoleSelf({ roleId, data, account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'registerRoleSelf',
-            args: [roleId, data],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async registryHasRole({ user, roleId }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'hasRole',
-            args: [roleId, user]
-        });
-    },
-    async registryUnRegisterRole({ user, roleId, account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'unregisterRole',
-            args: [user, roleId],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async registryGetRoleConfig({ roleId }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'getRoleConfig',
-            args: [roleId]
-        });
-    },
-    async registrySetRoleLockDuration({ roleId, duration, account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'setRoleLockDuration',
-            args: [roleId, duration],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async registrySetRoleOwner({ roleId, newOwner, account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'setRoleOwner',
-            args: [roleId, newOwner],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async registryIsCommunityMember({ community, user }) {
-        const ROLE_ENDUSER = await this.registryROLE_ENDUSER();
-        return this.registryHasRole({ user, roleId: ROLE_ENDUSER });
+    async configureRole({ roleId, config, account }) {
+        try {
+            validateRequired(roleId, 'roleId');
+            validateRequired(config, 'config');
+            return await client.writeContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'configureRole',
+                args: [roleId, config],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'configureRole');
+        }
+    },
+    async adminConfigureRole({ roleId, minStake, entryBurn, exitFeePercent, minExitFee, account }) {
+        try {
+            validateRequired(roleId, 'roleId');
+            return await client.writeContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'adminConfigureRole',
+                args: [roleId, minStake, entryBurn, exitFeePercent, minExitFee],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'adminConfigureRole');
+        }
+    },
+    async createNewRole({ roleId, config, roleOwner, account }) {
+        try {
+            validateRequired(roleId, 'roleId');
+            validateRequired(config, 'config');
+            validateAddress(roleOwner, 'roleOwner');
+            return await client.writeContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'createNewRole',
+                args: [roleId, config, roleOwner],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'createNewRole');
+        }
+    },
+    async registerRole({ roleId, user, data, account }) {
+        try {
+            validateRequired(roleId, 'roleId');
+            validateAddress(user, 'user');
+            return await client.writeContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'registerRole',
+                args: [roleId, user, data],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'registerRole');
+        }
+    },
+    async registerRoleSelf({ roleId, data, account }) {
+        try {
+            validateRequired(roleId, 'roleId');
+            return await client.writeContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'registerRoleSelf',
+                args: [roleId, data],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'registerRoleSelf');
+        }
+    },
+    async safeMintForRole({ roleId, user, data, account }) {
+        try {
+            validateRequired(roleId, 'roleId');
+            validateAddress(user, 'user');
+            return await client.writeContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'safeMintForRole',
+                args: [roleId, user, data],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'safeMintForRole');
+        }
+    },
+    async hasRole({ roleId, user }) {
+        try {
+            validateRequired(roleId, 'roleId');
+            validateAddress(user, 'user');
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'hasRole',
+                args: [roleId, user]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'hasRole');
+        }
+    },
+    async getRoleConfig({ roleId }) {
+        try {
+            validateRequired(roleId, 'roleId');
+            const result = await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'getRoleConfig',
+                args: [roleId]
+            });
+            if (Array.isArray(result)) {
+                return {
+                    minStake: result[0],
+                    entryBurn: result[1],
+                    slashThreshold: result[2],
+                    slashBase: result[3],
+                    slashInc: result[4],
+                    slashMax: result[5],
+                    exitFeePercent: result[6],
+                    isActive: result[7],
+                    minExitFee: result[8],
+                    description: result[9],
+                    owner: result[10],
+                    roleLockDuration: result[11]
+                };
+            }
+            return result;
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getRoleConfig');
+        }
+    },
+    async setRoleLockDuration({ roleId, duration, account }) {
+        try {
+            validateRequired(roleId, 'roleId');
+            validateRequired(duration, 'duration');
+            return await client.writeContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'setRoleLockDuration',
+                args: [roleId, duration],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setRoleLockDuration');
+        }
+    },
+    async setRoleOwner({ roleId, newOwner, account }) {
+        try {
+            validateRequired(roleId, 'roleId');
+            validateAddress(newOwner, 'newOwner');
+            return await client.writeContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'setRoleOwner',
+                args: [roleId, newOwner],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setRoleOwner');
+        }
+    },
+    async exitRole({ roleId, account }) {
+        try {
+            validateRequired(roleId, 'roleId');
+            return await client.writeContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'exitRole',
+                args: [roleId],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'exitRole');
+        }
+    },
+    // Community Management
+    async communityByName({ name }) {
+        try {
+            validateRequired(name, 'name');
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'communityByName',
+                args: [name]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'communityByName');
+        }
+    },
+    async communityByENS({ ensName }) {
+        try {
+            validateRequired(ensName, 'ensName');
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'communityByENS',
+                args: [ensName]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'communityByENS');
+        }
     },
     // Credit & Reputation
-    async registryGlobalReputation({ user }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'globalReputation',
-            args: [user]
-        });
-    },
-    async registryBatchUpdateGlobalReputation({ users, scores, epoch, proof, account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'batchUpdateGlobalReputation',
-            args: [users, scores, epoch, proof],
-            account: account,
-            chain: client.chain
-        });
-    },
-    // Blacklist Management
-    async registryUpdateOperatorBlacklist({ operator, users, statuses, proof, account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'updateOperatorBlacklist',
-            args: [operator, users, statuses, proof],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async registryIsOperatorBlacklisted({ operator }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'isOperatorBlacklisted',
-            args: [operator]
-        });
+    async getCreditLimit({ user }) {
+        try {
+            validateAddress(user, 'user');
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'getCreditLimit',
+                args: [user]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getCreditLimit');
+        }
+    },
+    async globalReputation({ user }) {
+        try {
+            validateAddress(user, 'user');
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'globalReputation',
+                args: [user]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'globalReputation');
+        }
+    },
+    async addLevelThreshold({ threshold, account }) {
+        try {
+            validateAmount(threshold, 'threshold');
+            return await client.writeContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'addLevelThreshold',
+                args: [threshold],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'addLevelThreshold');
+        }
+    },
+    async batchUpdateGlobalReputation({ proposalId, users, newScores, epoch, proof, account }) {
+        try {
+            validateAmount(proposalId, 'proposalId');
+            validateRequired(users, 'users');
+            validateRequired(newScores, 'newScores');
+            validateAmount(epoch, 'epoch');
+            validateRequired(proof, 'proof');
+            return await client.writeContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'batchUpdateGlobalReputation',
+                args: [proposalId, users, newScores, epoch, proof],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'batchUpdateGlobalReputation');
+        }
     },
     // Contract References
-    async registrySetBLSValidator({ validator, account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'setBLSValidator',
-            args: [validator],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async registrySetBLSAggregator({ aggregator, account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'setBLSAggregator',
-            args: [aggregator],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async registrySetMySBT({ sbt, account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'setMySBT',
-            args: [sbt],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async registrySetSuperPaymaster({ paymaster, account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'setSuperPaymaster',
-            args: [paymaster],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async registrySetStaking({ staking, account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'setStaking',
-            args: [staking],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async registrySetReputationSource({ source, account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'setReputationSource',
-            args: [source],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async registryBlsValidator() {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'blsValidator',
-            args: []
-        });
-    },
-    async registryBlsAggregator() {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'blsAggregator',
-            args: []
-        });
-    },
-    async registryMySBT() {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'MYSBT',
-            args: []
-        });
-    },
-    async registrySuperPaymaster() {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'SUPER_PAYMASTER',
-            args: []
-        });
-    },
-    async registryStaking() {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'GTOKEN_STAKING',
-            args: []
-        });
-    },
-    async registryReputationSource() {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'reputationSource',
-            args: []
-        });
-    },
-    // Admin
-    async registryTransferOwnership({ newOwner, account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'transferOwnership',
-            args: [newOwner],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async registryOwner() {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'owner',
-            args: []
-        });
-    },
-    async registryRenounceOwnership({ account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'renounceOwnership',
-            args: [],
-            account: account,
-            chain: client.chain
-        });
+    async setBLSValidator({ validator, account }) {
+        try {
+            validateAddress(validator, 'validator');
+            return await client.writeContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'setBLSValidator',
+                args: [validator],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setBLSValidator');
+        }
+    },
+    async setBLSAggregator({ aggregator, account }) {
+        try {
+            validateAddress(aggregator, 'aggregator');
+            return await client.writeContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'setBLSAggregator',
+                args: [aggregator],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setBLSAggregator');
+        }
+    },
+    async setMySBT({ sbt, account }) {
+        try {
+            validateAddress(sbt, 'sbt');
+            return await client.writeContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'setMySBT',
+                args: [sbt],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setMySBT');
+        }
+    },
+    async setSuperPaymaster({ paymaster, account }) {
+        try {
+            validateAddress(paymaster, 'paymaster');
+            return await client.writeContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'setSuperPaymaster',
+                args: [paymaster],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setSuperPaymaster');
+        }
+    },
+    async setStaking({ staking, account }) {
+        try {
+            validateAddress(staking, 'staking');
+            return await client.writeContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'setStaking',
+                args: [staking],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setStaking');
+        }
+    },
+    async setReputationSource({ source, account }) {
+        try {
+            validateAddress(source, 'source');
+            return await client.writeContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'setReputationSource',
+                args: [source],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setReputationSource');
+        }
+    },
+    async blsValidator() {
+        try {
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'blsValidator',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'blsValidator');
+        }
+    },
+    async blsAggregator() {
+        try {
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'blsAggregator',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'blsAggregator');
+        }
+    },
+    async MYSBT() {
+        try {
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'MYSBT',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'MYSBT');
+        }
+    },
+    async SUPER_PAYMASTER() {
+        try {
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'SUPER_PAYMASTER',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'SUPER_PAYMASTER');
+        }
+    },
+    async GTOKEN_STAKING() {
+        try {
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'GTOKEN_STAKING',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'GTOKEN_STAKING');
+        }
+    },
+    async reputationSource() {
+        try {
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'reputationSource',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'reputationSource');
+        }
+    },
+    async isReputationSource({ source }) {
+        try {
+            validateAddress(source, 'source');
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'isReputationSource',
+                args: [source]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'isReputationSource');
+        }
+    },
+    async lastReputationEpoch({ user }) {
+        try {
+            validateAddress(user, 'user');
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'lastReputationEpoch',
+                args: [user]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'lastReputationEpoch');
+        }
     },
     // View Functions
-    async registryRoleConfigs({ roleId }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'roleConfigs',
-            args: [roleId]
-        });
-    },
-    async registryRoleCounts({ roleId }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'roleCounts',
-            args: [roleId]
-        });
-    },
-    // Alias: getRoleMemberCount maps to contract's getRoleUserCount
-    async registryGetRoleMemberCount({ roleId }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'getRoleUserCount',
-            args: [roleId]
-        });
-    },
-    async registryRoleMembers({ roleId, index }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'roleMembers',
-            args: [roleId, index]
-        });
-    },
-    async registryUserRoles({ user, index }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'userRoles',
-            args: [user, index]
-        });
-    },
-    async registryUserRoleCount({ user }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'userRoleCount',
-            args: [user]
-        });
-    },
-    async registryLevelThresholds({ level }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'levelThresholds',
-            args: [level]
-        });
-    },
-    async registryExecutedProposals({ proposalId }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'executedProposals',
-            args: [proposalId]
-        });
-    },
-    // Community lookup functions
-    async registryCommunityByName({ name }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'communityByName',
-            args: [name]
-        });
-    },
-    async registryCommunityByENS({ ensName }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'communityByENS',
-            args: [ensName]
-        });
-    },
-    async registryCommunityByNameV3({ name }) {
-        return this.registryCommunityByName({ name });
-    },
-    async registryCommunityByENSV3({ ensName }) {
-        return this.registryCommunityByENS({ ensName });
-    },
-    async registryProposedRoleNames({ roleId }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'proposedRoleNames',
-            args: [roleId]
-        });
-    },
-    // Role Metadata & Members
-    async registryRoleLockDurations({ roleId }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'roleLockDurations',
-            args: [roleId]
-        });
-    },
-    async registryRoleMetadata({ roleId, user }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'roleMetadata',
-            args: user ? [roleId, user] : [roleId]
-        });
-    },
-    async registryRoleStakes({ roleId, user }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'roleStakes',
-            args: [roleId, user]
-        });
-    },
-    async registryRoleSBTTokenIds({ roleId, user }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'roleSBTTokenIds',
-            args: [roleId, user]
-        });
-    },
-    async registryRoleOwners({ roleId }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'roleOwners',
-            args: [roleId]
-        });
-    },
-    async registryRoleMemberIndex({ roleId, user }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'roleMemberIndex',
-            args: [roleId, user]
-        });
-    },
-    async registryGetRoleMembers({ roleId }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'getRoleMembers',
-            args: [roleId]
-        });
-    },
-    async registryGetRoleUserCount({ roleId }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'getRoleUserCount',
-            args: [roleId]
-        });
-    },
-    async registryGetUserRoles({ user }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'getUserRoles',
-            args: [user]
-        });
-    },
-    async registryExitRole({ roleId, account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'exitRole',
-            args: [roleId],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async registryCalculateExitFee({ roleId, amount }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'calculateExitFee',
-            args: [roleId, amount]
-        });
-    },
-    async registryAddLevelThreshold({ threshold, account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'addLevelThreshold',
-            args: [threshold],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async registrySetLevelThreshold({ index, threshold, account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'setLevelThreshold',
-            args: [index, threshold],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async registryAccountToUser({ account: userAccount }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'accountToUser',
-            args: [userAccount]
-        });
-    },
-    // Credit & Tiers
-    async registryGetCreditLimit({ user }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'getCreditLimit',
-            args: [user]
-        });
-    },
-    async registrySetCreditTier({ level, limit, account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'setCreditTier',
-            args: [level, limit],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async registryCreditTierConfig({ level }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'creditTierConfig',
-            args: [level]
-        });
-    },
-    // Role Admin
-    async registryAdminConfigureRole({ roleId, minStake, entryBurn, exitFeePercent, minExitFee, account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'adminConfigureRole',
-            args: [roleId, minStake, entryBurn, exitFeePercent, minExitFee],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async registryCreateNewRole({ roleId, config, roleOwner, account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'createNewRole',
-            args: [roleId, config, roleOwner],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async registrySafeMintForRole({ roleId, user, data, account }) {
-        return client.writeContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'safeMintForRole',
-            args: [roleId, user, data],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async registryGetAccountCommunity({ account: userAccount }) {
-        // Check if user has COMMUNITY role
-        const COMMUNITY_ROLE_ID = '0x0000000000000000000000000000000000000000000000000000000000000002';
-        const hasRole = await client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'hasRole',
-            args: [userAccount, COMMUNITY_ROLE_ID]
-        });
-        if (!hasRole) {
-            return '0x0000000000000000000000000000000000000000';
-        }
-        // Get role data which contains the community token address
-        const roleData = await client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'getRoleData',
-            args: [userAccount, COMMUNITY_ROLE_ID]
-        });
-        // Parse community token from role data (first 20 bytes after removing 0x)
-        if (!roleData || roleData === '0x') {
-            return '0x0000000000000000000000000000000000000000';
-        }
-        // Community token is at bytes 0-19 of roleData
-        const tokenAddress = ('0x' + roleData.slice(2, 42));
-        return tokenAddress;
+    async roleConfigs({ roleId }) {
+        try {
+            validateRequired(roleId, 'roleId');
+            const result = await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'roleConfigs',
+                args: [roleId]
+            });
+            if (Array.isArray(result)) {
+                return {
+                    minStake: result[0],
+                    entryBurn: result[1],
+                    slashThreshold: result[2],
+                    slashBase: result[3],
+                    slashInc: result[4],
+                    slashMax: result[5],
+                    exitFeePercent: result[6],
+                    isActive: result[7],
+                    minExitFee: result[8],
+                    description: result[9],
+                    owner: result[10],
+                    roleLockDuration: result[11]
+                };
+            }
+            return result;
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'roleConfigs');
+        }
+    },
+    async getRoleUserCount({ roleId }) {
+        try {
+            validateRequired(roleId, 'roleId');
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'getRoleUserCount',
+                args: [roleId]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getRoleUserCount');
+        }
+    },
+    async getRoleMembers({ roleId }) {
+        try {
+            validateRequired(roleId, 'roleId');
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'getRoleMembers',
+                args: [roleId]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getRoleMembers');
+        }
+    },
+    async getUserRoles({ user }) {
+        try {
+            validateAddress(user, 'user');
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'getUserRoles',
+                args: [user]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getUserRoles');
+        }
+    },
+    async roleMembers({ roleId, index }) {
+        try {
+            validateRequired(roleId, 'roleId');
+            validateRequired(index, 'index');
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'roleMembers',
+                args: [roleId, index]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'roleMembers');
+        }
+    },
+    async userRoles({ user, index }) {
+        try {
+            validateAddress(user, 'user');
+            validateRequired(index, 'index');
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'userRoles',
+                args: [user, index]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'userRoles');
+        }
+    },
+    async userRoleCount({ user }) {
+        try {
+            validateAddress(user, 'user');
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'userRoleCount',
+                args: [user]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'userRoleCount');
+        }
+    },
+    async creditTierConfig({ tierIndex }) {
+        try {
+            validateAmount(tierIndex, 'tierIndex');
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'creditTierConfig',
+                args: [tierIndex]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'creditTierConfig');
+        }
+    },
+    async levelThresholds({ levelIndex }) {
+        try {
+            validateAmount(levelIndex, 'levelIndex');
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'levelThresholds',
+                args: [levelIndex]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'levelThresholds');
+        }
+    },
+    async calculateExitFee({ roleId, amount }) {
+        try {
+            validateRequired(roleId, 'roleId');
+            validateAmount(amount, 'amount');
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'calculateExitFee',
+                args: [roleId, amount]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'calculateExitFee');
+        }
+    },
+    async accountToUser({ account }) {
+        try {
+            validateAddress(account, 'account');
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'accountToUser',
+                args: [account]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'accountToUser');
+        }
+    },
+    async roleOwners({ roleId }) {
+        try {
+            validateRequired(roleId, 'roleId');
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'roleOwners',
+                args: [roleId]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'roleOwners');
+        }
+    },
+    async roleStakes({ roleId, user }) {
+        try {
+            validateRequired(roleId, 'roleId');
+            validateAddress(user, 'user');
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'roleStakes',
+                args: [roleId, user]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'roleStakes');
+        }
+    },
+    async roleLockDurations({ roleId }) {
+        try {
+            validateRequired(roleId, 'roleId');
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'roleLockDurations',
+                args: [roleId]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'roleLockDurations');
+        }
     },
     // Constants (Role IDs)
-    async registryROLE_COMMUNITY() {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'ROLE_COMMUNITY',
-            args: []
-        });
-    },
-    async registryROLE_ENDUSER() {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'ROLE_ENDUSER',
-            args: []
-        });
-    },
-    async registryROLE_PAYMASTER_SUPER() {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'ROLE_PAYMASTER_SUPER',
-            args: []
-        });
-    },
-    async registryROLE_PAYMASTER_AOA() {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'ROLE_PAYMASTER_AOA',
-            args: []
-        });
-    },
-    async registryROLE_DVT() {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'ROLE_DVT',
-            args: []
-        });
-    },
-    async registryROLE_KMS() {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'ROLE_KMS',
-            args: []
-        });
-    },
-    async registryROLE_ANODE() {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'ROLE_ANODE',
-            args: []
-        });
-    },
-    async registryGTOKEN_STAKING() {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'GTOKEN_STAKING',
-            args: []
-        });
-    },
-    async registryMYSBT() {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'MYSBT',
-            args: []
-        });
-    },
-    async registrySUPER_PAYMASTER() {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'SUPER_PAYMASTER',
-            args: []
-        });
-    },
-    async registryIsReputationSource({ source }) {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'isReputationSource',
-            args: [source]
-        });
-    },
-    async registryLastReputationEpoch() {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'lastReputationEpoch',
-            args: []
-        });
-    },
-    // Version
-    async registryVersion() {
-        return client.readContract({
-            address,
-            abi: RegistryABI,
-            functionName: 'version',
-            args: []
-        });
+    async ROLE_COMMUNITY() {
+        try {
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'ROLE_COMMUNITY',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'ROLE_COMMUNITY');
+        }
+    },
+    async ROLE_ENDUSER() {
+        try {
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'ROLE_ENDUSER',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'ROLE_ENDUSER');
+        }
+    },
+    async ROLE_PAYMASTER_SUPER() {
+        try {
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'ROLE_PAYMASTER_SUPER',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'ROLE_PAYMASTER_SUPER');
+        }
+    },
+    async ROLE_PAYMASTER_AOA() {
+        try {
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'ROLE_PAYMASTER_AOA',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'ROLE_PAYMASTER_AOA');
+        }
+    },
+    async ROLE_DVT() {
+        try {
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'ROLE_DVT',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'ROLE_DVT');
+        }
+    },
+    async ROLE_KMS() {
+        try {
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'ROLE_KMS',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'ROLE_KMS');
+        }
+    },
+    async ROLE_ANODE() {
+        try {
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'ROLE_ANODE',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'ROLE_ANODE');
+        }
+    },
+    // Ownership
+    async owner() {
+        try {
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'owner',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'owner');
+        }
+    },
+    async transferOwnership({ newOwner, account }) {
+        try {
+            validateAddress(newOwner, 'newOwner');
+            return await client.writeContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'transferOwnership',
+                args: [newOwner],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'transferOwnership');
+        }
+    },
+    async renounceOwnership({ account }) {
+        try {
+            return await client.writeContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'renounceOwnership',
+                args: [],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'renounceOwnership');
+        }
+    },
+    async version() {
+        try {
+            return await client.readContract({
+                address,
+                abi: RegistryABI,
+                functionName: 'version',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'version');
+        }
     }
 });