@steerprotocol/sdk 1.26.0 → 1.28.0

package/src/__tests__/base/vault/single-asset/singleAssetDepositClient.test.ts

@@ -0,0 +1,400 @@
+import {Chain, createPublicClient, createWalletClient, http, parseEther} from 'viem';
+import {polygon} from 'viem/chains';
+import {SingleAssetDepositClient} from '../../../../base/vault/single-asset/singleAssetDeposit.js';
+import {AMMType, SingleAssetDepositParams} from '../../../../base/vault/single-asset/types.js';
+
+// Mock all the individual step functions
+
+import {SteerClient} from '../../../../client.js';
+
+
+const hyperEvmChain: Chain =  {
+  id: 999,
+  name: 'Hyperevm',
+  nativeCurrency: {
+    decimals: 18,
+    name: 'HYPE',
+    symbol: 'HYPE',
+  },
+  rpcUrls: {
+    public: { http: ['https://rpc.hyperlend.finance'] },
+    default: { http: ['https://rpc.hyperliquid.xyz/evm'] }
+  },
+  blockExplorers: {
+    default: { name: 'Hyperevm', url: 'https://hyperevmscan.io' },
+  },
+}
+
+describe('SingleAssetDepositClient', () => {
+    let client: SingleAssetDepositClient;
+    let publicClient: any;
+    let walletClient: any;
+
+    const mockAddresses = {
+        vault: '0xea102e191687b47d23f1239c6bca03389fd98a32' as `0x${string}`,
+        pool: '0xba2d4a755982eefbd24c52cea01c9ff5d3813bd4' as `0x${string}`,
+        contract: '0x3456789012345678901234567890123456789012' as `0x${string}`,
+        receiver: '0x9876543210987654321098765432109876543210' as `0x${string}`,
+        user: '0x9876543210987654321098765432109876543210' as `0x${string}`,
+        token0: '0x7ceb23fd6bc0add59e62ac25578270cff1b9f619' as `0x${string}`,
+        token1: '0xd1a718f77ab5d22e3955050658d7f65ae857a85e' as `0x${string}`
+    };
+
+    let realSteerClient: SteerClient;
+
+    beforeEach(() => {
+        publicClient = createPublicClient({chain: hyperEvmChain, transport: http()});
+        const walletClient = createWalletClient({chain: hyperEvmChain, transport: http()});
+
+        // Initialize SteerClient with real clients
+        realSteerClient = new SteerClient({environment: 'production', client: publicClient, walletClient: walletClient});
+
+        client = realSteerClient.vaults.singleAssetDepositClient;
+        // Reset all mocks
+        jest.clearAllMocks();
+    });
+
+    describe('previewDeposit', () => {
+        const baseParams = {
+            assets: parseEther('100'),
+            receiver: mockAddresses.receiver,
+            vault: mockAddresses.vault,
+            isToken0: true,
+            depositSlippagePercent: 5n,
+            swapSlippageBP: 500,
+            ammType: AMMType.UniswapV3
+        };
+
+        it.only('should successfully preview a complete single-asset deposit', async () => {
+
+            // const params: SingleAssetDepositParams = {
+            // "assets":1000000000000000000n,"receiver":"0x50f72c67ab509dDaFFd35c385ffB904B9E255547","vault":"0xea102e191687b47d23f1239c6bca03389fd98a32","isToken0":true,"depositSlippagePercent":85n,"swapSlippageBP":500,"ammType":0}
+
+            const params: SingleAssetDepositParams = {
+                ammType: 4,
+                assets: 1000000000000000000n,
+                depositSlippagePercent: 85n,
+                isToken0: false,
+                receiver: "0x50f72c67ab509dDaFFd35c385ffB904B9E255547",
+                swapSlippageBP: 500,
+                vault: "0xbf39c114d2ddf657f26c158a2a04c399c4cb1c2d"
+            }
+            const result = await realSteerClient.vaults.previewSingleAssetDeposit(params, '0x51323f313e36a93fac2e1e929e48b961ffce5510');
+
+            console.log('Preview deposit update')
+
+            expect(result.success).toBe(true);
+            expect(result.status).toBe(200);
+            expect(result.data).toEqual({
+                swapAmount: parseEther('25'),
+                currentSqrtPrice: BigInt('79228162514264337593543950336'),
+                sqrtPriceLimitX96: BigInt('75266754285251620654291905318'),
+                swapSimulation: {
+                    amount0: -parseEther('25'),
+                    amount1: parseEther('50')
+                },
+                lpEstimation: {
+                    lpTokens: parseEther('95'),
+                    finalAmount0: parseEther('75'),
+                    finalAmount1: parseEther('50')
+                },
+                zeroForOne: true
+            });
+
+        });
+
+        it('should handle token1 deposit', async () => {
+            const token1Params = {
+                ... baseParams,
+                isToken0: false
+            };
+
+
+            const result = await client.previewDeposit(token1Params, mockAddresses.pool);
+
+            expect(result.success).toBe(true);
+            expect(result.data ?. zeroForOne).toBe(false);
+        });
+
+        it('should handle calculateSwapAmount failure', async () => {
+
+            const result = await client.previewDeposit(baseParams, mockAddresses.pool);
+
+            expect(result.success).toBe(false);
+            expect(result.status).toBe(500);
+            expect(result.error).toBe('Swap calculation failed');
+            expect(result.data).toBeNull();
+
+            // Should not call subsequent functions
+        });
+
+    });
+
+    describe('deposit', () => {
+        const baseParams = {
+            assets: parseEther('100'),
+            receiver: mockAddresses.receiver,
+            vault: mockAddresses.vault,
+            isToken0: true,
+            depositSlippagePercent: 5n,
+            swapSlippageBP: 500,
+            ammType: AMMType.UniswapV3,
+            singleAssetDepositContract: mockAddresses.contract
+        };
+
+        it('should successfully execute deposit', async () => {
+            const mockTxHash = '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890';
+
+            walletClient.getAddresses = jest.fn().mockResolvedValue([mockAddresses.user]);
+            publicClient.simulateContract = jest.fn().mockResolvedValue({
+                request: {
+                    address: mockAddresses.contract,
+                    abi: expect.any(Array),
+                    functionName: 'deposit',
+                    args: [
+                        parseEther('100'),
+                        mockAddresses.receiver,
+                        mockAddresses.vault,
+                        true,
+                        5n,
+                        500,
+                        AMMType.UniswapV3
+                    ]
+                }
+            });
+            walletClient.writeContract = jest.fn().mockResolvedValue(mockTxHash);
+
+            const result = await client.deposit(baseParams);
+
+            expect(result.success).toBe(true);
+            expect(result.status).toBe(200);
+            expect(result.data).toBe(mockTxHash);
+
+            expect(publicClient.simulateContract).toHaveBeenCalledWith({
+                address: mockAddresses.contract,
+                abi: expect.any(Array),
+                functionName: 'deposit',
+                args: [
+                    parseEther('100'),
+                    mockAddresses.receiver,
+                    mockAddresses.vault,
+                    true,
+                    5n,
+                    500,
+                    AMMType.UniswapV3
+                ],
+                account: mockAddresses.user
+            });
+
+            expect(walletClient.writeContract).toHaveBeenCalled();
+        });
+
+        it('should handle no account found', async () => {
+            walletClient.getAddresses = jest.fn().mockResolvedValue([]);
+
+            const result = await client.deposit(baseParams);
+
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('No account found');
+        });
+
+        it('should handle simulation failure', async () => {
+            walletClient.getAddresses = jest.fn().mockResolvedValue([mockAddresses.user]);
+            publicClient.simulateContract = jest.fn().mockRejectedValue(new Error('Simulation failed'));
+
+            const result = await client.deposit(baseParams);
+
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Simulation failed');
+        });
+
+        it('should handle transaction failure', async () => {
+            walletClient.getAddresses = jest.fn().mockResolvedValue([mockAddresses.user]);
+            publicClient.simulateContract = jest.fn().mockResolvedValue({request: {}});
+            walletClient.writeContract = jest.fn().mockRejectedValue(new Error('Transaction failed'));
+
+            const result = await client.deposit(baseParams);
+
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Transaction failed');
+        });
+    });
+
+    describe('prepareDepositTx', () => {
+        const baseParams = {
+            assets: parseEther('100'),
+            receiver: mockAddresses.receiver,
+            vault: mockAddresses.vault,
+            isToken0: true,
+            depositSlippagePercent: 5n,
+            swapSlippageBP: 500,
+            ammType: AMMType.UniswapV3,
+            singleAssetDepositContract: mockAddresses.contract
+        };
+
+        it('should successfully prepare deposit transaction', async () => {
+            walletClient.getAddresses = jest.fn().mockResolvedValue([mockAddresses.user]);
+            publicClient.simulateContract = jest.fn().mockResolvedValue({
+                request: {
+                    address: mockAddresses.contract,
+                    functionName: 'deposit',
+                    args: [/* mock args */
+                    ]
+                }
+            });
+
+            const result = await client.prepareDepositTx(baseParams);
+
+            expect(result.success).toBe(true);
+            expect(result.status).toBe(200);
+            expect(result.data).toEqual({
+                address: mockAddresses.contract,
+                abi: expect.any(Array),
+                functionName: 'deposit',
+                args: [
+                    parseEther('100'),
+                    mockAddresses.receiver,
+                    mockAddresses.vault,
+                    true,
+                    5n,
+                    500,
+                    AMMType.UniswapV3
+                ]
+            });
+        });
+
+        it('should handle preparation errors', async () => {
+            walletClient.getAddresses = jest.fn().mockResolvedValue([]);
+
+            const result = await client.prepareDepositTx(baseParams);
+
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('No account found');
+        });
+    });
+
+    describe('validateDepositParams', () => {
+        const validParams = {
+            assets: parseEther('100'),
+            receiver: mockAddresses.receiver,
+            vault: mockAddresses.vault,
+            isToken0: true,
+            depositSlippagePercent: 5n,
+            swapSlippageBP: 500,
+            ammType: AMMType.UniswapV3,
+            singleAssetDepositContract: mockAddresses.contract
+        };
+
+        it('should not throw for valid parameters', () => {
+            expect(() => client.validateDepositParams(validParams)).not.toThrow();
+        });
+
+        it('should throw for zero assets', () => {
+            expect(() => client.validateDepositParams({
+                ... validParams,
+                assets: BigInt('0')
+            })).toThrow('Assets amount must be greater than 0');
+        });
+
+        it('should throw for invalid vault address', () => {
+            expect(() => client.validateDepositParams({
+                ... validParams,
+                vault: '0x0000000000000000000000000000000000000000'
+            })).toThrow('Invalid vault address');
+        });
+
+        it('should throw for invalid receiver address', () => {
+            expect(() => client.validateDepositParams({
+                ... validParams,
+                receiver: '0x0000000000000000000000000000000000000000'
+            })).toThrow('Invalid receiver address');
+        });
+
+        it('should throw for invalid contract address', () => {
+            expect(() => client.validateDepositParams({
+                ... validParams,
+                singleAssetDepositContract: '0x0000000000000000000000000000000000000000'
+            })).toThrow('Invalid single-asset deposit contract address');
+        });
+
+        it('should throw for excessive deposit slippage', () => {
+            expect(() => client.validateDepositParams({
+                ... validParams,
+                depositSlippagePercent: 101n
+            })).toThrow('Deposit slippage percent cannot exceed 100%');
+        });
+
+        it('should throw for excessive swap slippage', () => {
+            expect(() => client.validateDepositParams({
+                ... validParams,
+                swapSlippageBP: 10001
+            })).toThrow('Swap slippage BP cannot exceed 10000 (100%)');
+        });
+
+        it('should throw for invalid AMM type', () => {
+            expect(() => client.validateDepositParams({
+                ... validParams,
+                ammType: 999 as AMMType
+            })).toThrow('Invalid AMM type');
+        });
+
+        it('should handle edge case values', () => { // Test maximum allowed values
+            expect(() => client.validateDepositParams({
+                ... validParams,
+                depositSlippagePercent: 100n,
+                swapSlippageBP: 10000
+            })).not.toThrow();
+
+            // Test minimum values
+            expect(() => client.validateDepositParams({
+                ... validParams,
+                assets: BigInt('1'),
+                depositSlippagePercent: 0n,
+                swapSlippageBP: 0
+            })).not.toThrow();
+        });
+    });
+
+    describe('integration scenarios', () => {
+        it('should handle complete flow for balanced pool', async () => {
+            const params = {
+                assets: parseEther('100'),
+                receiver: mockAddresses.receiver,
+                vault: mockAddresses.vault,
+                isToken0: true,
+                depositSlippagePercent: 3n,
+                swapSlippageBP: 300,
+                ammType: AMMType.UniswapV3,
+                singleAssetDepositContract: mockAddresses.contract
+            };
+
+
+            const result = await client.previewDeposit(params, mockAddresses.pool);
+
+            expect(result.success).toBe(true);
+            expect(result.data ?. swapAmount).toBe(parseEther('50'));
+            expect(result.data ?. lpEstimation.finalAmount0).toBe(parseEther('50'));
+            expect(result.data ?. lpEstimation.finalAmount1).toBe(parseEther('50'));
+        });
+
+        it('should handle imbalanced pool scenario', async () => {
+            const params = {
+                assets: parseEther('100'),
+                receiver: mockAddresses.receiver,
+                vault: mockAddresses.vault,
+                isToken0: true,
+                depositSlippagePercent: 5n,
+                swapSlippageBP: 500,
+                ammType: AMMType.UniswapV3,
+                singleAssetDepositContract: mockAddresses.contract
+            };
+
+
+            const result = await client.previewDeposit(params, mockAddresses.pool);
+
+            expect(result.success).toBe(true);
+            expect(result.data ?. swapAmount).toBe(parseEther('80'));
+            expect(result.data ?. lpEstimation.lpTokens).toBe(parseEther('60'));
+        });
+    });
+});

package/src/__tests__/client.test.ts

@@ -0,0 +1,48 @@
+import { createPublicClient, http } from 'viem';
+import { polygon } from 'viem/chains';
+import { SteerClient } from '../client.js';
+import { SteerConfig } from '../types.js';
+import { VaultClient } from '../base/VaultClient.js';
+
+describe('SteerClient', () => {
+  let client: SteerClient;
+  const mockViemClient = createPublicClient({
+    chain: polygon,
+    transport: http('https://polygon-mainnet.g.alchemy.com/v2/VjQCxdNfXfyvPacuKwjsrhOsWc_g6X27')
+  });
+  
+  beforeEach(() => {
+    const config: SteerConfig = {
+      environment: 'development',
+      client: mockViemClient
+    };
+    client = new SteerClient(config);
+  });
+
+  describe('constructor', () => {
+    it('should create a new instance with valid config', () => {
+      expect(client).toBeInstanceOf(SteerClient);
+    });
+
+    it('should default to production environment if not specified', () => {
+      const configWithoutEnv: SteerConfig = {
+        client: mockViemClient
+      };
+      const clientWithoutEnv = new SteerClient(configWithoutEnv);
+      expect(clientWithoutEnv).toBeInstanceOf(SteerClient);
+    });
+
+    it('should initialize vaults property', () => {
+      expect(client.vaults).toBeInstanceOf(VaultClient);
+    });
+  });
+
+  describe('getActiveChain', () => {
+    it('should return the current chain ID', async () => {
+      const response = await client.getActiveChain();
+      expect(response.success).toBe(true);
+      expect(response.status).toBe(200);
+      expect(response.data).toBe(137); // polygon chain ID
+    });
+  });
+}); 

package/src/__tests__/const/capabilities.test.ts

@@ -0,0 +1,24 @@
+import { getSupportedChainIds, getSupportedChains } from '../../const/capabilities.js';
+import { ChainId } from '../../const/chain.js';
+
+describe('capabilities', () => {
+  it('returns supported chain ids (subgraph-backed)', () => {
+    const ids = getSupportedChainIds();
+
+    expect(Array.isArray(ids)).toBe(true);
+    expect(ids.length).toBeGreaterThan(0);
+
+    expect(ids).toContain(ChainId.Polygon);
+  });
+
+  it('can include deployments and filter by feature', () => {
+    const chains = getSupportedChains({
+      include: { subgraph: true, deployments: true, protocols: false, singleAssetDeposit: true },
+      filter: { feature: 'singleAssetDeposit' },
+    });
+
+    expect(chains.every((c) => c.features.singleAssetDeposit)).toBe(true);
+
+    expect(chains[0]).toHaveProperty('deployments');
+  });
+});