@aastar/core 0.16.7

package/dist/actions/staking.js

@@ -0,0 +1,330 @@
+import { GTokenStakingABI } from '../abis/index.js';
+export const stakingActions = (address) => (client) => ({
+    // Staking Operations
+    /**
+     * @internal
+     * @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
+        });
+    },
+    async unlockStake({ user, roleId, account }) {
+        return client.writeContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'unlockAndTransfer',
+            args: [user, roleId],
+            account: account,
+            chain: client.chain
+        });
+    },
+    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
+        });
+    },
+    // 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 setAuthorizedSlasher({ slasher, authorized, account }) {
+        return client.writeContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'setAuthorizedSlasher',
+            args: [slasher, authorized],
+            account: account,
+            chain: client.chain
+        });
+    },
+    // Query Functions
+    async getStakeInfo({ operator, roleId }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'stakes',
+            args: [operator]
+        });
+    },
+    async getStakingBalance({ user }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'balanceOf',
+            args: [user]
+        });
+    },
+    async getLockedStake({ user, roleId }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'getLockedStake',
+            args: [user, roleId]
+        });
+    },
+    async getUserRoleLocks({ user }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'getUserRoleLocks',
+            args: [user]
+        });
+    },
+    async hasRoleLock({ user, roleId }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'hasRoleLock',
+            args: [user, roleId]
+        });
+    },
+    async availableBalance({ user }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'availableBalance',
+            args: [user]
+        });
+    },
+    async previewExitFee({ user, roleId }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'previewExitFee',
+            args: [user, roleId]
+        });
+    },
+    // 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
+        });
+    },
+    async setTreasury({ treasury, account }) {
+        return client.writeContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'setTreasury',
+            args: [treasury],
+            account: account,
+            chain: client.chain
+        });
+    },
+    // View Functions
+    async stakes({ user }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'stakes',
+            args: [user]
+        });
+    },
+    async roleLocks({ user, roleId }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'roleLocks',
+            args: [user, roleId]
+        });
+    },
+    async roleExitConfigs({ roleId }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'roleExitConfigs',
+            args: [roleId]
+        });
+    },
+    async userActiveRoles({ user, index }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'userActiveRoles',
+            args: [user, index]
+        });
+    },
+    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]
+        });
+    },
+    async totalStaked() {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'totalStaked',
+            args: []
+        });
+    },
+    async getTotalStaked() {
+        return this.totalStaked();
+    },
+    async treasury() {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'treasury',
+            args: []
+        });
+    },
+    async owner() {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'owner',
+            args: []
+        });
+    },
+    // Ownership
+    async transferStakingOwnership({ newOwner, account }) {
+        return client.writeContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'transferOwnership',
+            args: [newOwner],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async renounceOwnership({ account }) {
+        return client.writeContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'renounceOwnership',
+            args: [],
+            account: account,
+            chain: client.chain
+        });
+    },
+    // Version
+    async version() {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'version',
+            args: []
+        });
+    },
+    // Constants
+    async REGISTRY() {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'REGISTRY',
+            args: []
+        });
+    },
+    async GTOKEN() {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'GTOKEN',
+            args: []
+        });
+    }
+});

package/dist/actions/staking.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/actions/staking.test.js

@@ -0,0 +1,223 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { stakingActions } from './staking.js';
+describe('Staking Actions', () => {
+    const mockStakingAddress = '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb';
+    let mockPublicClient;
+    let mockWalletClient;
+    let mockAccount;
+    const MOCK_USER = '0x1234567890123456789012345678901234567890';
+    const MOCK_ROLE_ID = '0xabcd...';
+    beforeEach(() => {
+        mockAccount = {
+            address: MOCK_USER,
+            type: 'json-rpc'
+        };
+        mockPublicClient = {
+            readContract: vi.fn(),
+        };
+        mockWalletClient = {
+            writeContract: vi.fn(),
+            account: mockAccount,
+        };
+    });
+    describe('Query functions', () => {
+        it('should get staking balance', async () => {
+            const mockBalance = 1000000000000000000000n;
+            mockPublicClient.readContract.mockResolvedValue(mockBalance);
+            const actions = stakingActions(mockStakingAddress)(mockPublicClient);
+            const balance = await actions.getStakingBalance({ user: MOCK_USER });
+            expect(balance).toBe(mockBalance);
+        });
+        it('should get locked stake', async () => {
+            const mockLocked = 500000000000000000000n;
+            mockPublicClient.readContract.mockResolvedValue(mockLocked);
+            const actions = stakingActions(mockStakingAddress)(mockPublicClient);
+            const locked = await actions.getLockedStake({ user: MOCK_USER, roleId: MOCK_ROLE_ID });
+            expect(locked).toBe(mockLocked);
+        });
+        it('should get available balance', async () => {
+            const mockAvailable = 500000000000000000000n;
+            mockPublicClient.readContract.mockResolvedValue(mockAvailable);
+            const actions = stakingActions(mockStakingAddress)(mockPublicClient);
+            const available = await actions.availableBalance({ user: MOCK_USER });
+            expect(available).toBe(mockAvailable);
+        });
+        it('should check if user has role lock', async () => {
+            mockPublicClient.readContract.mockResolvedValue(true);
+            const actions = stakingActions(mockStakingAddress)(mockPublicClient);
+            const hasLock = await actions.hasRoleLock({ user: MOCK_USER, roleId: MOCK_ROLE_ID });
+            expect(hasLock).toBe(true);
+        });
+        it('should get user role locks', async () => {
+            const mockLocks = [{ roleId: MOCK_ROLE_ID, amount: 1000n }];
+            mockPublicClient.readContract.mockResolvedValue(mockLocks);
+            const actions = stakingActions(mockStakingAddress)(mockPublicClient);
+            const locks = await actions.getUserRoleLocks({ user: MOCK_USER });
+            expect(locks).toEqual(mockLocks);
+        });
+        it('should preview exit fee', async () => {
+            const mockFee = 10000000000000000n; // 0.01 ETH
+            mockPublicClient.readContract.mockResolvedValue(mockFee);
+            const actions = stakingActions(mockStakingAddress)(mockPublicClient);
+            const fee = await actions.previewExitFee({ user: MOCK_USER, roleId: MOCK_ROLE_ID });
+            expect(fee).toBe(mockFee);
+        });
+    });
+    describe('Staking operations', () => {
+        it('should lock stake', async () => {
+            const txHash = '0xabc...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = stakingActions(mockStakingAddress)(mockWalletClient);
+            const result = await actions.lockStake({
+                user: MOCK_USER,
+                roleId: MOCK_ROLE_ID,
+                stakeAmount: 1000n,
+                entryBurn: 10n,
+                payer: MOCK_USER,
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+        });
+        it('should unlock stake', async () => {
+            const txHash = '0xdef...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = stakingActions(mockStakingAddress)(mockWalletClient);
+            const result = await actions.unlockStake({
+                user: MOCK_USER,
+                roleId: MOCK_ROLE_ID,
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+        });
+        it('should unlock and transfer', async () => {
+            const txHash = '0xghi...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = stakingActions(mockStakingAddress)(mockWalletClient);
+            const result = await actions.unlockAndTransfer({
+                user: MOCK_USER,
+                roleId: MOCK_ROLE_ID,
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+        });
+    });
+    describe('Slashing operations', () => {
+        it('should slash user stake', async () => {
+            const txHash = '0xjkl...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = stakingActions(mockStakingAddress)(mockWalletClient);
+            const result = await actions.slash({
+                user: MOCK_USER,
+                roleId: MOCK_ROLE_ID,
+                amount: 100n,
+                reason: 'Violation',
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+        });
+        it('should slash by DVT', async () => {
+            const txHash = '0xmno...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = stakingActions(mockStakingAddress)(mockWalletClient);
+            const result = await actions.slashByDVT({
+                user: MOCK_USER,
+                roleId: MOCK_ROLE_ID,
+                amount: 50n,
+                reason: 'DVT slash',
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+        });
+        it('should set authorized slasher', async () => {
+            const txHash = '0xpqr...';
+            const slasher = '0x99999999999999999999999999999999999999';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = stakingActions(mockStakingAddress)(mockWalletClient);
+            const result = await actions.setAuthorizedSlasher({
+                slasher,
+                authorized: true,
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+        });
+    });
+    describe('Advanced Query Functions', () => {
+        it('should get stake info', async () => {
+            mockPublicClient.readContract.mockResolvedValue({ amount: 100n });
+            const actions = stakingActions(mockStakingAddress)(mockPublicClient);
+            const info = await actions.getStakeInfo({ operator: MOCK_USER, roleId: MOCK_ROLE_ID });
+            expect(info.amount).toBe(100n);
+        });
+        it('should query stakes and role locks', async () => {
+            mockPublicClient.readContract
+                .mockResolvedValueOnce({ amount: 100n }) // stakes
+                .mockResolvedValueOnce({ amount: 50n }); // roleLocks
+            const actions = stakingActions(mockStakingAddress)(mockPublicClient);
+            const stake = await actions.stakes({ user: MOCK_USER });
+            const lock = await actions.roleLocks({ user: MOCK_USER, roleId: MOCK_ROLE_ID });
+            expect(stake.amount).toBe(100n);
+            expect(lock.amount).toBe(50n);
+        });
+        it('should query exit configs and active roles', async () => {
+            mockPublicClient.readContract
+                .mockResolvedValueOnce({ feePercent: 10n }) // roleExitConfigs
+                .mockResolvedValueOnce(MOCK_ROLE_ID); // userActiveRoles
+            const actions = stakingActions(mockStakingAddress)(mockPublicClient);
+            const config = await actions.roleExitConfigs({ roleId: MOCK_ROLE_ID });
+            const role = await actions.userActiveRoles({ user: MOCK_USER, index: 0n });
+            expect(config.feePercent).toBe(10n);
+            expect(role).toBe(MOCK_ROLE_ID);
+        });
+        it('should query total staked and system status', async () => {
+            mockPublicClient.readContract
+                .mockResolvedValueOnce(1000n) // totalStaked
+                .mockResolvedValueOnce(1000n) // totalStaked (via getTotalStaked)
+                .mockResolvedValueOnce(true); // authorizedSlashers
+            const actions = stakingActions(mockStakingAddress)(mockPublicClient);
+            const total = await actions.totalStaked();
+            const total2 = await actions.getTotalStaked();
+            const authorized = await actions.authorizedSlashers({ slasher: MOCK_USER });
+            expect(total).toBe(1000n);
+            expect(total2).toBe(1000n);
+            expect(authorized).toBe(true);
+        });
+    });
+    describe('System Configuration & Ownership', () => {
+        it('should manage treasury and registry', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = stakingActions(mockStakingAddress)(mockWalletClient);
+            const tx1 = await actions.setTreasury({ treasury: MOCK_USER, account: mockAccount });
+            const tx2 = await actions.setRegistry({ registry: MOCK_USER, account: mockAccount });
+            expect(tx1).toBe(txHash);
+            expect(tx2).toBe(txHash);
+        });
+        it('should handle ownership transfers', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = stakingActions(mockStakingAddress)(mockWalletClient);
+            const tx1 = await actions.transferStakingOwnership({ newOwner: MOCK_USER, account: mockAccount });
+            const tx2 = await actions.renounceOwnership({ account: mockAccount });
+            expect(tx1).toBe(txHash);
+            expect(tx2).toBe(txHash);
+        });
+        it('should query system references', async () => {
+            mockPublicClient.readContract.mockResolvedValue(MOCK_USER);
+            const actions = stakingActions(mockStakingAddress)(mockPublicClient);
+            const r = await actions.REGISTRY();
+            const g = await actions.GTOKEN();
+            const t = await actions.treasury();
+            const o = await actions.owner();
+            expect(r).toBe(MOCK_USER);
+            expect(g).toBe(MOCK_USER);
+            expect(t).toBe(MOCK_USER);
+            expect(o).toBe(MOCK_USER);
+        });
+        it('should get version', async () => {
+            mockPublicClient.readContract.mockResolvedValue('v1');
+            const actions = stakingActions(mockStakingAddress)(mockPublicClient);
+            const v = await actions.version();
+            expect(v).toBe('v1');
+        });
+    });
+});