@steerprotocol/sdk 1.31.0 → 2.0.0

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

@@ -1,197 +0,0 @@
-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 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(),
-    };
-
-    walletClient = {
-      getAddresses: jest.fn().mockResolvedValue([addresses.user]),
-      writeContract: jest.fn(),
-    };
-
-    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,
-    };
-
-    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);
-    });
-
-    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);
-
-      expect(result.success).toBe(true);
-      expect(result.status).toBe(200);
-      expect(result.data).toBe(txHash);
-      expect(publicClient.simulateContract).toHaveBeenCalled();
-      expect(walletClient.writeContract).toHaveBeenCalled();
-    });
-
-    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');
-    });
-
-    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');
-    });
-
-    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__/client.test.ts

@@ -1,48 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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');
-  });
-});

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

@@ -1,47 +0,0 @@
-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);
-  });
-});

package/src/__tests__/fixtures/live/single-asset.fixture.json

@@ -1,116 +0,0 @@
-{
-  "metadata": {
-    "generatedAt": "2026-03-30T18:00:32.064Z",
-    "rpcSource": "https://polygon-bor-rpc.publicnode.com",
-    "chainId": 137
-  },
-  "simulateSwap": {
-    "input": {
-      "pool": "0x45dda9cb7c25131df268515131f647d726f50608",
-      "recipient": "0x9876543210987654321098765432109876543210",
-      "zeroForOne": true,
-      "amountSpecified": "1000000",
-      "sqrtPriceLimitX96": "0",
-      "ammType": 0,
-      "tokenIn": "0x2791bca1f2de4661ed88a30c99a7a9449aa84174",
-      "tokenOut": "0x7ceb23fd6bc0add59e62ac25578270cff1b9f619",
-      "fee": 500,
-      "tickSpacing": 10
-    },
-    "output": {
-      "data": {
-        "amount0": "-1000000",
-        "amount1": "489913938600096",
-        "sqrtPriceX96After": "1754074135530713293602128356420702"
-      },
-      "status": 200,
-      "success": true
-    }
-  },
-  "simulateSwapWithSlippage": {
-    "input": {
-      "poolAddress": "0x45dda9cb7c25131df268515131f647d726f50608",
-      "recipient": "0x9876543210987654321098765432109876543210",
-      "zeroForOne": true,
-      "amountSpecified": "1000000",
-      "sqrtPriceLimitX96": "1600000000000000000000000000000000",
-      "ammType": 0,
-      "tokenIn": "0x2791bca1f2de4661ed88a30c99a7a9449aa84174",
-      "tokenOut": "0x7ceb23fd6bc0add59e62ac25578270cff1b9f619",
-      "fee": 500
-    },
-    "output": {
-      "data": {
-        "currentSlot0": {
-          "sqrtPriceX96": "1754075247371157834334823157586178",
-          "tick": 200112,
-          "observationIndex": 46289,
-          "observationCardinality": 65535,
-          "observationCardinalityNext": 65535,
-          "feeProtocol": 0,
-          "unlocked": true
-        },
-        "swapSimulation": {
-          "amount0": "-1000000",
-          "amount1": "489913938600096",
-          "sqrtPriceX96After": "1754074135530713293602128356420702"
-        },
-        "priceSlippagePercent": "-0.00012",
-        "currentPrice": "490159328802188573314396030",
-        "priceAfter": "490158707416311168758437023"
-      },
-      "status": 200,
-      "success": true
-    }
-  },
-  "calculateSwapAmount": {
-    "input": {
-      "depositAmount": "100000000000000000000000",
-      "isToken0": true,
-      "vault": "0xea102e191687b47d23f1239c6bca03389fd98a32",
-      "pool": "0xba2d4a755982eefbd24c52cea01c9ff5d3813bd4",
-      "ammType": 0,
-      "singleAssetDepositContract": "0x9903C4ED61A71d0d5C322097adfF752d6339F871"
-    },
-    "output": {
-      "data": {
-        "swapAmount": "49984808670274063772085",
-        "sqrtPrice": "812025700435481301737673187372305"
-      },
-      "status": 200,
-      "success": true
-    }
-  },
-  "calculateLimitPrice": {
-    "zeroForOne": {
-      "input": {
-        "pool": "0xba2d4a755982eefbd24c52cea01c9ff5d3813bd4",
-        "slippageBP": 500,
-        "zeroForOne": true,
-        "ammType": 0,
-        "token0": "0x7ceb23fd6bc0add59e62ac25578270cff1b9f619",
-        "token1": "0xd1a718f77ab5d22e3955050658d7f65ae857a85e"
-      },
-      "output": {
-        "data": "791464750484408697177199631514733",
-        "status": 200,
-        "success": true
-      }
-    },
-    "oneForZero": {
-      "input": {
-        "pool": "0xba2d4a755982eefbd24c52cea01c9ff5d3813bd4",
-        "slippageBP": 300,
-        "zeroForOne": false,
-        "ammType": 0,
-        "token0": "0x7ceb23fd6bc0add59e62ac25578270cff1b9f619",
-        "token1": "0xd1a718f77ab5d22e3955050658d7f65ae857a85e"
-      },
-      "output": {
-        "data": "824116078178775758854379371184505",
-        "status": 200,
-        "success": true
-      }
-    }
-  }
-}