@aastar/enduser 0.16.11 → 0.16.12

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@aastar/enduser",
-  "version": "0.16.11",
+  "version": "0.16.12",
   "type": "module",
   "description": "Enduser client for AAstar SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "keywords": [
     "aastar",
     "enduser",
@@ -14,7 +17,7 @@
   "license": "MIT",
   "dependencies": {
     "viem": "2.43.3",
-    "@aastar/core": "0.16.11"
+    "@aastar/core": "0.16.12"
   },
   "devDependencies": {
     "typescript": "5.7.2"

package/__tests__/CommunityClient.test.ts

@@ -1,205 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { CommunityClient } from '../src/CommunityClient';
-import { createMockPublicClient, createMockWalletClient, resetMocks } from './mocks/client';
-import { parseEther } from 'viem';
-
-// Define mocks using vi.hoisted to ensure they are available for vi.mock
-const mocks = vi.hoisted(() => {
-  const mockXPNTsFactory = { createToken: vi.fn() };
-  const mockRegistry = { ROLE_COMMUNITY: vi.fn(), registerRoleSelf: vi.fn() };
-  const mockToken = { allowance: vi.fn(), approve: vi.fn(), transferOwnership: vi.fn() };
-  const mockSBT = { airdropMint: vi.fn(), mintForRole: vi.fn(), burnSBT: vi.fn() };
-  const mockReputation = { setReputationRule: vi.fn() };
-
-  return {
-    mockXPNTsFactory,
-    mockRegistry,
-    mockToken,
-    mockSBT,
-    mockReputation,
-    // The actions typically return a function that accepts the client and returns the methods
-    // xPNTsFactoryActions(addr)(client).createToken(...)
-    mockXPNTsFactoryActions: vi.fn(() => () => mockXPNTsFactory),
-    mockRegistryActions: vi.fn(() => () => mockRegistry),
-    mockTokenActions: vi.fn(() => () => mockToken),
-    mockSBTActions: vi.fn(() => () => mockSBT),
-    mockReputationActions: vi.fn(() => () => mockReputation),
-  };
-});
-
-vi.mock('@aastar/core', async () => {
-  const actual = await vi.importActual('@aastar/core');
-  return {
-    ...actual,
-    xPNTsFactoryActions: mocks.mockXPNTsFactoryActions,
-    registryActions: mocks.mockRegistryActions,
-    tokenActions: mocks.mockTokenActions,
-    sbtActions: mocks.mockSBTActions,
-    reputationActions: mocks.mockReputationActions,
-  };
-});
-
-describe('CommunityClient', () => {
-  let client: CommunityClient;
-  const mockPublicClient = createMockPublicClient();
-  const mockWalletClient = createMockWalletClient();
-
-  const config = {
-    params: {
-        chainId: 11155111,
-        rpcUrl: 'https://rpc.sepolia.org',
-    },
-    services: {
-        paymasterUrl: 'https://paymaster.example.com',
-    },
-    // Required by BaseClient
-    client: mockWalletClient as any,
-    registryAddress: '0xRegistryAddress' as `0x${string}`,
-    gTokenAddress: '0xGTokenAddress' as `0x${string}`,
-    gTokenStakingAddress: '0xStakingAddress' as `0x${string}`,
-    // Required by CommunityClient
-    sbtAddress: '0xSBTAddress' as `0x${string}`,
-    factoryAddress: '0xFactoryAddress' as `0x${string}`,
-    reputationAddress: '0xReputationAddress' as `0x${string}`,
-  };
-
-  beforeEach(() => {
-    resetMocks();
-    vi.clearAllMocks();
-    
-    // Setup default successful mocks
-    mocks.mockRegistry.ROLE_COMMUNITY.mockResolvedValue(100n);
-    mocks.mockToken.allowance.mockResolvedValue(parseEther('100'));
-    mocks.mockXPNTsFactory.createToken.mockResolvedValue('0xTxHash');
-    mocks.mockRegistry.registerRoleSelf.mockResolvedValue('0xTxHash');
-    mocks.mockSBT.airdropMint.mockResolvedValue('0xTxHash');
-    mocks.mockSBT.burnSBT.mockResolvedValue('0xTxHash');
-    mocks.mockReputation.setReputationRule.mockResolvedValue('0xTxHash');
-    mocks.mockToken.transferOwnership.mockResolvedValue('0xTxHash');
-
-    client = new CommunityClient(config);
-    (client as any).client = mockWalletClient;
-    (client as any).publicClient = mockPublicClient;
-  });
-
-  describe('createCommunityToken', () => {
-    it('should successfully create a token', async () => {
-      const result = await client.createCommunityToken({
-        name: 'Test Token',
-        tokenSymbol: 'TEST'
-      });
-      
-      expect(mocks.mockXPNTsFactoryActions).toHaveBeenCalledWith(config.factoryAddress);
-      expect(mocks.mockXPNTsFactory.createToken).toHaveBeenCalledWith(expect.objectContaining({
-        name: 'Test Token',
-        symbol: 'TEST',
-        community: expect.stringContaining('0x000') 
-      }));
-      expect(result).toBe('0xTxHash');
-    });
-
-    it('should throw if factoryAddress is missing', async () => {
-      client.factoryAddress = undefined;
-      await expect(client.createCommunityToken({ name: 'T', tokenSymbol: 'T' }))
-        .rejects.toThrow('Factory address required');
-    });
-
-    it('should propagate core errors', async () => {
-      mocks.mockXPNTsFactory.createToken.mockRejectedValue(new Error('Core Error'));
-      await expect(client.createCommunityToken({ name: 'T', tokenSymbol: 'T' }))
-        .rejects.toThrow('Core Error');
-    });
-  });
-
-  describe('registerAsCommunity', () => {
-    it('should register successfully with sufficient allowance', async () => {
-      mocks.mockToken.allowance.mockResolvedValue(parseEther('100'));
-      
-      await client.registerAsCommunity({ name: 'My Community' });
-      
-      expect(mocks.mockToken.approve).not.toHaveBeenCalled();
-      expect(mocks.mockRegistry.registerRoleSelf).toHaveBeenCalledWith(expect.objectContaining({
-        roleId: 100n
-      }));
-    });
-
-    it('should approve if allowance is insufficient', async () => {
-      mocks.mockToken.allowance.mockResolvedValue(0n); 
-      mocks.mockToken.approve.mockResolvedValue('0xApproveHash');
-      
-      await client.registerAsCommunity({ name: 'My Community' });
-      
-      expect(mocks.mockToken.approve).toHaveBeenCalled();
-      expect(mockPublicClient.waitForTransactionReceipt).toHaveBeenCalledWith({ hash: '0xApproveHash' });
-      expect(mocks.mockRegistry.registerRoleSelf).toHaveBeenCalled();
-    });
-  });
-
-  describe('airdropSBT', () => {
-    it('should airdrop to a single user', async () => {
-      const user = '0xUser' as `0x${string}`;
-      await client.airdropSBT([user], 1n);
-      
-      expect(mocks.mockSBTActions).toHaveBeenCalledWith(config.sbtAddress);
-      expect(mocks.mockSBT.mintForRole).toHaveBeenCalledWith(expect.objectContaining({
-        user: user
-      }));
-    });
-
-    it('should throw if sbtAddress is missing', async () => {
-      client.sbtAddress = undefined;
-      await expect(client.airdropSBT(['0xUser'], 1n))
-        .rejects.toThrow('SBT address required');
-    });
-
-    it('should throw if multiple users provided (not implemented)', async () => {
-      await expect(client.airdropSBT(['0xU1', '0xU2'], 1n))
-        .rejects.toThrow('Batch airdrop not fully implemented');
-    });
-  });
-
-  describe('setReputationRule', () => {
-    it('setReputationRule should call reputation setReputationRule', async () => {
-        await client.setReputationRule(1n, {});
-        expect(mocks.mockReputationActions).toHaveBeenCalledWith(config.reputationAddress);
-        // Mock passes ruleId as hex because implementation converts it
-        expect(mocks.mockReputation.setReputationRule).toHaveBeenCalledWith(expect.objectContaining({
-            ruleId: '0x0000000000000000000000000000000000000000000000000000000000000001'
-        }));
-    });
-
-    it('should throw if reputationAddress is missing', async () => {
-      client.reputationAddress = undefined;
-      await expect(client.setReputationRule(1n, {}))
-        .rejects.toThrow('Reputation address required');
-    });
-  });
-
-  describe('revokeMembership', () => {
-    it('should burn SBT', async () => {
-      const user = '0xUser' as `0x${string}`;
-      await client.revokeMembership(user);
-      expect(mocks.mockSBTActions).toHaveBeenCalledWith(config.sbtAddress);
-      expect(mocks.mockSBT.burnSBT).toHaveBeenCalledWith(expect.objectContaining({
-        user: user
-      }));
-    });
-
-    it('should throw if sbtAddress is missing', async () => {
-      client.sbtAddress = undefined;
-      await expect(client.revokeMembership(123n))
-        .rejects.toThrow('SBT address required');
-    });
-  });
-
-  describe('transferCommunityTokenOwnership', () => {
-    it('should transfer ownership', async () => {
-      await client.transferCommunityTokenOwnership('0xToken', '0x2222222222222222222222222222222222222222');
-      expect(mocks.mockTokenActions).toHaveBeenCalled();
-      expect(mocks.mockToken.transferOwnership).toHaveBeenCalledWith(expect.objectContaining({
-        token: '0xToken',
-        newOwner: '0x2222222222222222222222222222222222222222'
-      }));
-    });
-  });
-});

package/__tests__/UserClient.test.ts

@@ -1,294 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { UserClient } from '../src/UserClient';
-import { createMockPublicClient, createMockWalletClient, resetMocks } from './mocks/client';
-import { parseEther } from 'viem';
-
-// Define mocks using vi.hoisted
-const mocks = vi.hoisted(() => {
-  const mockAccount = { owner: vi.fn(), execute: vi.fn(), executeBatch: vi.fn() };
-  const mockSBT = { balanceOf: vi.fn(), mintForRole: vi.fn(), leaveCommunity: vi.fn() };
-  const mockToken = { transfer: vi.fn(), balanceOf: vi.fn(), allowance: vi.fn() };
-  const mockStaking = { lockStake: vi.fn(), unlockAndTransfer: vi.fn(), getLockedStake: vi.fn() };
-  const mockRegistry = { exitRole: vi.fn(), registerRoleSelf: vi.fn() }; // registerRoleSelf calls execute in implementation logic but mocked here just in case? No, registerAsEndUser constructs tx data and calls execute/executeBatch.
-  // Wait, registerAsEndUser calls this.execute or this.executeBatch, so we don't mock registryActions for that call directly if we test logic flow, 
-  // BUT registerAsEndUser calls registryActions(this.registryAddress) effectively to get address? No, it uses this.registryAddress. 
-  // It calls registryActions to get ABI maybe? In the code: 
-  // const registry = registryActions(this.registryAddress);
-  // ... encodeFunctionData ...
-  // registerAsEndUser MANUALLY constructs tx data using encodeFunctionData. It DOES NOT use registryActions returned object methods for the transaction itself to send via execute.
-  // EXCEPT: It initializes registry = registryActions(...) which might be unused in logic?
-  // Let's look at source: 
-  // const registry = registryActions(this.registryAddress);
-  // ...
-  // It effectively uses it for nothing if it builds manually? 
-  // Line 293: const registry = registryActions(this.registryAddress);
-  // Then lines 315-337: const roleData = ... encodeFunctionData ... 
-  // So registryActions might be just for show? Or maybe strict mode requires it.
-  
-  const mockEntryPoint = { getNonce: vi.fn() };
-  
-  return {
-    mockAccount,
-    mockSBT,
-    mockToken,
-    mockStaking,
-    mockRegistry,
-    mockEntryPoint,
-    // Factory functions
-    mockAccountActions: vi.fn(() => () => mockAccount),
-    mockSBTActions: vi.fn(() => () => mockSBT),
-    mockTokenActions: vi.fn(() => () => mockToken),
-    mockStakingActions: vi.fn(() => () => mockStaking),
-    mockRegistryActions: vi.fn(() => () => mockRegistry),
-    mockEntryPointActions: vi.fn(() => () => mockEntryPoint),
-    // Bundler actions (mock extend)
-    mockBundlerActions: {},
-  };
-});
-
-vi.mock('@aastar/core', async () => {
-  const actual = await vi.importActual('@aastar/core');
-  return {
-    ...actual,
-    accountActions: mocks.mockAccountActions,
-    sbtActions: mocks.mockSBTActions,
-    tokenActions: mocks.mockTokenActions,
-    stakingActions: mocks.mockStakingActions,
-    registryActions: mocks.mockRegistryActions,
-    entryPointActions: mocks.mockEntryPointActions,
-  };
-});
-
-vi.mock('viem/account-abstraction', async () => {
-  const actual = await vi.importActual('viem/account-abstraction');
-  return {
-    ...actual,
-    bundlerActions: () => ({
-        estimateUserOperationGas: vi.fn().mockResolvedValue({
-            callGasLimit: 1000n,
-            verificationGasLimit: 1000n,
-            preVerificationGas: 1000n
-        }),
-        sendUserOperation: vi.fn().mockResolvedValue('0xUserOpHash')
-    }),
-    getUserOperationHash: vi.fn().mockReturnValue('0xHash'),
-  };
-});
-
-describe('UserClient', () => {
-  let client: UserClient;
-  const mockPublicClient = createMockPublicClient();
-  const mockWalletClient = createMockWalletClient();
-
-  const config = {
-    params: {
-        chainId: 11155111,
-        rpcUrl: 'https://rpc.sepolia.org',
-    },
-    services: {
-        paymasterUrl: 'https://paymaster.example.com',
-    },
-    client: mockWalletClient as any,
-    accountAddress: '0x1234567890123456789012345678901234567890' as `0x${string}`,
-    sbtAddress: '0x1111111111111111111111111111111111111111' as `0x${string}`,
-    entryPointAddress: '0x2222222222222222222222222222222222222222' as `0x${string}`,
-    gTokenStakingAddress: '0x3333333333333333333333333333333333333333' as `0x${string}`,
-    registryAddress: '0x4444444444444444444444444444444444444444' as `0x${string}`,
-    gTokenAddress: '0x5555555555555555555555555555555555555555' as `0x${string}`,
-  };
-
-  beforeEach(() => {
-    resetMocks();
-    vi.clearAllMocks();
-
-    // Default Resolves
-    mocks.mockAccount.owner.mockResolvedValue('0xOwner');
-    mocks.mockAccount.execute.mockResolvedValue('0xTxHash');
-    mocks.mockAccount.executeBatch.mockResolvedValue('0xTxHash');
-    mocks.mockEntryPoint.getNonce.mockResolvedValue(0n);
-    mocks.mockSBT.balanceOf.mockResolvedValue(1n);
-    mocks.mockSBT.mintForRole.mockResolvedValue('0xTxHash');
-    mocks.mockToken.transfer.mockResolvedValue('0xTxHash');
-    mocks.mockToken.balanceOf.mockResolvedValue(100n);
-    mocks.mockToken.allowance.mockResolvedValue(parseEther('1000'));
-    mocks.mockStaking.lockStake.mockResolvedValue('0xTxHash');
-    mocks.mockStaking.unlockAndTransfer.mockResolvedValue('0xTxHash');
-    mocks.mockStaking.getLockedStake.mockResolvedValue(50n);
-    mocks.mockRegistry.exitRole.mockResolvedValue('0xTxHash');
-    mocks.mockSBT.leaveCommunity.mockResolvedValue('0xTxHash');
-
-    // Mock public client methods needed for gasless
-    (mockPublicClient as any).estimateFeesPerGas = vi.fn().mockResolvedValue({
-        maxFeePerGas: 10n,
-        maxPriorityFeePerGas: 1n
-    });
-
-    client = new UserClient(config);
-    (client as any).client = mockWalletClient;
-    (client as any).publicClient = mockPublicClient;
-     // Mock extend for gasless
-    (client as any).client.extend = vi.fn().mockReturnValue({
-        estimateUserOperationGas: vi.fn().mockResolvedValue({
-            callGasLimit: 1000n,
-            verificationGasLimit: 1000n,
-            preVerificationGas: 1000n
-        }),
-        sendUserOperation: vi.fn().mockResolvedValue('0xUserOpHash'),
-        signMessage: vi.fn().mockResolvedValue('0xSig')
-    });
-    
-    // Also mock signMessage on the client itself if used directly
-    (client as any).client.signMessage = vi.fn().mockResolvedValue('0xSig');
-  });
-
-  describe('Basic Account Operations', () => {
-    it('getNonce should call entryPoint', async () => {
-      const nonce = await client.getNonce();
-      expect(mocks.mockEntryPointActions).toHaveBeenCalledWith(config.entryPointAddress);
-      expect(mocks.mockEntryPoint.getNonce).toHaveBeenCalledWith({
-          sender: config.accountAddress,
-          key: 0n
-      });
-      expect(nonce).toBe(0n);
-    });
-
-    it('getOwner should call account', async () => {
-      const owner = await client.getOwner();
-      expect(mocks.mockAccountActions).toHaveBeenCalledWith(config.accountAddress);
-      expect(mocks.mockAccount.owner).toHaveBeenCalled();
-      expect(owner).toBe('0xOwner');
-    });
-
-    it('execute should call account execute', async () => {
-      await client.execute('0x1111111111111111111111111111111111111111', 0n, '0x1234');
-      expect(mocks.mockAccountActions).toHaveBeenCalledWith(config.accountAddress);
-      expect(mocks.mockAccount.execute).toHaveBeenCalledWith(expect.objectContaining({
-          dest: '0x1111111111111111111111111111111111111111',
-          value: 0n,
-          func: '0x1234'
-      }));
-    });
-  });
-
-  describe('SBT Operations', () => {
-    it('getSBTBalance should call sbt', async () => {
-      await client.getSBTBalance();
-      expect(mocks.mockSBTActions).toHaveBeenCalledWith(config.sbtAddress);
-      expect(mocks.mockSBT.balanceOf).toHaveBeenCalled();
-    });
-
-    it('mintSBT should call sbt mintForRole', async () => {
-      await client.mintSBT('0x4444444444444444444444444444444444444444444444444444444444444444');
-      expect(mocks.mockSBT.mintForRole).toHaveBeenCalledWith(expect.objectContaining({
-          roleId: '0x4444444444444444444444444444444444444444444444444444444444444444',
-          user: config.accountAddress
-      }));
-    });
-    
-    it('should throw if sbtAddress missing', async () => {
-        client.sbtAddress = undefined;
-        await expect(client.mintSBT('0x4444444444444444444444444444444444444444444444444444444444444444')).rejects.toThrow('SBT address required');
-    });
-  });
-
-  describe('Asset Operations', () => {
-    it('transferToken should call token transfer', async () => {
-      await client.transferToken('0x5555555555555555555555555555555555555555', '0x6666666666666666666666666666666666666666', 100n);
-      expect(mocks.mockToken.transfer).toHaveBeenCalledWith(expect.objectContaining({
-          token: '0x5555555555555555555555555555555555555555',
-          to: '0x6666666666666666666666666666666666666666',
-          amount: 100n
-      }));
-    });
-
-    it('getTokenBalance should call token balanceOf', async () => {
-        await client.getTokenBalance('0x5555555555555555555555555555555555555555');
-        expect(mocks.mockToken.balanceOf).toHaveBeenCalledWith(expect.objectContaining({
-            token: '0x5555555555555555555555555555555555555555',
-            account: config.accountAddress
-        }));
-    });
-  });
-
-  describe('Staking Operations', () => {
-      it('stakeForRole should call lockStake', async () => {
-          await client.stakeForRole('0x4444444444444444444444444444444444444444444444444444444444444444', 100n);
-          expect(mocks.mockStakingActions).toHaveBeenCalledWith(config.gTokenStakingAddress);
-          expect(mocks.mockStaking.lockStake).toHaveBeenCalledWith(expect.objectContaining({
-              user: config.accountAddress,
-              roleId: '0x4444444444444444444444444444444444444444444444444444444444444444',
-              stakeAmount: 100n
-          }));
-      });
-      
-      it('unstakeFromRole should call unlockAndTransfer', async () => {
-          await client.unstakeFromRole('0x4444444444444444444444444444444444444444444444444444444444444444');
-          expect(mocks.mockStaking.unlockAndTransfer).toHaveBeenCalledWith(expect.objectContaining({
-              user: config.accountAddress,
-              roleId: '0x4444444444444444444444444444444444444444444444444444444444444444'
-          }));
-      });
-
-      it('getStakedBalance should call getLockedStake', async () => {
-          await client.getStakedBalance('0x4444444444444444444444444444444444444444444444444444444444444444');
-          expect(mocks.mockStaking.getLockedStake).toHaveBeenCalled();
-      });
-  });
-
-  describe('Lifecycle', () => {
-    it('exitRole should call registry exitRole', async () => {
-        await client.exitRole('0x4444444444444444444444444444444444444444444444444444444444444444');
-        expect(mocks.mockRegistryActions).toHaveBeenCalledWith(config.registryAddress);
-        expect(mocks.mockRegistry.exitRole).toHaveBeenCalledWith(expect.objectContaining({
-            roleId: '0x4444444444444444444444444444444444444444444444444444444444444444'
-        }));
-    });
-
-    it('leaveCommunity should call sbt leaveCommunity', async () => {
-        await client.leaveCommunity('0x3333333333333333333333333333333333333333');
-        expect(mocks.mockSBT.leaveCommunity).toHaveBeenCalledWith(expect.objectContaining({
-            community: '0x3333333333333333333333333333333333333333'
-        }));
-    });
-
-    it('registerAsEndUser should execute batch (approve + register)', async () => {
-        mocks.mockToken.allowance.mockResolvedValue(0n); // Force approve
-        
-        await client.registerAsEndUser('0x3333333333333333333333333333333333333333', 100n);
-        
-        // Should verify executeBatch is called because allowance is low
-        expect(mocks.mockAccount.executeBatch).toHaveBeenCalled();
-        // first arg (targets) should contain [gToken, registry]
-        const callArgs = mocks.mockAccount.executeBatch.mock.calls[0][0];
-        expect(callArgs.dest).toHaveLength(2);
-        expect(callArgs.dest[0]).toBe(config.gTokenAddress);
-        expect(callArgs.dest[1]).toBe(config.registryAddress);
-    });
-
-    it('registerAsEndUser should execute single if already approved', async () => {
-        mocks.mockToken.allowance.mockResolvedValue(parseEther('10000'));
-        
-        await client.registerAsEndUser('0x3333333333333333333333333333333333333333', 100n);
-        
-        expect(mocks.mockAccount.execute).toHaveBeenCalled();
-        const callArgs = mocks.mockAccount.execute.mock.calls[0][0];
-        expect(callArgs.dest).toBe(config.registryAddress);
-    });
-  });
-
-  describe('Gasless', () => {
-      it('executeGasless should construct and send UserOp', async () => {
-          const result = await client.executeGasless({
-              target: '0x1111111111111111111111111111111111111111',
-              value: 0n,
-              data: '0x1234',
-              paymaster: '0x2222222222222222222222222222222222222222',
-              paymasterType: 'V4'
-          });
-          
-          expect(client.client.extend).toHaveBeenCalled();
-          expect(result).toBe('0xUserOpHash');
-      });
-  });
-
-});

package/__tests__/index.test.ts

@@ -1,16 +0,0 @@
-
-import { CommunityClient } from '../src/CommunityClient';
-import { UserClient } from '../src/UserClient';
-import * as Exports from '../src/index';
-
-describe('EndUser Package Exports', () => {
-    it('should export CommunityClient', () => {
-        expect(Exports.CommunityClient).toBeDefined();
-        expect(Exports.CommunityClient).toBe(CommunityClient);
-    });
-
-    it('should export UserClient', () => {
-        expect(Exports.UserClient).toBeDefined();
-        expect(Exports.UserClient).toBe(UserClient);
-    });
-});

package/__tests__/mocks/client.ts

@@ -1,22 +0,0 @@
-import { vi } from 'vitest';
-import type { PublicClient, WalletClient } from 'viem';
-
-export const createMockPublicClient = (): PublicClient => {
-  return {
-    readContract: vi.fn(),
-    chain: { id: 11155111 },
-    waitForTransactionReceipt: vi.fn().mockResolvedValue({ status: 'success' }),
-  } as any;
-};
-
-export const createMockWalletClient = (): WalletClient => {
-  return {
-    writeContract: vi.fn(),
-    account: { address: '0x1234567890123456789012345678901234567890' },
-    chain: { id: 11155111 },
-  } as any;
-};
-
-export const resetMocks = () => {
-  vi.clearAllMocks();
-};