Merge pull request #152 from internet-dot/fix/issue-14

test: add Jest tests for walletService

Author: Smartdevs17

src/services/__tests__/walletService.test.ts

@@ -0,0 +1,333 @@
+import { WalletServiceManager, WalletConnection, TokenBalance, GasEstimate } from '../walletService';
+import { ethers } from 'ethers';
+
+// ── Mock dependencies ──────────────────────────────────────────────
+
+jest.mock('ethers', () => {
+  const actual = jest.requireActual('ethers') as Record<string, unknown>;
+  return {
+    ...actual,
+    providers: {
+      JsonRpcProvider: jest.fn().mockImplementation(() => ({
+        getBalance: jest.fn(),
+        getGasPrice: jest.fn(),
+      })),
+      Web3Provider: jest.fn().mockImplementation(() => ({
+        getSigner: jest.fn(),
+      })),
+    },
+  };
+});
+
+jest.mock('@superfluid-finance/sdk-core', () => ({
+  Framework: {
+    create: jest.fn(),
+  },
+  SFError: class extends Error {
+    constructor(msg: string) {
+      super(msg);
+      this.name = 'SFError';
+    }
+  },
+}));
+
+jest.mock('../../contracts', () => ({
+  ERC20__factory: {
+    connect: jest.fn(),
+  },
+  getContractAddress: jest.fn(),
+}));
+
+jest.mock('../../config/evm', () => ({
+  getEvmRpcUrl: jest.fn().mockReturnValue('https://rpc.example.com'),
+}));
+
+import { ethers as mockedEthers } from 'ethers';
+import { getContractAddress } from '../../contracts';
+import { getEvmRpcUrl } from '../../config/evm';
+import { Framework } from '@superfluid-finance/sdk-core';
+
+const mockedGetContractAddress = getContractAddress as jest.MockedFunction<typeof getContractAddress>;
+const mockedJsonRpcProvider = mockedEthers.providers.JsonRpcProvider as jest.Mock;
+
+// ── Helpers ────────────────────────────────────────────────────────
+
+function createMockConnection(overrides?: Partial<WalletConnection>): WalletConnection {
+  return {
+    address: '0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B',
+    chainId: 1,
+    isConnected: true,
+    eip1193Provider: {} as ethers.providers.ExternalProvider,
+    ...overrides,
+  };
+}
+
+function freshManager(): WalletServiceManager {
+  // Reset singleton state by re-instantiating via reflection
+  const mgr = new WalletServiceManager() as WalletServiceManager & { connection: WalletConnection | null; listeners: Function[] };
+  mgr.connection = null;
+  mgr.listeners = [];
+  return mgr;
+}
+
+// ── Tests ──────────────────────────────────────────────────────────
+
+describe('WalletServiceManager', () => {
+  describe('Singleton', () => {
+    it('getInstance returns the same instance', () => {
+      const a = WalletServiceManager.getInstance();
+      const b = WalletServiceManager.getInstance();
+      expect(a).toBe(b);
+    });
+  });
+
+  describe('Connection management', () => {
+    let mgr: WalletServiceManager & { connection: WalletConnection | null; listeners: Function[] };
+
+    beforeEach(() => {
+      mgr = freshManager() as typeof mgr;
+    });
+
+    it('getConnection returns null by default', () => {
+      expect(mgr.getConnection()).toBeNull();
+    });
+
+    it('setConnection updates and notifies listeners', () => {
+      const listener = jest.fn();
+      const conn = createMockConnection();
+      mgr.addListener(listener);
+      mgr.setConnection(conn);
+
+      expect(mgr.getConnection()).toBe(conn);
+      expect(listener).toHaveBeenCalledWith(conn);
+    });
+
+    it('removeListener stops notification', () => {
+      const listener = jest.fn();
+      mgr.addListener(listener);
+      mgr.removeListener(listener);
+      mgr.setConnection(createMockConnection());
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it('isConnected returns false when no connection', () => {
+      expect(mgr.isConnected()).toBe(false);
+    });
+
+    it('isConnected returns true when connected', () => {
+      mgr.setConnection(createMockConnection());
+      expect(mgr.isConnected()).toBe(true);
+    });
+  });
+
+  describe('disconnectWallet', () => {
+    it('clears connection and notifies listeners', async () => {
+      const mgr = freshManager() as WalletServiceManager & { connection: WalletConnection | null; listeners: Function[] };
+      const listener = jest.fn();
+      mgr.addListener(listener);
+      mgr.setConnection(createMockConnection());
+
+      await mgr.disconnectWallet();
+
+      expect(mgr.getConnection()).toBeNull();
+      expect(listener).toHaveBeenCalledWith(null);
+    });
+  });
+
+  describe('initialize', () => {
+    it('resolves without error', async () => {
+      const mgr = freshManager();
+      await expect(mgr.initialize()).resolves.toBeUndefined();
+    });
+  });
+
+  describe('getTokenBalances', () => {
+    let mgr: WalletServiceManager & { connection: WalletConnection | null; listeners: Function[] };
+    let mockProvider: { getBalance: jest.Mock; getGasPrice: jest.Mock };
+
+    beforeEach(() => {
+      mgr = freshManager() as typeof mgr;
+      mockProvider = {
+        getBalance: jest.fn().mockResolvedValue(ethers.BigNumber.from('1000000000000000000')),
+        getGasPrice: jest.fn(),
+      };
+      (mockedEthers.providers.JsonRpcProvider as jest.Mock).mockReturnValue(mockProvider);
+    });
+
+    it('returns native balance for chainId 1', async () => {
+      const balances = await mgr.getTokenBalances('0xAddr', 1);
+      expect(balances.length).toBeGreaterThanOrEqual(1);
+      expect(balances[0].symbol).toBe('ETH');
+      expect(balances[0].balance).toBe('1.0');
+    });
+
+    it('returns MATIC native balance for chainId 137', async () => {
+      const balances = await mgr.getTokenBalances('0xAddr', 137);
+      expect(balances[0].symbol).toBe('MATIC');
+    });
+
+    it('returns ETH for chainId 42161 (Arbitrum)', async () => {
+      const balances = await mgr.getTokenBalances('0xAddr', 42161);
+      expect(balances[0].symbol).toBe('ETH');
+    });
+
+    it('returns ETH as default for unknown chainId', async () => {
+      const balances = await mgr.getTokenBalances('0xAddr', 999);
+      expect(balances[0].symbol).toBe('ETH');
+    });
+
+    it('includes USDC for supported chains when contract address exists', async () => {
+      mockedGetContractAddress.mockReturnValue('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48');
+
+      const mockBalanceOf = jest.fn().mockResolvedValue(ethers.BigNumber.from('5000000'));
+      const mockContract = { balanceOf: mockBalanceOf, decimals: jest.fn() };
+      const ERC20Factory = require('../../contracts').ERC20__factory;
+      ERC20Factory.connect.mockReturnValue(mockContract);
+
+      const balances = await mgr.getTokenBalances('0xAddr', 1);
+      const usdc = balances.find((b: TokenBalance) => b.symbol === 'USDC');
+      expect(usdc).toBeDefined();
+      expect(usdc!.balance).toBe('5.0');
+    });
+
+    it('skips USDC when contract address is null', async () => {
+      mockedGetContractAddress.mockReturnValue(null);
+      const balances = await mgr.getTokenBalances('0xAddr', 1);
+      const usdc = balances.find((b: TokenBalance) => b.symbol === 'USDC');
+      expect(usdc).toBeUndefined();
+    });
+
+    it('handles USDC contract errors gracefully', async () => {
+      mockedGetContractAddress.mockReturnValue('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48');
+
+      const mockContract = {
+        balanceOf: jest.fn().mockRejectedValue(new Error('call revert')),
+        decimals: jest.fn(),
+      };
+      const ERC20Factory = require('../../contracts').ERC20__factory;
+      ERC20Factory.connect.mockReturnValue(mockContract);
+
+      const balances = await mgr.getTokenBalances('0xAddr', 1);
+      const usdc = balances.find((b: TokenBalance) => b.symbol === 'USDC');
+      expect(usdc).toBeUndefined();
+    });
+
+    it('throws when provider fails for native balance', async () => {
+      mockProvider.getBalance.mockRejectedValue(new Error('RPC down'));
+      await expect(mgr.getTokenBalances('0xAddr', 1)).rejects.toThrow('RPC down');
+    });
+  });
+
+  describe('estimateGas', () => {
+    let mgr: WalletServiceManager & { connection: WalletConnection | null; listeners: Function[] };
+    let mockProvider: { getBalance: jest.Mock; getGasPrice: jest.Mock };
+
+    beforeEach(() => {
+      mgr = freshManager() as typeof mgr;
+      mockProvider = {
+        getBalance: jest.fn(),
+        getGasPrice: jest.fn().mockResolvedValue(ethers.BigNumber.from('20000000000')), // 20 gwei
+      };
+      (mockedEthers.providers.JsonRpcProvider as jest.Mock).mockReturnValue(mockProvider);
+    });
+
+    it('returns a valid gas estimate', async () => {
+      const estimate: GasEstimate = await mgr.estimateGas('0xFrom', '0xTo', '1.0', 1);
+      expect(estimate.gasLimit).toBe('21000');
+      expect(estimate.gasPrice).toBe('20.0');
+      expect(parseFloat(estimate.estimatedCost)).toBeGreaterThan(0);
+    });
+
+    it('throws when provider fails', async () => {
+      mockProvider.getGasPrice.mockRejectedValue(new Error('network error'));
+      await expect(mgr.estimateGas('0xFrom', '0xTo', '1.0', 1)).rejects.toThrow('network error');
+    });
+  });
+
+  describe('getWalletSigner (private)', () => {
+    it('throws when no connection', () => {
+      const mgr = freshManager();
+      // Access private via casting
+      expect(() => (mgr as any).getWalletSigner()).toThrow('Wallet is not connected');
+    });
+
+    it('throws when connection has no eip1193Provider', () => {
+      const mgr = freshManager();
+      mgr.setConnection(createMockConnection({ eip1193Provider: undefined }));
+      expect(() => (mgr as any).getWalletSigner()).toThrow('does not expose a signing provider');
+    });
+  });
+
+  describe('createSuperfluidStream – user rejection', () => {
+    it('throws friendly error when user rejects transaction', async () => {
+      const mgr = freshManager();
+      const mockSigner = {
+        provider: { getNetwork: jest.fn().mockResolvedValue({ chainId: 1 }) },
+        getAddress: jest.fn().mockResolvedValue('0xSender'),
+      };
+      jest.spyOn(mgr as any, 'getWalletSigner').mockReturnValue(mockSigner);
+
+      // Mock buildSuperfluidCreateFlowContext to throw rejection-like error
+      jest.spyOn(mgr as any, 'buildSuperfluidCreateFlowContext').mockRejectedValue({
+        code: 4001,
+        message: 'User rejected',
+      });
+
+      await expect(
+        mgr.createSuperfluidStream('ETH', '10', '0xRecipient', 1)
+      ).rejects.toThrow('Transaction was rejected in your wallet.');
+    });
+  });
+
+  describe('createSuperfluidStream – user denied (string code)', () => {
+    it('throws friendly error for ACTION_REJECTED code', async () => {
+      const mgr = freshManager();
+      const mockSigner = {
+        provider: { getNetwork: jest.fn().mockResolvedValue({ chainId: 1 }) },
+        getAddress: jest.fn().mockResolvedValue('0xSender'),
+      };
+      jest.spyOn(mgr as any, 'getWalletSigner').mockReturnValue(mockSigner);
+      jest.spyOn(mgr as any, 'buildSuperfluidCreateFlowContext').mockRejectedValue({
+        code: 'ACTION_REJECTED',
+      });
+
+      await expect(
+        mgr.createSuperfluidStream('ETH', '10', '0xRecipient', 1)
+      ).rejects.toThrow('Transaction was rejected in your wallet.');
+    });
+  });
+
+  describe('estimateSuperfluidCreateFlow – network mismatch', () => {
+    it('throws when wallet chainId differs from requested chainId', async () => {
+      const mgr = freshManager();
+      const mockSigner = {
+        provider: { getNetwork: jest.fn().mockResolvedValue({ chainId: 137 }) },
+      };
+      jest.spyOn(mgr as any, 'getWalletSigner').mockReturnValue(mockSigner);
+
+      await expect(
+        mgr.estimateSuperfluidCreateFlow('ETH', '10', '0xRecipient', 1)
+      ).rejects.toThrow('does not match selected chain');
+    });
+  });
+
+  describe('createSablierStream – user denied via message', () => {
+    it('throws friendly error for user denied message', async () => {
+      const mgr = freshManager();
+      const mockSigner = {
+        provider: { getNetwork: jest.fn().mockResolvedValue({ chainId: 1 }) },
+        getAddress: jest.fn().mockResolvedValue('0xSender'),
+      };
+      jest.spyOn(mgr as any, 'getWalletSigner').mockReturnValue(mockSigner);
+
+      // Simulate a generic error with "user denied" in message
+      jest.spyOn(ethers, 'Contract' as any).mockImplementation(() => {
+        throw new Error('user denied transaction');
+      });
+
+      await expect(
+        mgr.createSablierStream('0xToken', '10', Date.now(), Date.now() + 86400000, '0xRecipient', 1)
+      ).rejects.toThrow('Transaction was rejected in your wallet.');
+    });
+  });
+});