@lombard.finance/sdk 3.7.4 → 4.0.0

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

@@ -0,0 +1,207 @@
+/**
+ * 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

@@ -0,0 +1,93 @@
+/**
+ * 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

@@ -0,0 +1,207 @@
+/**
+ * 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

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