feat: enable Soroswap Smart Wallet support with DeFi safety validation (#165)

packages/core/defi-protocols/__tests__/protocols/blend-protocol-operations.test.ts

@@ -355,6 +355,41 @@ describe('BlendProtocol - Operations Tests', () => {
         blendProtocol.supply(testAddress, testPrivateKey, invalidAsset, '1000000')
       ).rejects.toThrow('Invalid asset');
     });
+
+    it('should return pending transaction when privateKey is not provided', async () => {
+      // Mock transaction builder
+      const mockTx = {
+        toXDR: jest.fn(() => 'mocked-xdr')
+      };
+      (TransactionBuilder as jest.MockedClass<typeof TransactionBuilder>).mockImplementation(
+        () =>
+          ({
+            addOperation: jest.fn().mockReturnThis(),
+            setTimeout: jest.fn().mockReturnThis(),
+            build: jest.fn(() => mockTx)
+          } as any)
+      );
+
+      // Mock simulation success
+      const mockSimulation = {
+        result: { mock: 'result' }
+      };
+      mockSorobanServer.simulateTransaction = jest
+        .fn()
+        .mockResolvedValue(mockSimulation);
+      (rpc.Api.isSimulationError as jest.Mock).mockReturnValue(false);
+
+      // Mock prepareTransaction
+      const mockPreparedTx = {
+        toXDR: jest.fn(() => 'prepared-xdr')
+      };
+      mockSorobanServer.prepareTransaction = jest.fn().mockResolvedValue(mockPreparedTx);
+
+      const result = await blendProtocol.supply(testAddress, null as any, testAsset, '1000000');
+
+      expect(result.status).toBe('pending');
+      expect(mockSorobanServer.prepareTransaction).toHaveBeenCalled();
+    });
   });
 
   // ========================================
@@ -550,6 +585,41 @@ describe('BlendProtocol - Operations Tests', () => {
         blendProtocol.withdraw(testAddress, testPrivateKey, invalidAsset, '500000')
       ).rejects.toThrow('Invalid asset');
     });
+
+    it('should return pending transaction when privateKey is not provided', async () => {
+      // Mock transaction builder
+      const mockTx = {
+        toXDR: jest.fn(() => 'mocked-xdr')
+      };
+      (TransactionBuilder as jest.MockedClass<typeof TransactionBuilder>).mockImplementation(
+        () =>
+          ({
+            addOperation: jest.fn().mockReturnThis(),
+            setTimeout: jest.fn().mockReturnThis(),
+            build: jest.fn(() => mockTx)
+          } as any)
+      );
+
+      // Mock simulation success
+      const mockSimulation = {
+        result: { mock: 'result' }
+      };
+      mockSorobanServer.simulateTransaction = jest
+        .fn()
+        .mockResolvedValue(mockSimulation);
+      (rpc.Api.isSimulationError as jest.Mock).mockReturnValue(false);
+
+      // Mock prepareTransaction
+      const mockPreparedTx = {
+        toXDR: jest.fn(() => 'prepared-xdr')
+      };
+      mockSorobanServer.prepareTransaction = jest.fn().mockResolvedValue(mockPreparedTx);
+
+      const result = await blendProtocol.withdraw(testAddress, null as any, testAsset, '500000');
+
+      expect(result.status).toBe('pending');
+      expect(mockSorobanServer.prepareTransaction).toHaveBeenCalled();
+    });
   });
 
   // ========================================
@@ -682,6 +752,41 @@ describe('BlendProtocol - Operations Tests', () => {
         blendProtocol.borrow(testAddress, testPrivateKey, invalidAsset, '250000')
       ).rejects.toThrow('Invalid asset');
     });
+
+    it('should return pending transaction when privateKey is not provided', async () => {
+      // Mock transaction builder
+      const mockTx = {
+        toXDR: jest.fn(() => 'mocked-xdr')
+      };
+      (TransactionBuilder as jest.MockedClass<typeof TransactionBuilder>).mockImplementation(
+        () =>
+          ({
+            addOperation: jest.fn().mockReturnThis(),
+            setTimeout: jest.fn().mockReturnThis(),
+            build: jest.fn(() => mockTx)
+          } as any)
+      );
+
+      // Mock simulation success
+      const mockSimulation = {
+        result: { mock: 'result' }
+      };
+      mockSorobanServer.simulateTransaction = jest
+        .fn()
+        .mockResolvedValue(mockSimulation);
+      (rpc.Api.isSimulationError as jest.Mock).mockReturnValue(false);
+
+      // Mock prepareTransaction
+      const mockPreparedTx = {
+        toXDR: jest.fn(() => 'prepared-xdr')
+      };
+      mockSorobanServer.prepareTransaction = jest.fn().mockResolvedValue(mockPreparedTx);
+
+      const result = await blendProtocol.borrow(testAddress, null as any, testAsset, '250000');
+
+      expect(result.status).toBe('pending');
+      expect(mockSorobanServer.prepareTransaction).toHaveBeenCalled();
+    });
   });
 
   // ========================================
@@ -814,6 +919,41 @@ describe('BlendProtocol - Operations Tests', () => {
         blendProtocol.repay(testAddress, testPrivateKey, invalidAsset, '250000')
       ).rejects.toThrow('Invalid asset');
     });
+
+    it('should return pending transaction when privateKey is not provided', async () => {
+      // Mock transaction builder
+      const mockTx = {
+        toXDR: jest.fn(() => 'mocked-xdr')
+      };
+      (TransactionBuilder as jest.MockedClass<typeof TransactionBuilder>).mockImplementation(
+        () =>
+          ({
+            addOperation: jest.fn().mockReturnThis(),
+            setTimeout: jest.fn().mockReturnThis(),
+            build: jest.fn(() => mockTx)
+          } as any)
+      );
+
+      // Mock simulation success
+      const mockSimulation = {
+        result: { mock: 'result' }
+      };
+      mockSorobanServer.simulateTransaction = jest
+        .fn()
+        .mockResolvedValue(mockSimulation);
+      (rpc.Api.isSimulationError as jest.Mock).mockReturnValue(false);
+
+      // Mock prepareTransaction
+      const mockPreparedTx = {
+        toXDR: jest.fn(() => 'prepared-xdr')
+      };
+      mockSorobanServer.prepareTransaction = jest.fn().mockResolvedValue(mockPreparedTx);
+
+      const result = await blendProtocol.repay(testAddress, null as any, testAsset, '250000');
+
+      expect(result.status).toBe('pending');
+      expect(mockSorobanServer.prepareTransaction).toHaveBeenCalled();
+    });
   });
 
   // ========================================

packages/core/defi-protocols/__tests__/protocols/blend-protocol.test.ts

@@ -111,6 +111,7 @@ describe('BlendProtocol', () => {
   let mockHorizonServer: any;
 
   const testAddress = 'GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5';
+  const testBorrowerAddress = 'GDXFZ4UXBQPTPLQHZJ2IZ3MJRZ6G7CRGSKXM3XDMIFV4KQDLXP2KPXK5';
   const testPrivateKey = 'SAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABSC4';
   const testAsset: Asset = {
     code: 'USDC',
@@ -416,7 +417,7 @@ describe('BlendProtocol', () => {
       const result = await blendProtocol.liquidate(
         testAddress,
         testPrivateKey,
-        'borrower-address',
+        testBorrowerAddress,
         testAsset,
         debtAmount,
         testAsset
@@ -442,7 +443,7 @@ describe('BlendProtocol', () => {
       await expect(blendProtocol.liquidate(
         testAddress,
         testPrivateKey,
-        'borrower-address',
+        testBorrowerAddress,
         testAsset,
         '50',
         testAsset

packages/core/defi-protocols/__tests__/protocols/soroswap-protocol.test.ts

@@ -245,6 +245,20 @@ describe('SoroswapProtocol', () => {
       expect(stats.utilizationRate).toBe(0);
       expect(stats.timestamp).toBeInstanceOf(Date);
     });
+
+    it('should handle errors in getStats gracefully', async () => {
+      // Force an error by corrupting the internal state
+      const originalNew = Date.prototype.getTime;
+      Date.prototype.getTime = (() => { throw new Error('Time error'); }) as any;
+
+      const stats = await soroswapProtocol.getStats();
+
+      // Should still return default stats due to error handling
+      expect(stats).toBeDefined();
+
+      // Restore original function
+      Date.prototype.getTime = originalNew;
+    });
   });
 
   // ==========================================
@@ -775,6 +789,25 @@ describe('SoroswapProtocol', () => {
       const pool = await soroswapProtocol.getLiquidityPool(tokenA, tokenB);
       expect(pool.address).toBe('');
     });
+
+    it('should handle fromScVal error when parsing pair address', async () => {
+      (soroswapProtocol as any).sorobanServer.simulateTransaction.mockResolvedValueOnce({
+        result: { retval: { type: 'address' } }
+      });
+      (Address.fromScVal as jest.Mock).mockImplementationOnce(() => {
+        throw new Error('fromScVal parse error');
+      });
+
+      const pool = await soroswapProtocol.getLiquidityPool(tokenA, tokenB);
+      expect(pool.address).toBe('');
+    });
+
+    it('should throw on general errors in getLiquidityPool', async () => {
+      // Force an error by corrupting factoryContract
+      (soroswapProtocol as any).factoryContract = { call: () => { throw new Error('Contract error'); } };
+
+      await expect(soroswapProtocol.getLiquidityPool(tokenA, tokenB)).rejects.toThrow('Contract error');
+    });
   });
 
   // ==========================================
@@ -1034,6 +1067,17 @@ describe('SoroswapProtocol', () => {
 
       expect(analytics.feeApr).toBe(0);
     });
+
+    it('should throw on general errors in getPoolAnalytics', async () => {
+      // Force an error by making sorobanServer undefined
+      const originalServer = (soroswapProtocol as any).sorobanServer;
+      (soroswapProtocol as any).sorobanServer = undefined;
+
+      await expect(soroswapProtocol.getPoolAnalytics(poolAddress)).rejects.toThrow();
+
+      // Restore original server
+      (soroswapProtocol as any).sorobanServer = originalServer;
+    });
   });
 
   // ==========================================
@@ -1087,5 +1131,12 @@ describe('SoroswapProtocol', () => {
 
       await expect(uninitProtocol.getAllPoolsAnalytics()).rejects.toThrow(/not initialized/);
     });
+
+    it('should throw on general errors in getAllPoolsAnalytics', async () => {
+      // Force an error by making getAllPairs throw an error
+      jest.spyOn(soroswapProtocol, 'getAllPairs').mockRejectedValueOnce(new Error('Network error'));
+
+      await expect(soroswapProtocol.getAllPoolsAnalytics()).rejects.toThrow('Network error');
+    });
   });
 });