@aastar/core 0.16.7 → 0.16.11

package/dist/actions/staking.js

@@ -1,4 +1,6 @@
 import { GTokenStakingABI } from '../abis/index.js';
+import { validateAddress, validateAmount, validateRequired } from '../validators/index.js';
+import { AAStarError } from '../errors/index.js';
 export const stakingActions = (address) => (client) => ({
     // Staking Operations
     /**
@@ -6,325 +8,494 @@ export const stakingActions = (address) => (client) => ({
      * @warning This is a low-level internal API. Use high-level clients instead.
      */
     async lockStake({ user, roleId, stakeAmount, entryBurn, payer, account }) {
-        return client.writeContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'lockStake',
-            args: [user, roleId, stakeAmount, entryBurn, payer],
-            account: account,
-            chain: client.chain
-        });
+        try {
+            validateAddress(user, 'user');
+            validateAddress(payer, 'payer');
+            validateAmount(stakeAmount, 'stakeAmount');
+            validateAmount(entryBurn, 'entryBurn');
+            return await client.writeContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'lockStake',
+                args: [user, roleId, stakeAmount, entryBurn, payer],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'lockStake');
+        }
+    },
+    async topUpStake({ user, roleId, stakeAmount, payer, account }) {
+        try {
+            validateAddress(user, 'user');
+            validateAddress(payer, 'payer');
+            validateAmount(stakeAmount, 'stakeAmount');
+            return await client.writeContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'topUpStake',
+                args: [user, roleId, stakeAmount, payer],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'topUpStake');
+        }
     },
     async unlockStake({ user, roleId, account }) {
-        return client.writeContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'unlockAndTransfer',
-            args: [user, roleId],
-            account: account,
-            chain: client.chain
-        });
+        try {
+            validateAddress(user, 'user');
+            validateRequired(roleId, 'roleId');
+            return await client.writeContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'unlockAndTransfer',
+                args: [user, roleId],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'unlockStake');
+        }
     },
     async unlockAndTransfer({ user, roleId, account }) {
-        return client.writeContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'unlockAndTransfer',
-            args: [user, roleId],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async stake({ amount, account }) {
-        return client.writeContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'stake',
-            args: [amount],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async topUpStake({ amount, account }) {
-        // topUpStake typically calls stake internally or is a distinct function. Assuming distinct based on request.
-        return client.writeContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'topUpStake',
-            args: [amount],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async unstake({ amount, account }) {
-        return client.writeContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'unstake',
-            args: [amount],
-            account: account,
-            chain: client.chain
-        });
+        try {
+            validateAddress(user, 'user');
+            validateRequired(roleId, 'roleId');
+            return await client.writeContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'unlockAndTransfer',
+                args: [user, roleId],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'unlockAndTransfer');
+        }
     },
     // Slashing
-    async slash({ user, roleId, amount, reason, account }) {
-        return client.writeContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'slash',
-            args: [user, roleId, amount, reason],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async slashByDVT({ user, roleId, amount, reason, account }) {
-        return client.writeContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'slashByDVT',
-            args: [user, roleId, amount, reason],
-            account: account,
-            chain: client.chain
-        });
+    async slash({ user, amount, reason, account }) {
+        try {
+            validateAddress(user, 'user');
+            validateAmount(amount, 'amount');
+            return await client.writeContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'slash',
+                args: [user, amount, reason],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'slash');
+        }
+    },
+    async slashByDVT({ operator, roleId, penaltyAmount, reason, account }) {
+        try {
+            validateAddress(operator, 'operator');
+            validateRequired(roleId, 'roleId');
+            validateAmount(penaltyAmount, 'penaltyAmount');
+            return await client.writeContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'slashByDVT',
+                args: [operator, roleId, penaltyAmount, reason],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'slashByDVT');
+        }
     },
     async setAuthorizedSlasher({ slasher, authorized, account }) {
-        return client.writeContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'setAuthorizedSlasher',
-            args: [slasher, authorized],
-            account: account,
-            chain: client.chain
-        });
+        try {
+            validateAddress(slasher, 'slasher');
+            return await client.writeContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'setAuthorizedSlasher',
+                args: [slasher, authorized],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setAuthorizedSlasher');
+        }
     },
     // Query Functions
     async getStakeInfo({ operator, roleId }) {
-        return client.readContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'stakes',
-            args: [operator]
-        });
+        try {
+            validateAddress(operator, 'operator');
+            validateRequired(roleId, 'roleId');
+            const res = await client.readContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'getStakeInfo',
+                args: [operator, roleId]
+            });
+            return {
+                amount: res.amount,
+                slashedAmount: res.slashedAmount,
+                stakedAt: res.stakedAt,
+                unstakeRequestedAt: res.unstakeRequestedAt
+            };
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getStakeInfo');
+        }
     },
     async getStakingBalance({ user }) {
-        return client.readContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'balanceOf',
-            args: [user]
-        });
+        try {
+            validateAddress(user, 'user');
+            return await client.readContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'balanceOf',
+                args: [user]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getStakingBalance');
+        }
     },
     async getLockedStake({ user, roleId }) {
-        return client.readContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'getLockedStake',
-            args: [user, roleId]
-        });
+        try {
+            validateAddress(user, 'user');
+            validateRequired(roleId, 'roleId');
+            return await client.readContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'getLockedStake',
+                args: [user, roleId]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getLockedStake');
+        }
     },
     async getUserRoleLocks({ user }) {
-        return client.readContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'getUserRoleLocks',
-            args: [user]
-        });
+        try {
+            validateAddress(user, 'user');
+            return await client.readContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'getUserRoleLocks',
+                args: [user]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getUserRoleLocks');
+        }
     },
     async hasRoleLock({ user, roleId }) {
-        return client.readContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'hasRoleLock',
-            args: [user, roleId]
-        });
+        try {
+            validateAddress(user, 'user');
+            validateRequired(roleId, 'roleId');
+            return await client.readContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'hasRoleLock',
+                args: [user, roleId]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'hasRoleLock');
+        }
     },
     async availableBalance({ user }) {
-        return client.readContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'availableBalance',
-            args: [user]
-        });
+        try {
+            validateAddress(user, 'user');
+            return await client.readContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'availableBalance',
+                args: [user]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'availableBalance');
+        }
     },
     async previewExitFee({ user, roleId }) {
-        return client.readContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'previewExitFee',
-            args: [user, roleId]
-        });
+        try {
+            validateAddress(user, 'user');
+            validateRequired(roleId, 'roleId');
+            const [fee, netAmount] = await client.readContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'previewExitFee',
+                args: [user, roleId]
+            });
+            return { fee, netAmount };
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'previewExitFee');
+        }
     },
     // Admin Functions
     async setRegistry({ registry, account }) {
-        return client.writeContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'setRegistry',
-            args: [registry],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async transferOwnership({ newOwner, account }) {
-        return client.writeContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'transferOwnership',
-            args: [newOwner],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async setRoleExitFee({ roleId, feePercent, account }) {
-        return client.writeContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'setRoleExitFee',
-            args: [roleId, feePercent],
-            account: account,
-            chain: client.chain
-        });
+        try {
+            validateAddress(registry, 'registry');
+            return await client.writeContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'setRegistry',
+                args: [registry],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setRegistry');
+        }
+    },
+    async setRoleExitFee({ roleId, feePercent, minFee, account }) {
+        try {
+            validateRequired(roleId, 'roleId');
+            validateAmount(feePercent, 'feePercent');
+            validateAmount(minFee, 'minFee');
+            return await client.writeContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'setRoleExitFee',
+                args: [roleId, feePercent, minFee],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setRoleExitFee');
+        }
     },
     async setTreasury({ treasury, account }) {
-        return client.writeContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'setTreasury',
-            args: [treasury],
-            account: account,
-            chain: client.chain
-        });
+        try {
+            validateAddress(treasury, 'treasury');
+            return await client.writeContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'setTreasury',
+                args: [treasury],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setTreasury');
+        }
     },
     // View Functions
     async stakes({ user }) {
-        return client.readContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'stakes',
-            args: [user]
-        });
+        try {
+            validateAddress(user, 'user');
+            const res = await client.readContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'stakes',
+                args: [user]
+            });
+            if (Array.isArray(res)) {
+                return {
+                    amount: res[0],
+                    slashedAmount: res[1],
+                    stakedAt: res[2],
+                    unstakeRequestedAt: res[3]
+                };
+            }
+            return res;
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'stakes');
+        }
     },
     async roleLocks({ user, roleId }) {
-        return client.readContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'roleLocks',
-            args: [user, roleId]
-        });
+        try {
+            validateAddress(user, 'user');
+            validateRequired(roleId, 'roleId');
+            const res = await client.readContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'roleLocks',
+                args: [user, roleId]
+            });
+            if (Array.isArray(res)) {
+                return {
+                    amount: res[0],
+                    entryBurn: res[1],
+                    lockedAt: Number(res[2]),
+                    roleId: res[3],
+                    metadata: res[4]
+                };
+            }
+            return res;
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'roleLocks');
+        }
     },
     async roleExitConfigs({ roleId }) {
-        return client.readContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'roleExitConfigs',
-            args: [roleId]
-        });
+        try {
+            validateRequired(roleId, 'roleId');
+            const [feePercent, minFee] = await client.readContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'roleExitConfigs',
+                args: [roleId]
+            });
+            return { feePercent, minFee };
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'roleExitConfigs');
+        }
     },
     async userActiveRoles({ user, index }) {
-        return client.readContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'userActiveRoles',
-            args: [user, index]
-        });
+        try {
+            validateAddress(user, 'user');
+            return await client.readContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'userActiveRoles',
+                args: [user, index]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'userActiveRoles');
+        }
     },
     async authorizedSlashers({ slasher }) {
-        return client.readContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'authorizedSlashers',
-            args: [slasher]
-        });
-    },
-    async getStake({ account }) {
-        return client.readContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'getStake',
-            args: [account]
-        });
-    },
-    async balanceOf({ account }) {
-        // GTokenStaking might implement balanceOf if it's an ERC20-like or just tracking stakes
-        return client.readContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'balanceOf',
-            args: [account]
-        });
+        try {
+            validateAddress(slasher, 'slasher');
+            return await client.readContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'authorizedSlashers',
+                args: [slasher]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'authorizedSlashers');
+        }
     },
     async totalStaked() {
-        return client.readContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'totalStaked',
-            args: []
-        });
+        try {
+            return await client.readContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'totalStaked',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'totalStaked');
+        }
     },
     async getTotalStaked() {
         return this.totalStaked();
     },
     async treasury() {
-        return client.readContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'treasury',
-            args: []
-        });
+        try {
+            return await client.readContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'treasury',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'treasury');
+        }
     },
     async owner() {
-        return client.readContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'owner',
-            args: []
-        });
+        try {
+            return await client.readContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'owner',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'owner');
+        }
     },
     // Ownership
-    async transferStakingOwnership({ newOwner, account }) {
-        return client.writeContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'transferOwnership',
-            args: [newOwner],
-            account: account,
-            chain: client.chain
-        });
+    async transferOwnership({ newOwner, account }) {
+        try {
+            validateAddress(newOwner, 'newOwner');
+            return await client.writeContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'transferOwnership',
+                args: [newOwner],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'transferOwnership');
+        }
     },
     async renounceOwnership({ account }) {
-        return client.writeContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'renounceOwnership',
-            args: [],
-            account: account,
-            chain: client.chain
-        });
+        try {
+            return await client.writeContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'renounceOwnership',
+                args: [],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'renounceOwnership');
+        }
     },
     // Version
     async version() {
-        return client.readContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'version',
-            args: []
-        });
+        try {
+            return await client.readContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'version',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'version');
+        }
     },
     // Constants
     async REGISTRY() {
-        return client.readContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'REGISTRY',
-            args: []
-        });
+        try {
+            return await client.readContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'REGISTRY',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'REGISTRY');
+        }
     },
     async GTOKEN() {
-        return client.readContract({
-            address,
-            abi: GTokenStakingABI,
-            functionName: 'GTOKEN',
-            args: []
-        });
+        try {
+            return await client.readContract({
+                address,
+                abi: GTokenStakingABI,
+                functionName: 'GTOKEN',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'GTOKEN');
+        }
     }
 });