@aastar/sdk 0.16.6 → 0.16.11

package/packages/core/__tests__/actions/registry.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { registryActions } from '../../src/actions/registry';
+import { createMockPublicClient, createMockWalletClient, resetMocks } from '../mocks/client';
+
+const ADDR = '0x1111111111111111111111111111111111111111' as `0x${string}`;
+const USER = '0x2222222222222222222222222222222222222222' as `0x${string}`;
+
+describe('RegistryActions Bulk Coverage', () => {
+  let p: any;
+  let w: any;
+  beforeEach(() => { resetMocks(); p = createMockPublicClient(); w = createMockWalletClient(); });
+
+  describe('Role Management (Writes)', () => {
+    it('adminConfigureRole', async () => { w.writeContract.mockResolvedValue('0x'); await registryActions(ADDR)(w).adminConfigureRole({ roleId: '0x01', minStake: 1n, entryBurn: 1n, exitFeePercent: 1n, minExitFee: 1n, account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('createNewRole', async () => { w.writeContract.mockResolvedValue('0x'); await registryActions(ADDR)(w).createNewRole({ roleId: '0x01', config: {} as any, roleOwner: USER, account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('setRoleLockDuration', async () => { w.writeContract.mockResolvedValue('0x'); await registryActions(ADDR)(w).setRoleLockDuration({ roleId: '0x01', duration: 100n, account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('setRoleOwner', async () => { w.writeContract.mockResolvedValue('0x'); await registryActions(ADDR)(w).setRoleOwner({ roleId: '0x01', newOwner: USER, account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('exitRole', async () => { w.writeContract.mockResolvedValue('0x'); await registryActions(ADDR)(w).exitRole({ roleId: '0x01', account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+  });
+
+  describe('Community & Credit (Views/Writes)', () => {
+    it('communityByName', async () => { p.readContract.mockResolvedValue(USER); expect(await registryActions(ADDR)(p).communityByName({ name: 'test' })).toBe(USER); });
+    it('communityByENS', async () => { p.readContract.mockResolvedValue(USER); expect(await registryActions(ADDR)(p).communityByENS({ ensName: 'test.eth' })).toBe(USER); });
+    it('getCreditLimit', async () => { p.readContract.mockResolvedValue(100n); expect(await registryActions(ADDR)(p).getCreditLimit({ user: USER })).toBe(100n); });
+    it('globalReputation', async () => { p.readContract.mockResolvedValue(100n); expect(await registryActions(ADDR)(p).globalReputation({ user: USER })).toBe(100n); });
+    it('addLevelThreshold', async () => { w.writeContract.mockResolvedValue('0x'); await registryActions(ADDR)(w).addLevelThreshold({ threshold: 100n, account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('batchUpdateGlobalReputation', async () => { w.writeContract.mockResolvedValue('0x'); await registryActions(ADDR)(w).batchUpdateGlobalReputation({ proposalId: 1n, users: [USER], newScores: [100n], epoch: 1n, proof: '0x', account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+  });
+
+  describe('Contract References (Setters)', () => {
+    it('setBLSValidator', async () => { w.writeContract.mockResolvedValue('0x'); await registryActions(ADDR)(w).setBLSValidator({ validator: USER, account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('setBLSAggregator', async () => { w.writeContract.mockResolvedValue('0x'); await registryActions(ADDR)(w).setBLSAggregator({ aggregator: USER, account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('setMySBT', async () => { w.writeContract.mockResolvedValue('0x'); await registryActions(ADDR)(w).setMySBT({ sbt: USER, account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('setSuperPaymaster', async () => { w.writeContract.mockResolvedValue('0x'); await registryActions(ADDR)(w).setSuperPaymaster({ paymaster: USER, account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('setStaking', async () => { w.writeContract.mockResolvedValue('0x'); await registryActions(ADDR)(w).setStaking({ staking: USER, account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('setReputationSource', async () => { w.writeContract.mockResolvedValue('0x'); await registryActions(ADDR)(w).setReputationSource({ source: USER, account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+  });
+
+  describe('Contract References (Getters)', () => {
+    it('blsValidator', async () => { p.readContract.mockResolvedValue(USER); expect(await registryActions(ADDR)(p).blsValidator()).toBe(USER); });
+    it('blsAggregator', async () => { p.readContract.mockResolvedValue(USER); expect(await registryActions(ADDR)(p).blsAggregator()).toBe(USER); });
+    it('MYSBT', async () => { p.readContract.mockResolvedValue(USER); expect(await registryActions(ADDR)(p).MYSBT()).toBe(USER); });
+    it('SUPER_PAYMASTER', async () => { p.readContract.mockResolvedValue(USER); expect(await registryActions(ADDR)(p).SUPER_PAYMASTER()).toBe(USER); });
+    it('GTOKEN_STAKING', async () => { p.readContract.mockResolvedValue(USER); expect(await registryActions(ADDR)(p).GTOKEN_STAKING()).toBe(USER); });
+    it('reputationSource', async () => { p.readContract.mockResolvedValue(USER); expect(await registryActions(ADDR)(p).reputationSource()).toBe(USER); });
+    it('isReputationSource', async () => { p.readContract.mockResolvedValue(true); expect(await registryActions(ADDR)(p).isReputationSource({ source: USER })).toBe(true); });
+    it('lastReputationEpoch', async () => { p.readContract.mockResolvedValue(1n); expect(await registryActions(ADDR)(p).lastReputationEpoch({ user: USER })).toBe(1n); });
+  });
+
+  describe('View Functions', () => {
+    it('getRoleUserCount', async () => { p.readContract.mockResolvedValue(10n); expect(await registryActions(ADDR)(p).getRoleUserCount({ roleId: '0x01' })).toBe(10n); });
+    it('getRoleMembers', async () => { p.readContract.mockResolvedValue([USER]); expect(await registryActions(ADDR)(p).getRoleMembers({ roleId: '0x01' })).toEqual([USER]); });
+    it('getUserRoles', async () => { p.readContract.mockResolvedValue(['0x01']); expect(await registryActions(ADDR)(p).getUserRoles({ user: USER })).toEqual(['0x01']); });
+    it('roleMembers', async () => { p.readContract.mockResolvedValue(USER); expect(await registryActions(ADDR)(p).roleMembers({ roleId: '0x01', index: 0n })).toBe(USER); });
+    it('userRoles', async () => { p.readContract.mockResolvedValue('0x01'); expect(await registryActions(ADDR)(p).userRoles({ user: USER, index: 0n })).toBe('0x01'); });
+    it('userRoleCount', async () => { p.readContract.mockResolvedValue(1n); expect(await registryActions(ADDR)(p).userRoleCount({ user: USER })).toBe(1n); });
+    it('creditTierConfig', async () => { p.readContract.mockResolvedValue(100n); expect(await registryActions(ADDR)(p).creditTierConfig({ tierIndex: 0n })).toBe(100n); });
+    it('levelThresholds', async () => { p.readContract.mockResolvedValue(100n); expect(await registryActions(ADDR)(p).levelThresholds({ levelIndex: 0n })).toBe(100n); });
+    it('calculateExitFee', async () => { p.readContract.mockResolvedValue(5n); expect(await registryActions(ADDR)(p).calculateExitFee({ roleId: '0x01', amount: 100n })).toBe(5n); });
+    it('accountToUser', async () => { p.readContract.mockResolvedValue(USER); expect(await registryActions(ADDR)(p).accountToUser({ account: USER })).toBe(USER); });
+    it('roleOwners', async () => { p.readContract.mockResolvedValue(USER); expect(await registryActions(ADDR)(p).roleOwners({ roleId: '0x01' })).toBe(USER); });
+    it('roleStakes', async () => { p.readContract.mockResolvedValue(100n); expect(await registryActions(ADDR)(p).roleStakes({ roleId: '0x01', user: USER })).toBe(100n); });
+    it('roleLockDurations', async () => { p.readContract.mockResolvedValue(100n); expect(await registryActions(ADDR)(p).roleLockDurations({ roleId: '0x01' })).toBe(100n); });
+  });
+
+  describe('Constants (Role IDs)', () => {
+    it('ROLE_COMMUNITY', async () => { p.readContract.mockResolvedValue('0x01'); expect(await registryActions(ADDR)(p).ROLE_COMMUNITY()).toBe('0x01'); });
+    it('ROLE_ENDUSER', async () => { p.readContract.mockResolvedValue('0x02'); expect(await registryActions(ADDR)(p).ROLE_ENDUSER()).toBe('0x02'); });
+    it('ROLE_PAYMASTER_SUPER', async () => { p.readContract.mockResolvedValue('0x03'); expect(await registryActions(ADDR)(p).ROLE_PAYMASTER_SUPER()).toBe('0x03'); });
+    it('ROLE_PAYMASTER_AOA', async () => { p.readContract.mockResolvedValue('0x04'); expect(await registryActions(ADDR)(p).ROLE_PAYMASTER_AOA()).toBe('0x04'); });
+    it('ROLE_DVT', async () => { p.readContract.mockResolvedValue('0x05'); expect(await registryActions(ADDR)(p).ROLE_DVT()).toBe('0x05'); });
+    it('ROLE_KMS', async () => { p.readContract.mockResolvedValue('0x06'); expect(await registryActions(ADDR)(p).ROLE_KMS()).toBe('0x06'); });
+    it('ROLE_ANODE', async () => { p.readContract.mockResolvedValue('0x07'); expect(await registryActions(ADDR)(p).ROLE_ANODE()).toBe('0x07'); });
+  });
+
+  describe('Ownership & Version', () => {
+    it('transferOwnership', async () => { w.writeContract.mockResolvedValue('0x'); await registryActions(ADDR)(w).transferOwnership({ newOwner: USER, account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('renounceOwnership', async () => { w.writeContract.mockResolvedValue('0x'); await registryActions(ADDR)(w).renounceOwnership({ account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('version', async () => { p.readContract.mockResolvedValue('1.0'); expect(await registryActions(ADDR)(p).version()).toBe('1.0'); });
+  });
+});

package/packages/core/__tests__/actions/reputation.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { reputationActions } from '../../src/actions/reputation';
+import { createMockPublicClient, createMockWalletClient, resetMocks } from '../mocks/client';
+
+const ADDR = '0x1111111111111111111111111111111111111111' as `0x${string}`;
+const USER = '0x2222222222222222222222222222222222222222' as `0x${string}`;
+
+describe('ReputationActions Bulk Coverage', () => {
+  let p: any;
+  let w: any;
+  beforeEach(() => { resetMocks(); p = createMockPublicClient(); w = createMockWalletClient(); });
+
+  describe('Rules & Scores', () => {
+    it('setReputationRule', async () => { w.writeContract.mockResolvedValue('0x'); await reputationActions(ADDR)(w).setReputationRule({ ruleId: '0x01', rule: {} as any, account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('getReputationRule', async () => { p.readContract.mockResolvedValue([0n, 0n, 0n, 'desc', true]); const res = await reputationActions(ADDR)(p).getReputationRule({ ruleId: '0x01' }); expect(res).toBeDefined(); });
+    it('enableRule', async () => { w.writeContract.mockResolvedValue('0x'); await reputationActions(ADDR)(w).enableRule({ ruleId: '0x01', account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('disableRule', async () => { w.writeContract.mockResolvedValue('0x'); await reputationActions(ADDR)(w).disableRule({ ruleId: '0x01', account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('isRuleActive', async () => { p.readContract.mockResolvedValue(true); expect(await reputationActions(ADDR)(p).isRuleActive({ ruleId: '0x01' })).toBe(true); });
+    it('getActiveRules', async () => { p.readContract.mockResolvedValue(['0x01']); expect(await reputationActions(ADDR)(p).getActiveRules({ community: ADDR })).toEqual(['0x01']); });
+    it('getRuleCount', async () => { p.readContract.mockResolvedValue(5n); expect(await reputationActions(ADDR)(p).getRuleCount()).toBe(5n); });
+    it('getUserScore', async () => { p.readContract.mockResolvedValue(100n); expect(await reputationActions(ADDR)(p).getUserScore({ user: USER })).toBe(100n); });
+    it('getCommunityScore', async () => { p.readContract.mockResolvedValue(500n); expect(await reputationActions(ADDR)(p).getCommunityScore({ community: ADDR })).toBe(500n); });
+  });
+
+  describe('NFT Boosts', () => {
+    it('setNFTBoost', async () => { w.writeContract.mockResolvedValue('0x'); await reputationActions(ADDR)(w).setNFTBoost({ collection: ADDR, boost: 10n, account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('nftCollectionBoost', async () => { p.readContract.mockResolvedValue(10n); expect(await reputationActions(ADDR)(p).nftCollectionBoost({ collection: ADDR })).toBe(10n); });
+    it('updateNFTHoldStart', async () => { w.writeContract.mockResolvedValue('0x'); await reputationActions(ADDR)(w).updateNFTHoldStart({ collection: ADDR, account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+  });
+
+  describe('Batch Operations & Sync', () => {
+    it('batchUpdateScores', async () => { w.writeContract.mockResolvedValue('0x'); await reputationActions(ADDR)(w).batchUpdateScores({ users: [USER], scores: [100n], account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('batchSyncToRegistry', async () => { w.writeContract.mockResolvedValue('0x'); await reputationActions(ADDR)(w).batchSyncToRegistry({ users: [USER], account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+  });
+
+  describe('Configuration & Meta', () => {
+    it('setRegistry', async () => { w.writeContract.mockResolvedValue('0x'); await reputationActions(ADDR)(w).setRegistry({ registry: ADDR, account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('setEntropyFactor', async () => { w.writeContract.mockResolvedValue('0x'); await reputationActions(ADDR)(w).setEntropyFactor({ community: ADDR, factor: 10n, account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('getEntropyFactor', async () => { p.readContract.mockResolvedValue(10n); expect(await reputationActions(ADDR)(p).getEntropyFactor()).toBe(10n); });
+    it('REGISTRY', async () => { p.readContract.mockResolvedValue(ADDR); expect(await reputationActions(ADDR)(p).REGISTRY()).toBe(ADDR); });
+    it('version', async () => { p.readContract.mockResolvedValue('1.0'); expect(await reputationActions(ADDR)(p).version()).toBe('1.0'); });
+  });
+});

package/packages/core/__tests__/actions/sbt.test.ts

@@ -0,0 +1,145 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { sbtActions } from '../../src/actions/sbt';
+import { createMockPublicClient, createMockWalletClient, resetMocks } from '../mocks/client';
+
+const ADDR = '0x1111111111111111111111111111111111111111' as `0x${string}`;
+const USER = '0x2222222222222222222222222222222222222222' as `0x${string}`;
+
+describe('SBTActions Exhaustive Coverage', () => {
+  let p: any;
+  let w: any;
+  beforeEach(() => { resetMocks(); p = createMockPublicClient(); w = createMockWalletClient(); });
+
+  describe('Minting & Burning', () => {
+    it('minting ops', async () => {
+      w.writeContract.mockResolvedValue('0x');
+      const act = sbtActions(ADDR)(w);
+      await act.airdropMint({ user: USER, roleId: '0x01', roleData: '0x', account: USER });
+      await act.mintForRole({ user: USER, roleId: '0x01', roleData: '0x', account: USER });
+      await act.burnSBT({ user: USER, account: USER });
+      expect(w.writeContract).toHaveBeenCalledTimes(3);
+    });
+  });
+
+  describe('Membership & Activity', () => {
+    it('membership ops', async () => {
+      w.writeContract.mockResolvedValue('0x');
+      const act = sbtActions(ADDR)(w);
+      await act.leaveCommunity({ community: ADDR, account: USER });
+      await act.deactivateMembership({ user: USER, community: ADDR, account: USER });
+      await act.deactivateAllMemberships({ user: USER, account: USER });
+      await act.recordActivity({ user: USER, account: USER });
+      expect(w.writeContract).toHaveBeenCalledTimes(4);
+    });
+    it('membership views', async () => {
+      const act = sbtActions(ADDR)(p);
+      p.readContract.mockResolvedValue(100n); // generic bigint
+      await act.getUserSBT({ user: USER });
+      await act.userToSBT({ user: USER });
+      await act.membershipIndex({ tokenId: 1n, community: ADDR });
+      await act.lastActivityTime({ tokenId: 1n, community: ADDR });
+      
+      p.readContract.mockResolvedValue([USER, USER, 0n, 1n]); // SBTData
+      await act.getSBTData({ tokenId: 1n });
+      await act.sbtData({ tokenId: 1n });
+      
+      p.readContract.mockResolvedValue([ADDR, 0n, 0n, true, 'meta']); // Membership
+      await act.getCommunityMembership({ tokenId: 1n, community: ADDR });
+      
+      p.readContract.mockResolvedValue([[ADDR, 0n, 0n, true, 'meta']]); // Memberships[]
+      await act.getMemberships({ tokenId: 1n });
+      
+      p.readContract.mockResolvedValue([ADDR]); // Address[]
+      await act.getActiveMemberships({ tokenId: 1n });
+      
+      p.readContract.mockResolvedValue(true); // bool
+      await act.verifyCommunityMembership({ user: USER, community: ADDR });
+      await act.weeklyActivity({ tokenId: 1n, community: ADDR, week: 1n });
+      
+      expect(p.readContract).toHaveBeenCalledTimes(11);
+    });
+  });
+
+  describe('ERC721 Standard', () => {
+    it('writes', async () => {
+      w.writeContract.mockResolvedValue('0x');
+      const act = sbtActions(ADDR)(w);
+      await act.safeTransferFrom({ from: USER, to: USER, tokenId: 1n, account: USER });
+      await act.transferFrom({ from: USER, to: USER, tokenId: 1n, account: USER });
+      await act.approve({ to: USER, tokenId: 1n, account: USER });
+      await act.setApprovalForAll({ operator: USER, approved: true, account: USER });
+      expect(w.writeContract).toHaveBeenCalledTimes(4);
+    });
+    it('views', async () => {
+      const act = sbtActions(ADDR)(p);
+      p.readContract.mockResolvedValue(1n);
+      await act.balanceOf({ owner: USER });
+      await act.nextTokenId();
+      
+      p.readContract.mockResolvedValue(USER);
+      await act.ownerOf({ tokenId: 1n });
+      await act.getApproved({ tokenId: 1n });
+      
+      p.readContract.mockResolvedValue(true);
+      await act.isApprovedForAll({ owner: USER, operator: USER });
+      await act.supportsInterface({ interfaceId: '0x01ffc9a7' });
+      
+      p.readContract.mockResolvedValue('uri');
+      await act.tokenURI({ tokenId: 1n });
+      await act.name();
+      await act.symbol();
+      
+      expect(p.readContract).toHaveBeenCalledTimes(9);
+    });
+  });
+
+  describe('Admin & Config', () => {
+    it('config setters', async () => {
+      w.writeContract.mockResolvedValue('0x');
+      const act = sbtActions(ADDR)(w);
+      await act.setBaseURI({ baseURI: 'uri', account: USER });
+      await act.setReputationCalculator({ calculator: USER, account: USER });
+      await act.setMintFee({ fee: 100n, account: USER });
+      await act.setMinLockAmount({ amount: 100n, account: USER });
+      await act.pause({ account: USER });
+      await act.unpause({ account: USER });
+      await act.setDAOMultisig({ multisig: USER, account: USER });
+      await act.setRegistry({ registry: USER, account: USER });
+      expect(w.writeContract).toHaveBeenCalledTimes(8);
+    });
+    it('config getters', async () => {
+      const act = sbtActions(ADDR)(p);
+      p.readContract.mockResolvedValue(USER);
+      await act.reputationCalculator();
+      await act.daoMultisig();
+      await act.REGISTRY();
+      await act.GTOKEN_STAKING();
+      await act.GTOKEN();
+      
+      p.readContract.mockResolvedValue(100n);
+      await act.mintFee();
+      await act.minLockAmount();
+      
+      p.readContract.mockResolvedValue(true);
+      await act.paused();
+      
+      p.readContract.mockResolvedValue('1.0');
+      await act.version();
+      
+      expect(p.readContract).toHaveBeenCalledTimes(9);
+    });
+    it('ownership', async () => {
+      const actP = sbtActions(ADDR)(p);
+      p.readContract.mockResolvedValue(USER);
+      await actP.owner();
+      
+      w.writeContract.mockResolvedValue('0x');
+      const actW = sbtActions(ADDR)(w);
+      await actW.transferOwnership({ newOwner: USER, account: USER });
+      await actW.renounceOwnership({ account: USER });
+      
+      expect(p.readContract).toHaveBeenCalledTimes(1);
+      expect(w.writeContract).toHaveBeenCalledTimes(2);
+    });
+  });
+});

package/packages/core/__tests__/actions/staking.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { stakingActions } from '../../src/actions/staking';
+import { createMockPublicClient, createMockWalletClient, resetMocks } from '../mocks/client';
+
+const ADDR = '0x1111111111111111111111111111111111111111' as `0x${string}`;
+const USER = '0x2222222222222222222222222222222222222222' as `0x${string}`;
+
+describe('StakingActions Bulk Coverage', () => {
+  let p: any;
+  let w: any;
+  beforeEach(() => { resetMocks(); p = createMockPublicClient(); w = createMockWalletClient(); });
+
+  describe('Staking Operations', () => {
+    it('lockStake', async () => { w.writeContract.mockResolvedValue('0x'); await stakingActions(ADDR)(w).lockStake({ user: USER, roleId: '0x01', stakeAmount: 100n, entryBurn: 10n, payer: USER, account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('topUpStake', async () => { w.writeContract.mockResolvedValue('0x'); await stakingActions(ADDR)(w).topUpStake({ user: USER, roleId: '0x01', stakeAmount: 100n, payer: USER, account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('unlockStake', async () => { w.writeContract.mockResolvedValue('0x'); await stakingActions(ADDR)(w).unlockStake({ user: USER, roleId: '0x01', account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('slash', async () => { w.writeContract.mockResolvedValue('0x'); await stakingActions(ADDR)(w).slash({ user: USER, amount: 100n, reason: 'test', account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+  });
+
+  describe('Views', () => {
+    it('getStakeInfo', async () => { p.readContract.mockResolvedValue([100n, 100n, true]); const res = await stakingActions(ADDR)(p).getStakeInfo({ operator: USER, roleId: '0x01' }); expect(res).toBeDefined(); });
+    it('previewExitFee', async () => { p.readContract.mockResolvedValue([5n, 95n]); const res = await stakingActions(ADDR)(p).previewExitFee({ user: USER, roleId: '0x01' }); expect(res.fee).toBe(5n); expect(res.netAmount).toBe(95n); });
+    it('totalStaked', async () => { p.readContract.mockResolvedValue(1000n); expect(await stakingActions(ADDR)(p).totalStaked()).toBe(1000n); });
+  });
+
+  describe('Configuration', () => {
+    it('setRegistry', async () => { w.writeContract.mockResolvedValue('0x'); await stakingActions(ADDR)(w).setRegistry({ registry: USER, account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+    it('setRoleExitFee', async () => { w.writeContract.mockResolvedValue('0x'); await stakingActions(ADDR)(w).setRoleExitFee({ roleId: '0x01', feePercent: 1n, minFee: 1n, account: USER }); expect(w.writeContract).toHaveBeenCalled(); });
+  });
+});

package/packages/core/__tests__/actions/superPaymaster.test.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { superPaymasterActions } from '../../src/actions/superPaymaster';
+import { createMockPublicClient, createMockWalletClient, resetMocks } from '../mocks/client';
+
+const A = '0x1111111111111111111111111111111111111111' as `0x${string}`;
+const U = '0x2222222222222222222222222222222222222222' as `0x${string}`;
+
+describe('SuperPaymasterActions Exhaustive Coverage', () => {
+  let p: any;
+  let w: any;
+  beforeEach(() => { resetMocks(); p = createMockPublicClient(); w = createMockWalletClient(); });
+
+  describe('Core Operations', () => {
+    it('deposit/withdraw/ETH', async () => {
+      w.writeContract.mockResolvedValue('0x');
+      const act = superPaymasterActions(A)(w);
+      await act.deposit({ amount: 100n, account: U });
+      await act.depositETH({ value: 100n, account: U });
+      await act.depositFor({ targetOperator: U, amount: 100n, account: U });
+      await act.withdraw({ amount: 100n, account: U });
+      await act.withdrawTo({ to: U, amount: 100n, account: U });
+      expect(w.writeContract).toHaveBeenCalledTimes(5);
+    });
+    it('stking ops', async () => {
+      w.writeContract.mockResolvedValue('0x');
+      const act = superPaymasterActions(A)(w);
+      await act.addStake({ unstakeDelaySec: 3600, value: 100n, account: U });
+      await act.unlockStake({ account: U });
+      await act.withdrawStake({ to: U, account: U });
+      expect(w.writeContract).toHaveBeenCalledTimes(3);
+    });
+  });
+
+  describe('Operator Management', () => {
+    it('configure/paused/limits', async () => {
+      w.writeContract.mockResolvedValue('0x');
+      const act = superPaymasterActions(A)(w);
+      await act.configureOperator({ xPNTsToken: U, opTreasury: U, exchangeRate: 100n, account: U });
+      await act.setOperatorPaused({ operator: U, paused: true, account: U });
+      await act.setOperatorLimits({ minTxInterval: 10, account: U });
+      await act.updateReputation({ operator: U, newScore: 100n, account: U });
+      await act.executeSlashWithBLS({ operator: U, level: 1, proof: '0x', account: U });
+      await act.slashOperator({ operator: U, level: 1, penaltyAmount: 100n, reason: 'r', account: U });
+      expect(w.writeContract).toHaveBeenCalledTimes(6);
+    });
+    it('blocks/sbt status', async () => {
+      w.writeContract.mockResolvedValue('0x');
+      const act = superPaymasterActions(A)(w);
+      await act.updateBlockedStatus({ operator: U, users: [U], statuses: [true], account: U });
+      await act.updateSBTStatus({ user: U, status: true, account: U });
+      expect(w.writeContract).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe('Price & Protocol', () => {
+    it('prices', async () => {
+      w.writeContract.mockResolvedValue('0x');
+      const act = superPaymasterActions(A)(w);
+      await act.setAPNTSPrice({ newPrice: 100n, account: U });
+      await act.updatePrice({ account: U });
+      await act.updatePriceDVT({ price: 100n, updatedAt: 123n, proof: '0x', account: U });
+      expect(w.writeContract).toHaveBeenCalledTimes(3);
+    });
+    it('protocol config', async () => {
+      w.writeContract.mockResolvedValue('0x');
+      const act = superPaymasterActions(A)(w);
+      await act.setProtocolFee({ newFeeBPS: 100n, account: U });
+      await act.setTreasury({ treasury: U, account: U });
+      await act.setXPNTsFactory({ factory: U, account: U });
+      await act.setAPNTsToken({ token: U, account: U });
+      await act.setBLSAggregator({ aggregator: U, account: U });
+      await act.withdrawProtocolRevenue({ to: U, amount: 100n, account: U });
+      expect(w.writeContract).toHaveBeenCalledTimes(6);
+    });
+  });
+
+  describe('Views & Getters', () => {
+    it('operator/credit/slash', async () => {
+      p.readContract.mockResolvedValueOnce([100n, 100n, true, false, U, 0, 0, U, 0n, 0n]);
+      p.readContract.mockResolvedValueOnce(100n);
+      p.readContract.mockResolvedValueOnce(100n);
+      p.readContract.mockResolvedValueOnce([100n, 100n, 100n, 'r', 1]);
+      p.readContract.mockResolvedValueOnce(1n);
+      p.readContract.mockResolvedValueOnce([[100n, 100n, 100n, 'r', 1]]);
+      p.readContract.mockResolvedValueOnce([100n, 100n, 100n, 'r', 1]);
+      const act = superPaymasterActions(A)(p);
+      await act.operators({ operator: U });
+      await act.getAvailableCredit({ user: U, token: U });
+      await act.getDeposit();
+      await act.getLatestSlash({ operator: U });
+      await act.getSlashCount({ operator: U });
+      await act.getSlashHistory({ operator: U });
+      await act.slashHistory({ operator: U, index: 0n });
+      expect(p.readContract).toHaveBeenCalledTimes(7);
+    });
+    it('state/price/protocol', async () => {
+      p.readContract.mockResolvedValueOnce([123, true]);
+      p.readContract.mockResolvedValueOnce([100n, 123n, 1n, 18]);
+      p.readContract.mockResolvedValueOnce(100n);
+      p.readContract.mockResolvedValueOnce(500n);
+      p.readContract.mockResolvedValueOnce(1000n);
+      p.readContract.mockResolvedValueOnce(10000n);
+      p.readContract.mockResolvedValueOnce(3600n);
+      p.readContract.mockResolvedValueOnce(true);
+      const act = superPaymasterActions(A)(p);
+      await act.userOpState({ user: U, operator: U });
+      await act.cachedPrice();
+      await act.aPNTsPriceUSD();
+      await act.protocolFeeBPS();
+      await act.protocolRevenue();
+      await act.totalTrackedBalance();
+      await act.priceStalenessThreshold();
+      await act.sbtHolders({ user: U });
+      expect(p.readContract).toHaveBeenCalledTimes(8);
+    });
+  });
+
+  describe('Constants & Meta', () => {
+    it('refernce getters', async () => {
+      p.readContract.mockResolvedValue(U);
+      const act = superPaymasterActions(A)(p);
+      await act.APNTS_TOKEN();
+      await act.REGISTRY();
+      await act.BLS_AGGREGATOR();
+      await act.ETH_USD_PRICE_FEED();
+      await act.treasury();
+      await act.xpntsFactory();
+      await act.entryPoint();
+      expect(p.readContract).toHaveBeenCalledTimes(7);
+    });
+    it('thresholds', async () => {
+      p.readContract.mockResolvedValue(100n);
+      const act = superPaymasterActions(A)(p);
+      await act.MAX_PROTOCOL_FEE();
+      await act.MAX_ETH_USD_PRICE();
+      await act.MIN_ETH_USD_PRICE();
+      await act.PAYMASTER_DATA_OFFSET();
+      await act.PRICE_CACHE_DURATION();
+      await act.RATE_OFFSET();
+      await act.VALIDATION_BUFFER_BPS();
+      await act.BPS_DENOMINATOR();
+      expect(p.readContract).toHaveBeenCalledTimes(8);
+    });
+    it('ownership/version', async () => {
+      p.readContract.mockResolvedValueOnce(U);
+      p.readContract.mockResolvedValueOnce('1.0');
+      const actP = superPaymasterActions(A)(p);
+      await actP.owner();
+      await actP.version();
+      w.writeContract.mockResolvedValue('0x');
+      const actW = superPaymasterActions(A)(w);
+      await actW.transferOwnership({ newOwner: U, account: U });
+      await actW.renounceOwnership({ account: U });
+      expect(p.readContract).toHaveBeenCalledTimes(2);
+      expect(w.writeContract).toHaveBeenCalledTimes(2);
+    });
+  });
+});

package/packages/core/__tests__/actions/tokens-extended.test.ts

@@ -0,0 +1,18 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { tokenActions } from '../../src/actions/tokens';
+import { createMockPublicClient, createMockWalletClient, resetMocks } from '../mocks/client';
+
+const T = '0x1111111111111111111111111111111111111111' as `0x${string}`;
+const U = '0x2222222222222222222222222222222222222222' as `0x${string}`;
+
+describe('Token All Functions', () => {
+  let p: ReturnType<typeof createMockPublicClient>;
+  let w: ReturnType<typeof createMockWalletClient>;
+  beforeEach(() => { resetMocks(); p = createMockPublicClient(); w = createMockWalletClient(); });
+
+  it('transferFrom', async () => { w.writeContract.mockResolvedValue('0x' as `0x${string}`); await tokenActions()(w).transferFrom({ token: T, from: U, to: U, amount: 1n, account: w.account }); expect(w.writeContract).toHaveBeenCalled(); });
+  it('name', async () => { p.readContract.mockResolvedValue('T'); expect(await tokenActions()(p).name({ token: T })).toBe('T'); });
+  it('symbol', async () => { p.readContract.mockResolvedValue('TKN'); expect(await tokenActions()(p).symbol({ token: T })).toBe('TKN'); });
+  it('decimals', async () => { p.readContract.mockResolvedValue(18); expect(await tokenActions()(p).decimals({ token: T })).toBe(18); });
+  it('needsApproval', async () => { p.readContract.mockResolvedValue(true); expect(await tokenActions()(p).needsApproval({ token: T, owner: U, spender: U, amount: 100n })).toBe(true); });
+});

package/packages/core/__tests__/actions/tokens.test.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { tokenActions, xPNTsTokenActions, gTokenActions } from '../../src/actions/tokens';
+import { createMockPublicClient, createMockWalletClient, resetMocks } from '../mocks/client';
+
+const ADDR = '0x1111111111111111111111111111111111111111' as `0x${string}`;
+const USER = '0x2222222222222222222222222222222222222222' as `0x${string}`;
+
+describe('TokenActions Exhaustive Coverage', () => {
+  let p: any;
+  let w: any;
+  beforeEach(() => { resetMocks(); p = createMockPublicClient(); w = createMockWalletClient(); });
+
+  describe('GToken (Base ERC20 + extensions)', () => {
+    it('read ops', async () => {
+      p.readContract.mockResolvedValue(100n);
+      const acts = gTokenActions(ADDR)(p);
+      await acts.totalSupply();
+      await acts.balanceOf({ account: USER });
+      await acts.allowance({ owner: USER, spender: USER });
+      await acts.cap();
+      await acts.remainingMintableSupply();
+      await acts.decimals(); // number
+      
+      p.readContract.mockResolvedValue('str');
+      await acts.name();
+      await acts.symbol();
+      await acts.version();
+      p.readContract.mockResolvedValue(USER);
+      await acts.owner();
+
+      expect(p.readContract).toHaveBeenCalledTimes(10);
+    });
+    
+    it('write ops', async () => {
+      w.writeContract.mockResolvedValue('0x');
+      const acts = gTokenActions(ADDR)(w);
+      await acts.transfer({ to: USER, amount: 100n, account: USER });
+      await acts.transferFrom({ from: USER, to: USER, amount: 100n, account: USER });
+      await acts.approve({ spender: USER, amount: 100n, account: USER });
+      await acts.mint({ to: USER, amount: 100n, account: USER });
+      await acts.burn({ amount: 100n, account: USER });
+      await acts.burnFrom({ from: USER, amount: 100n, account: USER });
+      await acts.transferOwnership({ newOwner: USER, account: USER });
+      await acts.renounceOwnership({ account: USER });
+      
+      expect(w.writeContract).toHaveBeenCalledTimes(8);
+    });
+  });
+
+  describe('XPNTs (ERC677 + Advanced)', () => {
+    it('read ops', async () => {
+      const acts = xPNTsTokenActions(ADDR)(p);
+      p.readContract.mockResolvedValue(100n);
+      await acts.exchangeRate();
+      await acts.debts({ user: USER });
+      await acts.getDebt({ user: USER });
+      await acts.spendingLimits({ owner: USER, spender: USER });
+      await acts.cumulativeSpent({ owner: USER, spender: USER });
+      await acts.DEFAULT_SPENDING_LIMIT_APNTS();
+      await acts.getDefaultSpendingLimitXPNTs();
+      await acts.nonces({ owner: USER });
+      
+      p.readContract.mockResolvedValue(true);
+      await acts.needsApproval({ owner: USER, spender: USER, amount: 100n });
+      await acts.autoApprovedSpenders({ spender: USER });
+      await acts.usedOpHashes({ opHash: '0x' });
+      
+      p.readContract.mockResolvedValue(USER);
+      await acts.SUPERPAYMASTER_ADDRESS();
+      await acts.FACTORY();
+      await acts.communityOwner();
+      
+      p.readContract.mockResolvedValue('str');
+      await acts.communityENS();
+      await acts.communityName();
+      await acts.version();
+      
+      p.readContract.mockResolvedValue({});
+      await acts.eip712Domain();
+      
+      expect(p.readContract).toHaveBeenCalledTimes(18);
+    });
+
+    it('write ops', async () => {
+      w.writeContract.mockResolvedValue('0x');
+      const acts = xPNTsTokenActions(ADDR)(w);
+      
+      // Inherited ERC20 writes (just test one to prove mapping)
+      await acts.transfer({ to: USER, amount: 100n, account: USER });
+      
+      // XPNTs writes
+      await acts.burnFromWithOpHash({ from: USER, amount: 100n, userOpHash: '0x', account: USER });
+      await acts.updateExchangeRate({ newRate: 100n, account: USER });
+      await acts.recordDebt({ user: USER, amountXPNTs: 100n, account: USER });
+      await acts.repayDebt({ amount: 100n, account: USER });
+      await acts.setPaymasterLimit({ spender: USER, limit: 100n, account: USER });
+      await acts.addAutoApprovedSpender({ spender: USER, account: USER });
+      await acts.removeAutoApprovedSpender({ spender: USER, account: USER });
+      await acts.permit({ owner: USER, spender: USER, value: 100n, deadline: 100n, v: 27, r: '0x', s: '0x', account: USER });
+      await acts.transferAndCall({ to: USER, amount: 100n, data: '0x', account: USER });
+      await acts.transferCommunityOwnership({ newOwner: USER, account: USER });
+      await acts.setSuperPaymasterAddress({ spAddress: USER, account: USER });
+
+      expect(w.writeContract).toHaveBeenCalledTimes(12);
+    });
+
+    it('metadata', async () => {
+      p.readContract.mockResolvedValue({ name: 'n', symbol: 's', communityName: 'cn', communityENS: 'ce', communityOwner: USER });
+      const acts = xPNTsTokenActions(ADDR)(p);
+      const meta = await acts.getMetadata();
+      expect(meta).toBeDefined();
+    });
+  });
+
+  describe('Legacy tokenActions', () => {
+    it('defaults to xPNTs', async () => {
+      p.readContract.mockResolvedValue('1.0');
+      const acts = tokenActions(ADDR)(p);
+      expect(await acts.version()).toBe('1.0');
+    });
+  });
+});