@aastar/core 0.16.8 → 0.16.12

package/dist/actions/sbt.js

@@ -1,533 +1,816 @@
 import { MySBTABI } from '../abis/index.js';
+import { validateAddress, validateAmount, validateRequired } from '../validators/index.js';
+import { AAStarError } from '../errors/index.js';
 export const sbtActions = (address) => (client) => ({
     // SBT specific
-    async sbtSafeMintForRole({ roleId, to, tokenURI, account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'safeMintForRole',
-            args: [roleId, to, tokenURI],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtAirdropMint({ roleId, to, tokenURI, account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'airdropMint',
-            args: [roleId, to, tokenURI],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtGetUserSBT({ user, roleId }) {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'getUserSBT',
-            args: [user]
-        });
-    },
-    async sbtGetSBTData({ tokenId }) {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'getSBTData',
-            args: [tokenId]
-        });
-    },
-    async sbtGetCommunityMembership({ user, community }) {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'getCommunityMembership',
-            args: [user, community]
-        });
+    async airdropMint({ user, roleId, roleData, account }) {
+        try {
+            validateAddress(user, 'user');
+            validateRequired(roleId, 'roleId');
+            validateRequired(roleData, 'roleData');
+            return await client.writeContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'airdropMint',
+                args: [user, roleId, roleData],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'airdropMint');
+        }
+    },
+    async mintForRole({ user, roleId, roleData, account }) {
+        try {
+            validateAddress(user, 'user');
+            validateRequired(roleId, 'roleId');
+            validateRequired(roleData, 'roleData');
+            return await client.writeContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'mintForRole',
+                args: [user, roleId, roleData],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'mintForRole');
+        }
+    },
+    async getUserSBT({ user }) {
+        try {
+            validateAddress(user, 'user');
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'getUserSBT',
+                args: [user]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getUserSBT');
+        }
+    },
+    async getSBTData({ tokenId }) {
+        try {
+            validateRequired(tokenId, 'tokenId');
+            const res = await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'getSBTData',
+                args: [tokenId]
+            });
+            if (Array.isArray(res)) {
+                return {
+                    holder: res[0],
+                    firstCommunity: res[1],
+                    mintedAt: res[2],
+                    totalCommunities: res[3]
+                };
+            }
+            return res;
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getSBTData');
+        }
+    },
+    async getCommunityMembership({ tokenId, community }) {
+        try {
+            validateRequired(tokenId, 'tokenId');
+            validateAddress(community, 'community');
+            const res = await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'getCommunityMembership',
+                args: [tokenId, community]
+            });
+            if (Array.isArray(res)) {
+                return {
+                    community: res[0],
+                    joinedAt: res[1],
+                    lastActiveTime: res[2],
+                    isActive: res[3],
+                    metadata: res[4]
+                };
+            }
+            return res;
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getCommunityMembership');
+        }
+    },
+    async getMemberships({ tokenId }) {
+        try {
+            validateRequired(tokenId, 'tokenId');
+            const res = await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'getMemberships',
+                args: [tokenId]
+            });
+            return res.map(m => {
+                if (Array.isArray(m)) {
+                    return {
+                        community: m[0],
+                        joinedAt: m[1],
+                        lastActiveTime: m[2],
+                        isActive: m[3],
+                        metadata: m[4]
+                    };
+                }
+                return m;
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getMemberships');
+        }
+    },
+    async getActiveMemberships({ tokenId }) {
+        try {
+            validateRequired(tokenId, 'tokenId');
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'getActiveMemberships',
+                args: [tokenId]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getActiveMemberships');
+        }
+    },
+    async verifyCommunityMembership({ user, community }) {
+        try {
+            validateAddress(user, 'user');
+            validateAddress(community, 'community');
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'verifyCommunityMembership',
+                args: [user, community]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'verifyCommunityMembership');
+        }
+    },
+    async userToSBT({ user }) {
+        try {
+            validateAddress(user, 'user');
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'userToSBT',
+                args: [user]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'userToSBT');
+        }
+    },
+    async sbtData({ tokenId }) {
+        try {
+            validateRequired(tokenId, 'tokenId');
+            const res = await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'sbtData',
+                args: [tokenId]
+            });
+            if (Array.isArray(res)) {
+                return {
+                    holder: res[0],
+                    firstCommunity: res[1],
+                    mintedAt: res[2],
+                    totalCommunities: res[3]
+                };
+            }
+            return res;
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'sbtData');
+        }
+    },
+    async membershipIndex({ tokenId, community }) {
+        try {
+            validateRequired(tokenId, 'tokenId');
+            validateAddress(community, 'community');
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'membershipIndex',
+                args: [tokenId, community]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'membershipIndex');
+        }
     },
     // ERC721 Standard
-    async sbtBalanceOf({ owner }) {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'balanceOf',
-            args: [owner]
-        });
-    },
-    async sbtOwnerOf({ tokenId }) {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'ownerOf',
-            args: [tokenId]
-        });
-    },
-    async sbtSafeTransferFrom({ from, to, tokenId, account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'safeTransferFrom',
-            args: [from, to, tokenId],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtTransferFrom({ from, to, tokenId, account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'transferFrom',
-            args: [from, to, tokenId],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtApprove({ to, tokenId, account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'approve',
-            args: [to, tokenId],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtSetApprovalForAll({ operator, approved, account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'setApprovalForAll',
-            args: [operator, approved],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtGetApproved({ tokenId }) {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'getApproved',
-            args: [tokenId]
-        });
-    },
-    async sbtIsApprovedForAll({ owner, operator }) {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'isApprovedForAll',
-            args: [owner, operator]
-        });
+    async balanceOf({ owner }) {
+        try {
+            validateAddress(owner, 'owner');
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'balanceOf',
+                args: [owner]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'balanceOf');
+        }
+    },
+    async ownerOf({ tokenId }) {
+        try {
+            validateRequired(tokenId, 'tokenId');
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'ownerOf',
+                args: [tokenId]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'ownerOf');
+        }
+    },
+    async safeTransferFrom({ from, to, tokenId, data, account }) {
+        try {
+            validateAddress(from, 'from');
+            validateAddress(to, 'to');
+            validateRequired(tokenId, 'tokenId');
+            const args = data ? [from, to, tokenId, data] : [from, to, tokenId];
+            return await client.writeContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'safeTransferFrom',
+                args,
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'safeTransferFrom');
+        }
+    },
+    async transferFrom({ from, to, tokenId, account }) {
+        try {
+            validateAddress(from, 'from');
+            validateAddress(to, 'to');
+            validateRequired(tokenId, 'tokenId');
+            return await client.writeContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'transferFrom',
+                args: [from, to, tokenId],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'transferFrom');
+        }
+    },
+    async approve({ to, tokenId, account }) {
+        try {
+            validateAddress(to, 'to');
+            validateRequired(tokenId, 'tokenId');
+            return await client.writeContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'approve',
+                args: [to, tokenId],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'approve');
+        }
+    },
+    async setApprovalForAll({ operator, approved, account }) {
+        try {
+            validateAddress(operator, 'operator');
+            return await client.writeContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'setApprovalForAll',
+                args: [operator, approved],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setApprovalForAll');
+        }
+    },
+    async getApproved({ tokenId }) {
+        try {
+            validateRequired(tokenId, 'tokenId');
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'getApproved',
+                args: [tokenId]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getApproved');
+        }
+    },
+    async isApprovedForAll({ owner, operator }) {
+        try {
+            validateAddress(owner, 'owner');
+            validateAddress(operator, 'operator');
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'isApprovedForAll',
+                args: [owner, operator]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'isApprovedForAll');
+        }
     },
     // ERC721 Metadata
-    async sbtName() {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'name',
-            args: []
-        });
-    },
-    async sbtSymbol() {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'symbol',
-            args: []
-        });
-    },
-    async sbtTokenURI({ tokenId }) {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'tokenURI',
-            args: [tokenId]
-        });
-    },
-    // ERC721 Enumerable
-    async sbtTotalSupply() {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'totalSupply',
-            args: []
-        });
-    },
-    async sbtTokenByIndex({ index }) {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'tokenByIndex',
-            args: [index]
-        });
-    },
-    async sbtTokenOfOwnerByIndex({ owner, index }) {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'tokenOfOwnerByIndex',
-            args: [owner, index]
-        });
+    async name() {
+        try {
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'name',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'name');
+        }
+    },
+    async symbol() {
+        try {
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'symbol',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'symbol');
+        }
+    },
+    async tokenURI({ tokenId }) {
+        try {
+            validateRequired(tokenId, 'tokenId');
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'tokenURI',
+                args: [tokenId]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'tokenURI');
+        }
+    },
+    // View Functions
+    async nextTokenId() {
+        try {
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'nextTokenId',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'nextTokenId');
+        }
+    },
+    async supportsInterface({ interfaceId }) {
+        try {
+            validateRequired(interfaceId, 'interfaceId');
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'supportsInterface',
+                args: [interfaceId]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'supportsInterface');
+        }
     },
     // Admin/Minting
-    async sbtMint({ to, tokenURI, account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'mint',
-            args: [to, tokenURI],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtBurn({ tokenId, account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'burn',
-            args: [tokenId],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtDeactivateAllMemberships({ user, account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'deactivateAllMemberships',
-            args: [user],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtSetBaseURI({ baseURI, account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'setBaseURI',
-            args: [baseURI],
-            account: account,
-            chain: client.chain
-        });
+    async burnSBT({ user, account }) {
+        try {
+            validateAddress(user, 'user');
+            return await client.writeContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'burnSBT',
+                args: [user],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'burnSBT');
+        }
+    },
+    async setBaseURI({ baseURI, account }) {
+        try {
+            validateRequired(baseURI, 'baseURI');
+            return await client.writeContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'setBaseURI',
+                args: [baseURI],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setBaseURI');
+        }
+    },
+    // Membership Management
+    async leaveCommunity({ community, account }) {
+        try {
+            validateAddress(community, 'community');
+            return await client.writeContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'leaveCommunity',
+                args: [community],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'leaveCommunity');
+        }
+    },
+    async deactivateMembership({ user, community, account }) {
+        try {
+            validateAddress(user, 'user');
+            validateAddress(community, 'community');
+            return await client.writeContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'deactivateMembership',
+                args: [user, community],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'deactivateMembership');
+        }
+    },
+    async deactivateAllMemberships({ user, account }) {
+        try {
+            validateAddress(user, 'user');
+            return await client.writeContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'deactivateAllMemberships',
+                args: [user],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'deactivateAllMemberships');
+        }
+    },
+    // Activity & Reputation
+    async recordActivity({ user, account }) {
+        try {
+            validateAddress(user, 'user');
+            return await client.writeContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'recordActivity',
+                args: [user],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'recordActivity');
+        }
+    },
+    async lastActivityTime({ tokenId, community }) {
+        try {
+            validateRequired(tokenId, 'tokenId');
+            validateAddress(community, 'community');
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'lastActivityTime',
+                args: [tokenId, community]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'lastActivityTime');
+        }
+    },
+    async weeklyActivity({ tokenId, community, week }) {
+        try {
+            validateRequired(tokenId, 'tokenId');
+            validateAddress(community, 'community');
+            validateRequired(week, 'week');
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'weeklyActivity',
+                args: [tokenId, community, week]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'weeklyActivity');
+        }
+    },
+    async reputationCalculator() {
+        try {
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'reputationCalculator',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'reputationCalculator');
+        }
+    },
+    async setReputationCalculator({ calculator, account }) {
+        try {
+            validateAddress(calculator, 'calculator');
+            return await client.writeContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'setReputationCalculator',
+                args: [calculator],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setReputationCalculator');
+        }
+    },
+    // Mint Fee & Lock
+    async mintFee() {
+        try {
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'mintFee',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'mintFee');
+        }
+    },
+    async setMintFee({ fee, account }) {
+        try {
+            validateAmount(fee, 'fee');
+            return await client.writeContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'setMintFee',
+                args: [fee],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setMintFee');
+        }
+    },
+    async minLockAmount() {
+        try {
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'minLockAmount',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'minLockAmount');
+        }
+    },
+    async setMinLockAmount({ amount, account }) {
+        try {
+            validateAmount(amount, 'amount');
+            return await client.writeContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'setMinLockAmount',
+                args: [amount],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setMinLockAmount');
+        }
+    },
+    // Pause
+    async pause({ account }) {
+        try {
+            return await client.writeContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'pause',
+                args: [],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'pause');
+        }
+    },
+    async unpause({ account }) {
+        try {
+            return await client.writeContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'unpause',
+                args: [],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'unpause');
+        }
+    },
+    async paused() {
+        try {
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'paused',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'paused');
+        }
+    },
+    // DAO & Config
+    async daoMultisig() {
+        try {
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'daoMultisig',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'daoMultisig');
+        }
+    },
+    async setDAOMultisig({ multisig, account }) {
+        try {
+            validateAddress(multisig, 'multisig');
+            return await client.writeContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'setDAOMultisig',
+                args: [multisig],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setDAOMultisig');
+        }
+    },
+    async setRegistry({ registry, account }) {
+        try {
+            validateAddress(registry, 'registry');
+            return await client.writeContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'setRegistry',
+                args: [registry],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setRegistry');
+        }
+    },
+    // Version
+    async version() {
+        try {
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'version',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'version');
+        }
     },
     // Constants
-    async sbtREGISTRY() {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'REGISTRY',
-            args: []
-        });
-    },
-    async sbtGTOKEN_STAKING() {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'GTOKEN_STAKING',
-            args: []
-        });
-    },
-    async sbtGTOKEN() {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'GTOKEN',
-            args: []
-        });
-    },
-    async sbtSUPER_PAYMASTER() {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'SUPER_PAYMASTER',
-            args: []
-        });
+    async REGISTRY() {
+        try {
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'REGISTRY',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'REGISTRY');
+        }
+    },
+    async GTOKEN_STAKING() {
+        try {
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'GTOKEN_STAKING',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'GTOKEN_STAKING');
+        }
+    },
+    async GTOKEN() {
+        try {
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'GTOKEN',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'GTOKEN');
+        }
     },
     // Ownership
-    async sbtOwner() {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'owner',
-            args: []
-        });
-    },
-    async sbtTransferSBTOwnership({ newOwner, account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'transferOwnership',
-            args: [newOwner],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtRenounceOwnership({ account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'renounceOwnership',
-            args: [],
-            account: account,
-            chain: client.chain
-        });
-    },
-    // Additional SBT-specific functions
-    async sbtMintForRole({ roleId, to, account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'mintForRole',
-            args: [roleId, to],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtGetMemberships({ user }) {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'getMemberships',
-            args: [user]
-        });
-    },
-    async sbtGetActiveMemberships({ user }) {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'getActiveMemberships',
-            args: [user]
-        });
-    },
-    async sbtVerifyCommunityMembership({ user, community }) {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'verifyCommunityMembership',
-            args: [user, community]
-        });
-    },
-    async sbtUserToSBT({ user }) {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'userToSBT',
-            args: [user]
-        });
-    },
-    async sbtSbtData({ tokenId }) {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'sbtData',
-            args: [tokenId]
-        });
-    },
-    async sbtMembershipIndex({ user, index }) {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'membershipIndex',
-            args: [user, index]
-        });
-    },
-    async sbtSupportsInterface({ interfaceId }) {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'supportsInterface',
-            args: [interfaceId]
-        });
-    },
-    async sbtNextTokenId() {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'nextTokenId',
-            args: []
-        });
-    },
-    async sbtBurnSBT({ tokenId, account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'burnSBT',
-            args: [tokenId],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtLeaveCommunity({ community, account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'leaveCommunity',
-            args: [community],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtDeactivateMembership({ tokenId, account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'deactivateMembership',
-            args: [tokenId],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtRecordActivity({ user, account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'recordActivity',
-            args: [user],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtLastActivityTime({ user }) {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'lastActivityTime',
-            args: [user]
-        });
-    },
-    async sbtWeeklyActivity({ user }) {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'weeklyActivity',
-            args: [user]
-        });
-    },
-    async sbtReputationCalculator() {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'reputationCalculator',
-            args: []
-        });
-    },
-    async sbtSetReputationCalculator({ calculator, account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'setReputationCalculator',
-            args: [calculator],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtMintFee() {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'mintFee',
-            args: []
-        });
-    },
-    async sbtSetMintFee({ fee, account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'setMintFee',
-            args: [fee],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtMinLockAmount() {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'minLockAmount',
-            args: []
-        });
-    },
-    async sbtSetMinLockAmount({ amount, account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'setMinLockAmount',
-            args: [amount],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtPause({ account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'pause',
-            args: [],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtUnpause({ account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'unpause',
-            args: [],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtPaused() {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'paused',
-            args: []
-        });
-    },
-    async sbtDaoMultisig() {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'daoMultisig',
-            args: []
-        });
-    },
-    async sbtSetDAOMultisig({ multisig, account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'setDAOMultisig',
-            args: [multisig],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtSetRegistry({ registry, account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'setRegistry',
-            args: [registry],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtSetSuperPaymaster({ paymaster, account }) {
-        return client.writeContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'setSuperPaymaster',
-            args: [paymaster],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async sbtVersion() {
-        return client.readContract({
-            address,
-            abi: MySBTABI,
-            functionName: 'version',
-            args: []
-        });
+    async owner() {
+        try {
+            return await client.readContract({
+                address,
+                abi: MySBTABI,
+                functionName: 'owner',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'owner');
+        }
+    },
+    async transferOwnership({ newOwner, account }) {
+        try {
+            validateAddress(newOwner, 'newOwner');
+            return await client.writeContract({
+                address,
+                abi: MySBTABI,
+                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: MySBTABI,
+                functionName: 'renounceOwnership',
+                args: [],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'renounceOwnership');
+        }
     }
 });