@steerprotocol/sdk 1.30.8 → 1.31.0

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

@@ -1,400 +1,197 @@
-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' },
-  },
-}
+import { parseEther } from 'viem';
+import { SingleAssetDepositClient } from '../../../../base/vault/single-asset/singleAssetDeposit.js';
+import { AMMType } from '../../../../base/vault/single-asset/types.js';
+
+jest.mock('../../../../base/vault/single-asset/calculateSwapAmount.js', () => ({
+  calculateSwapAmount: jest.fn(),
+}));
+
+jest.mock('../../../../base/vault/single-asset/calculateLimitPrice.js', () => ({
+  calculateLimitPrice: jest.fn(),
+}));
+
+jest.mock('../../../../base/vault/single-asset/simulateSwap.js', () => ({
+  determineSwapDirection: jest.fn((isToken0: boolean) => isToken0),
+  simulateSwapWithSlippage: jest.fn(),
+}));
+
+jest.mock('../../../../base/vault/single-asset/estimateLpTokens.js', () => ({
+  estimateLpTokens: jest.fn(),
+}));
+
+import { calculateSwapAmount } from '../../../../base/vault/single-asset/calculateSwapAmount.js';
+import { calculateLimitPrice } from '../../../../base/vault/single-asset/calculateLimitPrice.js';
+import { simulateSwapWithSlippage } from '../../../../base/vault/single-asset/simulateSwap.js';
+import { estimateLpTokens } from '../../../../base/vault/single-asset/estimateLpTokens.js';
 
 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 client: SingleAssetDepositClient;
+  let publicClient: any;
+  let walletClient: any;
+
+  const addresses = {
+    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}`,
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    publicClient = {
+      chain: { id: 137 },
+      getChainId: jest.fn().mockResolvedValue(137),
+      readContract: jest.fn().mockImplementation(async ({ functionName }: { functionName: string }) => {
+        if (functionName === 'token0') return addresses.token0;
+        if (functionName === 'token1') return addresses.token1;
+        if (functionName === 'fee') return 3000;
+        if (functionName === 'vaultDetailsByAddress') {
+          return { vaultType: 'MultiPositionUniswapV3' };
+        }
+        return { vaultType: 'MultiPositionUniswapV3' };
+      }),
+      simulateContract: jest.fn(),
     };
 
-    let realSteerClient: SteerClient;
-
-    beforeEach(() => {
-        publicClient = createPublicClient({chain: hyperEvmChain, transport: http()});
-        const walletClient = createWalletClient({chain: hyperEvmChain, transport: http()});
+    walletClient = {
+      getAddresses: jest.fn().mockResolvedValue([addresses.user]),
+      writeContract: jest.fn(),
+    };
 
-        // Initialize SteerClient with real clients
-        realSteerClient = new SteerClient({environment: 'production', client: publicClient, walletClient: walletClient});
+    client = new SingleAssetDepositClient(publicClient, walletClient);
+  });
+
+  describe('previewDeposit', () => {
+    const baseParams = {
+      assets: parseEther('100'),
+      receiver: addresses.receiver,
+      vault: addresses.vault,
+      isToken0: true,
+      depositSlippagePercent: 5n,
+      swapSlippageBP: 500,
+      ammType: AMMType.UniswapV3,
+      singleAssetDepositContract: addresses.contract,
+    };
 
-        client = realSteerClient.vaults.singleAssetDepositClient;
-        // Reset all mocks
-        jest.clearAllMocks();
+    it('successfully previews a complete single-asset deposit', async () => {
+      (calculateSwapAmount as jest.Mock).mockResolvedValue({
+        success: true,
+        status: 200,
+        data: {
+          swapAmount: parseEther('25'),
+          sqrtPrice: 79228162514264337593543950336n,
+        },
+      });
+
+      (calculateLimitPrice as jest.Mock).mockResolvedValue({
+        success: true,
+        status: 200,
+        data: 75266754285251620654291905318n,
+      });
+
+      (simulateSwapWithSlippage as jest.Mock).mockResolvedValue({
+        success: true,
+        status: 200,
+        data: {
+          swapSimulation: {
+            amount0: -parseEther('25'),
+            amount1: parseEther('50'),
+            sqrtPriceX96After: 75266754285251620654291905318n,
+          },
+        },
+      });
+
+      (estimateLpTokens as jest.Mock).mockResolvedValue({
+        success: true,
+        status: 200,
+        data: {
+          lpTokens: parseEther('95'),
+          finalAmount0: parseEther('75'),
+          finalAmount1: parseEther('50'),
+        },
+      });
+
+      const result = await client.previewDeposit(baseParams, addresses.pool);
+
+      expect(result.success).toBe(true);
+      expect(result.status).toBe(200);
+      expect(result.data?.swapAmount).toBe(parseEther('25'));
+      expect(result.data?.lpEstimation.lpTokens).toBe(parseEther('95'));
+      expect(result.data?.zeroForOne).toBe(true);
     });
 
-    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
-        });
+    it('returns swap calculation failure', async () => {
+      (calculateSwapAmount as jest.Mock).mockResolvedValue({
+        success: false,
+        status: 500,
+        error: 'Swap calculation failed',
+      });
+
+      const result = await client.previewDeposit(baseParams, addresses.pool);
 
+      expect(result.success).toBe(false);
+      expect(result.status).toBe(500);
+      expect(result.error).toBe('Swap calculation failed');
+      expect(result.data).toBeNull();
     });
+  });
+
+  describe('deposit', () => {
+    const baseParams = {
+      assets: parseEther('100'),
+      receiver: addresses.receiver,
+      vault: addresses.vault,
+      isToken0: true,
+      depositSlippagePercent: 5n,
+      swapSlippageBP: 500,
+      ammType: AMMType.UniswapV3,
+      singleAssetDepositContract: addresses.contract,
+    };
+
+    it('successfully executes deposit', async () => {
+      const txHash = `0x${'a'.repeat(64)}` as `0x${string}`;
+      publicClient.simulateContract.mockResolvedValue({ request: { to: addresses.contract } });
+      walletClient.writeContract.mockResolvedValue(txHash);
+
+      const result = await client.deposit(baseParams);
 
-    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');
-        });
+      expect(result.success).toBe(true);
+      expect(result.status).toBe(200);
+      expect(result.data).toBe(txHash);
+      expect(publicClient.simulateContract).toHaveBeenCalled();
+      expect(walletClient.writeContract).toHaveBeenCalled();
     });
 
-    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');
-        });
+    it('returns error when no account exists', async () => {
+      walletClient.getAddresses.mockResolvedValue([]);
+
+      const result = await client.deposit(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();
-        });
+    it('returns simulation failure', async () => {
+      publicClient.simulateContract.mockRejectedValue(new Error('Simulation failed'));
+
+      const result = await client.deposit(baseParams);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Simulation failed');
     });
 
-    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'));
-        });
+    it('returns transaction failure', async () => {
+      publicClient.simulateContract.mockResolvedValue({ request: { to: addresses.contract } });
+      walletClient.writeContract.mockRejectedValue(new Error('Transaction failed'));
+
+      const result = await client.deposit(baseParams);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Transaction failed');
     });
+  });
 });

package/src/__tests__/const/network.feeManager.test.ts

@@ -0,0 +1,47 @@
+import { ChainId } from '../../const/chain.js';
+import type { NetworkConfig } from '../../const/network.js';
+import { feeManagerContractsByChainId } from '../../const/feeManagerContracts.js';
+import { getContractAddressByChainIdAndContractName, networks } from '../../const/network.js';
+
+describe('network FeeManager overlay', () => {
+  it('backfills FeeManager for chains missing it in legacy SDK deployment files', () => {
+    expect(getContractAddressByChainIdAndContractName(ChainId.Base, 'FeeManager')).toBe(
+      feeManagerContractsByChainId[ChainId.Base]?.address
+    );
+    expect(getContractAddressByChainIdAndContractName(ChainId.Avalanche, 'FeeManager')).toBe(
+      feeManagerContractsByChainId[ChainId.Avalanche]?.address
+    );
+    expect(getContractAddressByChainIdAndContractName(ChainId.Linea, 'FeeManager')).toBe(
+      feeManagerContractsByChainId[ChainId.Linea]?.address
+    );
+    expect(getContractAddressByChainIdAndContractName(ChainId.Scroll, 'FeeManager')).toBe(
+      feeManagerContractsByChainId[ChainId.Scroll]?.address
+    );
+  });
+
+  it('prefers contracts package FeeManager values when they conflict', () => {
+    expect(getContractAddressByChainIdAndContractName(ChainId.BeraChainBartio, 'FeeManager')).toBe(
+      feeManagerContractsByChainId[ChainId.BeraChainBartio]?.address
+    );
+  });
+
+  it('keeps SDK-only FeeManager entries when contracts map has no chain match', () => {
+    expect(feeManagerContractsByChainId[ChainId.Hyperevm]).toBeUndefined();
+    expect(getContractAddressByChainIdAndContractName(ChainId.Hyperevm, 'FeeManager')).toBe(
+      '0x8BfAdC53bfd06F051685b42690076d9c94aaBCBd'
+    );
+  });
+
+  it('exposes materially more FeeManager-enabled networks than legacy baseline', () => {
+    const feeManagerEnabledNetworks = (Object.values(networks) as NetworkConfig[]).filter(
+      (network) => Boolean(network.FeeManager?.address)
+    );
+    const chainIds = feeManagerEnabledNetworks.map((network) => network.chainId);
+
+    expect(feeManagerEnabledNetworks.length).toBeGreaterThan(4);
+    expect(chainIds).toContain(ChainId.Base);
+    expect(chainIds).toContain(ChainId.Avalanche);
+    expect(chainIds).toContain(ChainId.Linea);
+    expect(chainIds).toContain(ChainId.Scroll);
+  });
+});