@lombard.finance/sdk 4.0.0 → 4.1.2

package/src/__tests__/unit/evm/EvmRedeem.test.ts

@@ -1,207 +0,0 @@
-/**
- * EVM Redeem Action Unit Tests
- *
- * Tests the LBTC → BTC.b redemption flow on EVM chains.
- *
- * @module __tests__/unit/evm/EvmRedeem.test.ts
- */
-
-import { describe, expect, it, vi } from 'vitest';
-
-import { AssetId, Chain } from '../../../core';
-import { LombardError, ValidationErrorCode } from '../../../shared/errors';
-
-describe('EvmRedeem Interface', () => {
-  describe('EvmRedeemParams', () => {
-    it('should require LBTC as input asset', () => {
-      const params = {
-        assetIn: AssetId.LBTC,
-        assetOut: AssetId.BTCb,
-        sourceChain: Chain.AVALANCHE,
-      };
-
-      expect(params.assetIn).toBe(AssetId.LBTC);
-    });
-
-    it('should require BTCb as output asset', () => {
-      const params = {
-        assetIn: AssetId.LBTC,
-        assetOut: AssetId.BTCb,
-        sourceChain: Chain.AVALANCHE,
-      };
-
-      expect(params.assetOut).toBe(AssetId.BTCb);
-    });
-
-    it('should be same-chain operation', () => {
-      const params = {
-        assetIn: AssetId.LBTC,
-        assetOut: AssetId.BTCb,
-        sourceChain: Chain.AVALANCHE,
-        destChain: Chain.AVALANCHE, // Same as source
-      };
-
-      expect(params.sourceChain).toBe(params.destChain);
-    });
-  });
-
-  describe('EvmRedeemPrepareParams', () => {
-    it('should accept valid prepare parameters', () => {
-      const params = {
-        amount: '0.1',
-        recipient: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
-      };
-
-      expect(params.amount).toBe('0.1');
-      expect(params.recipient).toBeDefined();
-    });
-
-    it('should require EVM recipient address', () => {
-      const params = {
-        amount: '0.1',
-        recipient: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
-      };
-
-      expect(params.recipient).toMatch(/^0x/);
-    });
-  });
-
-  describe('Status Transitions', () => {
-    it('should define all required status values', () => {
-      const statuses = [
-        'idle',
-        'needs-approval',
-        'ready',
-        'completed',
-      ];
-
-      statuses.forEach(status => {
-        expect(typeof status).toBe('string');
-      });
-    });
-  });
-
-  describe('Method Signatures', () => {
-    it('should define prepare method', () => {
-      type PrepareMethod = (params: { amount: string; recipient: string }) => Promise<void>;
-      const testType: PrepareMethod = async () => {};
-      expect(testType).toBeDefined();
-    });
-
-    it('should define approve method', () => {
-      type ApproveMethod = () => Promise<void>;
-      const testType: ApproveMethod = async () => {};
-      expect(testType).toBeDefined();
-    });
-
-    it('should define execute method', () => {
-      type ExecuteMethod = () => Promise<{ txHash: string }>;
-      const testType: ExecuteMethod = async () => ({ txHash: '0x123' });
-      expect(testType).toBeDefined();
-    });
-  });
-
-  describe('Redemption Logic', () => {
-    it('should burn LBTC and mint BTC.b', () => {
-      // Redeem burns LBTC and mints equivalent BTC.b
-      const redeemFlow = {
-        input: AssetId.LBTC,
-        output: AssetId.BTCb,
-        operation: 'burn-and-mint',
-      };
-
-      expect(redeemFlow.operation).toBe('burn-and-mint');
-    });
-
-    it('should be 1:1 conversion', () => {
-      const inputAmount = '0.1';
-      const outputAmount = '0.1'; // 1:1 ratio
-      
-      expect(inputAmount).toBe(outputAmount);
-    });
-  });
-
-  describe('Token Approval', () => {
-    it('should require LBTC approval before redemption', () => {
-      const approvalRequired = true;
-      expect(approvalRequired).toBe(true);
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should reject BTC as output (use unstake)', () => {
-      const error = new LombardError(
-        ValidationErrorCode.INVALID_ASSET,
-        `Cannot redeem to BTC. Use EvmUnstake for LBTC → BTC.`,
-      );
-
-      expect(error.code).toBe(ValidationErrorCode.INVALID_ASSET);
-    });
-
-    it('should reject chains without BTC.b support', () => {
-      const error = new LombardError(
-        ValidationErrorCode.INVALID_CHAIN,
-        `BTC.b is not available on ethereum. Cannot redeem.`,
-      );
-
-      expect(error.code).toBe(ValidationErrorCode.INVALID_CHAIN);
-    });
-
-    it('should handle insufficient LBTC balance', () => {
-      const error = new LombardError(
-        ValidationErrorCode.INVALID_PARAMETER,
-        `Insufficient LBTC balance for redemption.`,
-      );
-
-      expect(error.message).toContain('Insufficient');
-    });
-  });
-
-  describe('Chain Support', () => {
-    it('should support Avalanche chains', () => {
-      const supportedChains = [Chain.AVALANCHE, Chain.AVALANCHE_FUJI];
-      
-      // Chains are CAIP-2 format (e.g., eip155:43114)
-      supportedChains.forEach(chain => {
-        expect(chain).toBeDefined();
-        expect(typeof chain).toBe('string');
-      });
-
-      // Verify they are the correct Avalanche chain IDs
-      expect(supportedChains).toContain(Chain.AVALANCHE);
-      expect(supportedChains).toContain(Chain.AVALANCHE_FUJI);
-    });
-  });
-
-  describe('Event Emissions', () => {
-    it('should emit progress events', () => {
-      const handler = vi.fn((progress: { status: string; txHash?: string }) => {
-        expect(progress.status).toBeDefined();
-      });
-
-      handler({ status: 'completed', txHash: '0x123' });
-      expect(handler).toHaveBeenCalledOnce();
-    });
-  });
-
-  describe('Public Properties', () => {
-    it('should expose status property', () => {
-      type HasStatus = { readonly status: string };
-      const obj: HasStatus = { status: 'idle' };
-      expect(obj.status).toBe('idle');
-    });
-
-    it('should expose amount property', () => {
-      type HasAmount = { readonly amount?: string };
-      const obj: HasAmount = { amount: '0.1' };
-      expect(obj.amount).toBe('0.1');
-    });
-
-    it('should expose txHash after execute', () => {
-      type HasTxHash = { readonly txHash?: string };
-      const obj: HasTxHash = { txHash: '0x123' };
-      expect(obj.txHash).toBeDefined();
-    });
-  });
-});
-

package/src/__tests__/unit/evm/EvmRedeemFeeAuth.test.ts

@@ -1,93 +0,0 @@
-/**
- * EVM Redeem Fee Authorization Tests
- *
- * Verifies that:
- * 1. EvmRedeem correctly checks for fee authorization on unsubsidized chains
- * 2. EvmRedeem skips fee auth on subsidized chains
- * 3. EvmRedeem correctly handles existing valid signatures
- */
-
-import { afterEach,beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { ChainId } from '../../../common/chains';
-import { requiresAutoMintFee } from '../../../common/fee-requirements';
-import { EvmOperationStatus } from '../../../shared/constants/statusConstants';
-
-// Mock the fee requirements module
-vi.mock('../../../common/fee-requirements', () => ({
-  requiresAutoMintFee: vi.fn(),
-}));
-
-describe('EVM Redeem Fee Authorization', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('requiresAutoMintFee', () => {
-    it('should return true for Ethereum mainnet', () => {
-      vi.mocked(requiresAutoMintFee).mockReturnValue(true);
-      expect(requiresAutoMintFee(ChainId.ethereum)).toBe(true);
-    });
-
-    it('should return true for Sepolia testnet', () => {
-      vi.mocked(requiresAutoMintFee).mockReturnValue(true);
-      expect(requiresAutoMintFee(ChainId.sepolia)).toBe(true);
-    });
-
-    it('should return false for Base (subsidized)', () => {
-      vi.mocked(requiresAutoMintFee).mockReturnValue(false);
-      expect(requiresAutoMintFee(ChainId.base)).toBe(false);
-    });
-
-    it('should return false for BSC (subsidized)', () => {
-      vi.mocked(requiresAutoMintFee).mockReturnValue(false);
-      expect(requiresAutoMintFee(ChainId.binanceSmartChain)).toBe(false);
-    });
-  });
-
-  describe('EvmOperationStatus', () => {
-    it('should have NEEDS_FEE_AUTHORIZATION status', () => {
-      expect(EvmOperationStatus.NEEDS_FEE_AUTHORIZATION).toBe('needs_fee_authorization');
-    });
-
-    it('should have all required statuses for EVM redeem flow', () => {
-      expect(EvmOperationStatus.IDLE).toBe('idle');
-      expect(EvmOperationStatus.NEEDS_FEE_AUTHORIZATION).toBe('needs_fee_authorization');
-      expect(EvmOperationStatus.READY).toBe('ready');
-      expect(EvmOperationStatus.COMPLETED).toBe('completed');
-    });
-  });
-
-  describe('Fee Authorization Flow', () => {
-    it('documents expected flow for Ethereum (unsubsidized)', () => {
-      // On Ethereum/Sepolia, the flow should be:
-      // IDLE → NEEDS_FEE_AUTHORIZATION → READY → COMPLETED
-      const expectedFlow = [
-        EvmOperationStatus.IDLE,
-        EvmOperationStatus.NEEDS_FEE_AUTHORIZATION,
-        EvmOperationStatus.READY,
-        EvmOperationStatus.COMPLETED,
-      ];
-
-      expect(expectedFlow).toHaveLength(4);
-      expect(expectedFlow[1]).toBe(EvmOperationStatus.NEEDS_FEE_AUTHORIZATION);
-    });
-
-    it('documents expected flow for Base (subsidized)', () => {
-      // On Base/BSC (subsidized), the flow should skip fee auth:
-      // IDLE → READY → COMPLETED
-      const expectedFlow = [
-        EvmOperationStatus.IDLE,
-        EvmOperationStatus.READY,
-        EvmOperationStatus.COMPLETED,
-      ];
-
-      expect(expectedFlow).toHaveLength(3);
-      expect(expectedFlow).not.toContain(EvmOperationStatus.NEEDS_FEE_AUTHORIZATION);
-    });
-  });
-});

package/src/__tests__/unit/evm/EvmStake.test.ts

@@ -1,207 +0,0 @@
-/**
- * EVM Stake Action Unit Tests
- *
- * Tests the BTC.b → LBTC staking flow on EVM chains.
- *
- * ## Fee Authorization
- *
- * Fee authorization is required on unsubsidized chains (Ethereum, Sepolia).
- * On subsidized chains (Avalanche, Base, BSC), no fee auth is required.
- *
- * @module __tests__/unit/evm/EvmStake.test.ts
- */
-
-import { describe, expect, it, vi } from 'vitest';
-
-import { AssetId, Chain } from '../../../core';
-import { LombardError, ValidationErrorCode } from '../../../shared/errors';
-
-describe('EvmStake Interface', () => {
-  describe('EvmStakeParams', () => {
-    it('should require BTCb as input asset', () => {
-      const params = {
-        assetIn: AssetId.BTCb,
-        assetOut: AssetId.LBTC,
-        sourceChain: Chain.AVALANCHE,
-      };
-
-      expect(params.assetIn).toBe(AssetId.BTCb);
-    });
-
-    it('should require LBTC as output asset', () => {
-      const params = {
-        assetIn: AssetId.BTCb,
-        assetOut: AssetId.LBTC,
-        sourceChain: Chain.AVALANCHE,
-      };
-
-      expect(params.assetOut).toBe(AssetId.LBTC);
-    });
-
-    it('should support Avalanche chains', () => {
-      const mainnetParams = {
-        assetIn: AssetId.BTCb,
-        assetOut: AssetId.LBTC,
-        sourceChain: Chain.AVALANCHE,
-      };
-
-      const testnetParams = {
-        assetIn: AssetId.BTCb,
-        assetOut: AssetId.LBTC,
-        sourceChain: Chain.AVALANCHE_FUJI,
-      };
-
-      expect(mainnetParams.sourceChain).toBe(Chain.AVALANCHE);
-      expect(testnetParams.sourceChain).toBe(Chain.AVALANCHE_FUJI);
-    });
-  });
-
-  describe('EvmStakePrepareParams', () => {
-    it('should accept valid prepare parameters', () => {
-      const params = {
-        amount: '0.1',
-      };
-
-      expect(params.amount).toBe('0.1');
-    });
-  });
-
-  describe('Status Transitions', () => {
-    it('should define all required status values for fee auth flow', () => {
-      const statuses = [
-        'idle',
-        'needs-fee-authorization',
-        'ready',
-        'completed',
-      ];
-
-      statuses.forEach(status => {
-        expect(typeof status).toBe('string');
-      });
-    });
-  });
-
-  describe('Method Signatures', () => {
-    it('should define prepare method', () => {
-      type PrepareMethod = (params: { amount: string }) => Promise<void>;
-      const testType: PrepareMethod = async () => {};
-      expect(testType).toBeDefined();
-    });
-
-    it('should define authorizeFee method for unsubsidized chains', () => {
-      type AuthorizeFeeMethod = () => Promise<void>;
-      const testType: AuthorizeFeeMethod = async () => {};
-      expect(testType).toBeDefined();
-    });
-
-    it('should define execute method', () => {
-      type ExecuteMethod = () => Promise<{ txHash: string }>;
-      const testType: ExecuteMethod = async () => ({ txHash: '0x123' });
-      expect(testType).toBeDefined();
-    });
-  });
-
-  describe('Fee Authorization', () => {
-    it('should require fee auth on unsubsidized chains (Ethereum, Sepolia)', () => {
-      const unsubsidizedChains = [Chain.ETHEREUM, Chain.SEPOLIA];
-      expect(unsubsidizedChains).toHaveLength(2);
-    });
-
-    it('should skip fee auth on subsidized chains (Avalanche, Base, BSC)', () => {
-      const subsidizedChains = [Chain.AVALANCHE, Chain.BASE, Chain.BSC];
-      expect(subsidizedChains).toHaveLength(3);
-    });
-
-    it('should expose feeAuth state for UI display', () => {
-      type FeeAuthState = {
-        requiresAuth: boolean;
-        isAuthorized: boolean;
-        feeInSatoshis: bigint | null;
-        feeFormatted: string | null;
-        expirationDate: string | null;
-      };
-      
-      const feeAuth: FeeAuthState = {
-        requiresAuth: true,
-        isAuthorized: false,
-        feeInSatoshis: BigInt(32),
-        feeFormatted: '0.00000032',
-        expirationDate: null,
-      };
-      
-      expect(feeAuth.requiresAuth).toBe(true);
-      expect(feeAuth.isAuthorized).toBe(false);
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should reject LBTC as input asset', () => {
-      const error = new LombardError(
-        ValidationErrorCode.INVALID_ASSET,
-        `Cannot stake LBTC. Stake is for BTC.b → LBTC conversion.`,
-      );
-
-      expect(error.code).toBe(ValidationErrorCode.INVALID_ASSET);
-    });
-
-    it('should reject chains without BTC.b', () => {
-      const error = new LombardError(
-        ValidationErrorCode.INVALID_CHAIN,
-        `BTC.b is not available on ethereum. Use Avalanche instead.`,
-      );
-
-      expect(error.code).toBe(ValidationErrorCode.INVALID_CHAIN);
-    });
-
-    it('should handle insufficient balance', () => {
-      const error = new LombardError(
-        ValidationErrorCode.INVALID_PARAMETER,
-        `Insufficient BTC.b balance. Have: 0, Need: 0.1`,
-      );
-
-      expect(error.message).toContain('Insufficient');
-    });
-  });
-
-  describe('Event Emissions', () => {
-    it('should emit progress events', () => {
-      const handler = vi.fn((progress: { status: string; txHash?: string }) => {
-        expect(progress.status).toBeDefined();
-      });
-
-      handler({ status: 'completed', txHash: '0x123' });
-      expect(handler).toHaveBeenCalledOnce();
-    });
-
-    it('should emit transaction hash on completion', () => {
-      const result = { txHash: '0x1234567890abcdef' };
-      expect(result.txHash).toMatch(/^0x/);
-    });
-  });
-
-  describe('Public Properties', () => {
-    it('should expose status property', () => {
-      type HasStatus = { readonly status: string };
-      const obj: HasStatus = { status: 'idle' };
-      expect(obj.status).toBe('idle');
-    });
-
-    it('should expose amount property', () => {
-      type HasAmount = { readonly amount?: string };
-      const obj: HasAmount = { amount: '0.1' };
-      expect(obj.amount).toBe('0.1');
-    });
-
-    it('should expose txHash after execute', () => {
-      type HasTxHash = { readonly txHash?: string };
-      const obj: HasTxHash = { txHash: '0x123' };
-      expect(obj.txHash).toBeDefined();
-    });
-
-    it('should expose feeAuth state', () => {
-      type HasFeeAuth = { readonly feeAuth: { requiresAuth: boolean; isAuthorized: boolean } };
-      const obj: HasFeeAuth = { feeAuth: { requiresAuth: true, isAuthorized: false } };
-      expect(obj.feeAuth.requiresAuth).toBe(true);
-    });
-  });
-});

package/src/__tests__/unit/evm/EvmStakeFeeAuth.test.ts

@@ -1,193 +0,0 @@
-/**
- * EVM Stake Fee Authorization Tests
- *
- * Tests the fee authorization flow for BTC.b → LBTC staking on EVM chains.
- *
- * Fee authorization is required on unsubsidized chains (Ethereum, Sepolia).
- * On subsidized chains (Avalanche, Base, BSC), no fee auth is required.
- *
- * @module __tests__/unit/evm/EvmStakeFeeAuth.test.ts
- */
-
-import { Env } from '@lombard.finance/sdk-common';
-import BigNumber from 'bignumber.js';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { EvmStake } from '../../../chains/evm/actions/stake/EvmStake';
-import * as feeAuthModule from '../../../chains/evm/shared/feeAuth';
-import { PartnerConfiguration } from '../../../client/PartnerConfiguration';
-import { AssetId, Chain } from '../../../core';
-import { EvmOperationStatus } from '../../../shared/constants/statusConstants';
-import type { EvmCoreContext } from '../../../shared/context/types';
-
-// Mock the token functions to avoid contract address lookups
-vi.mock('../../../tokens/tokens', () => ({
-  getTokenContractInfo: vi.fn().mockResolvedValue({
-    address: '0x1234567890123456789012345678901234567890' as `0x${string}`,
-    abi: [],
-  }),
-}));
-
-vi.mock('../../../contract-functions/approveToken', () => ({
-  getTokenAllowance: vi.fn().mockResolvedValue(new BigNumber('1000')), // Sufficient allowance
-  approveToken: vi.fn().mockResolvedValue('0xtxhash'),
-}));
-
-// Spy on the fee authorization functions
-vi.spyOn(feeAuthModule, 'checkFeeAuthorization');
-vi.spyOn(feeAuthModule, 'authorizeFee');
-
-const mockProvider = {
-  request: vi.fn(async ({ method }: { method: string }) => {
-    if (method === 'eth_accounts') {
-      return ['0x0000000000000000000000000000000000000002'];
-    }
-    return [];
-  }),
-};
-
-function createContext(): EvmCoreContext {
-  return {
-    env: Env.prod,
-    partner: new PartnerConfiguration(undefined),
-    getProvider: async () => mockProvider,
-    evm: {} as EvmCoreContext['evm'],
-  };
-}
-
-describe('EvmStake Fee Authorization', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('Subsidized Chains (no fee auth required)', () => {
-    it('should transition directly to READY on Base (no approval, no fee auth)', async () => {
-      // Base doesn't require approval, and is subsidized (no fee auth)
-      vi.mocked(feeAuthModule.checkFeeAuthorization).mockResolvedValueOnce({
-        requiresAuth: false,
-        hasValidSignature: false,
-        feeInSatoshis: null,
-        feeFormatted: null,
-        expirationDate: null,
-      });
-
-      const ctx = createContext();
-      const stake = new EvmStake(ctx, {
-        assetIn: AssetId.BTCb,
-        assetOut: AssetId.LBTC,
-        sourceChain: Chain.BASE,
-        destChain: Chain.BASE,
-      });
-
-      await stake.prepare({ amount: '0.5' });
-
-      expect(stake.status).toBe(EvmOperationStatus.READY);
-      expect(stake.feeAuth.requiresAuth).toBe(false);
-    });
-  });
-
-  describe('Unsubsidized Chains (fee auth required)', () => {
-    it('should transition to NEEDS_FEE_AUTHORIZATION on Ethereum when no signature exists', async () => {
-      vi.mocked(feeAuthModule.checkFeeAuthorization).mockResolvedValueOnce({
-        requiresAuth: true,
-        hasValidSignature: false,
-        feeInSatoshis: BigInt(32),
-        feeFormatted: '0.00000032',
-        expirationDate: null,
-      });
-
-      const ctx = createContext();
-      const stake = new EvmStake(ctx, {
-        assetIn: AssetId.BTCb,
-        assetOut: AssetId.LBTC,
-        sourceChain: Chain.ETHEREUM,
-        destChain: Chain.ETHEREUM,
-      });
-
-      await stake.prepare({ amount: '0.5' });
-
-      expect(stake.status).toBe(EvmOperationStatus.NEEDS_FEE_AUTHORIZATION);
-      expect(stake.feeAuth.requiresAuth).toBe(true);
-      expect(stake.feeAuth.isAuthorized).toBe(false);
-      expect(stake.feeAuth.feeFormatted).toBe('0.00000032');
-    });
-
-    it('should skip fee auth when valid signature exists on Ethereum', async () => {
-      vi.mocked(feeAuthModule.checkFeeAuthorization).mockResolvedValueOnce({
-        requiresAuth: true,
-        hasValidSignature: true,
-        feeInSatoshis: null,
-        feeFormatted: null,
-        expirationDate: '1737331200', // Some future timestamp
-      });
-
-      const ctx = createContext();
-      const stake = new EvmStake(ctx, {
-        assetIn: AssetId.BTCb,
-        assetOut: AssetId.LBTC,
-        sourceChain: Chain.ETHEREUM,
-        destChain: Chain.ETHEREUM,
-      });
-
-      await stake.prepare({ amount: '0.5' });
-
-      expect(stake.status).toBe(EvmOperationStatus.READY);
-      expect(stake.feeAuth.requiresAuth).toBe(true);
-      expect(stake.feeAuth.isAuthorized).toBe(true);
-    });
-
-    it('should transition to READY after authorizeFee', async () => {
-      vi.mocked(feeAuthModule.checkFeeAuthorization).mockResolvedValueOnce({
-        requiresAuth: true,
-        hasValidSignature: false,
-        feeInSatoshis: BigInt(32),
-        feeFormatted: '0.00000032',
-        expirationDate: null,
-      });
-      vi.mocked(feeAuthModule.authorizeFee).mockResolvedValueOnce({
-        signature: '0xabc123' as `0x${string}`,
-        typedData: '{}',
-      });
-
-      const ctx = createContext();
-      const stake = new EvmStake(ctx, {
-        assetIn: AssetId.BTCb,
-        assetOut: AssetId.LBTC,
-        sourceChain: Chain.ETHEREUM,
-        destChain: Chain.ETHEREUM,
-      });
-
-      await stake.prepare({ amount: '0.5' });
-      expect(stake.status).toBe(EvmOperationStatus.NEEDS_FEE_AUTHORIZATION);
-
-      await stake.authorizeFee();
-      expect(stake.status).toBe(EvmOperationStatus.READY);
-      expect(stake.feeAuth.isAuthorized).toBe(true);
-    });
-  });
-
-  describe('FeeAuth State', () => {
-    it('should expose fee information for UI display', async () => {
-      vi.mocked(feeAuthModule.checkFeeAuthorization).mockResolvedValueOnce({
-        requiresAuth: true,
-        hasValidSignature: false,
-        feeInSatoshis: BigInt(32),
-        feeFormatted: '0.00000032',
-        expirationDate: null,
-      });
-
-      const ctx = createContext();
-      const stake = new EvmStake(ctx, {
-        assetIn: AssetId.BTCb,
-        assetOut: AssetId.LBTC,
-        sourceChain: Chain.ETHEREUM,
-        destChain: Chain.ETHEREUM,
-      });
-
-      await stake.prepare({ amount: '0.5' });
-
-      expect(stake.feeAuth.feeInSatoshis).toBe(BigInt(32));
-      expect(stake.feeAuth.feeFormatted).toBe('0.00000032');
-    });
-  });
-});