feat: add bitcoin package unit tests (#1848)

* feat: add bitcoin package unit tests

* fixup! feat: add bitcoin package unit tests

* fixup! feat: add bitcoin package unit tests

Author: AngelCastilloB

packages/bitcoin/src/wallet/lib/common/transaction.ts

@@ -1,5 +1,5 @@
 import { Psbt } from 'bitcoinjs-lib';
-import { DerivedAddress } from '@wallet';
+import { DerivedAddress } from './address';
 
 export type UnsignedTransaction = {
   context: Psbt;

packages/bitcoin/src/wallet/lib/providers/BlockchainInputResolver.ts

@@ -1,5 +1,5 @@
 import { BlockchainDataProvider, UTxO } from './BitcoinDataProvider';
-import { InputResolver } from '@src/wallet';
+import { InputResolver } from './InputResolver';
 
 /**
  * Represents an implementation of the `InputResolver` interface that fetches detailed information

packages/bitcoin/test/BlockchainInputResolver.test.ts

@@ -0,0 +1,51 @@
+/* eslint-disable unicorn/no-useless-undefined, no-magic-numbers, no-loop-func, @typescript-eslint/no-non-null-assertion, unicorn/consistent-function-scoping, @typescript-eslint/no-explicit-any, @typescript-eslint/no-var-requires, camelcase */
+import { BlockchainInputResolver } from '../src/wallet/lib/providers/BlockchainInputResolver';
+import { BlockchainDataProvider } from '../src/wallet/lib/providers/BitcoinDataProvider';
+
+describe('BlockchainInputResolver', () => {
+  const mockTransaction = {
+    outputs: [
+      { address: 'addr1', satoshis: BigInt(1000) },
+      { address: 'addr2', satoshis: BigInt(2000) }
+    ]
+  };
+
+  let mockProvider: BlockchainDataProvider;
+
+  beforeEach(() => {
+    mockProvider = {
+      getTransaction: jest.fn()
+    } as unknown as BlockchainDataProvider;
+  });
+
+  it('resolves a valid input correctly', async () => {
+    (mockProvider.getTransaction as jest.Mock).mockResolvedValue(mockTransaction);
+
+    const resolver = new BlockchainInputResolver(mockProvider);
+    const result = await resolver.resolve('tx123', 1);
+
+    expect(result).toEqual({
+      txId: 'tx123',
+      index: 1,
+      address: 'addr2',
+      satoshis: BigInt(2000)
+    });
+    expect(mockProvider.getTransaction).toHaveBeenCalledWith('tx123');
+  });
+
+  it('throws error if transaction is not found', async () => {
+    (mockProvider.getTransaction as jest.Mock).mockResolvedValue(undefined);
+
+    const resolver = new BlockchainInputResolver(mockProvider);
+
+    await expect(resolver.resolve('missingTx', 0)).rejects.toThrow('Transaction or output index not found');
+  });
+
+  it('throws error if output index is out of range', async () => {
+    (mockProvider.getTransaction as jest.Mock).mockResolvedValue(mockTransaction);
+
+    const resolver = new BlockchainInputResolver(mockProvider);
+
+    await expect(resolver.resolve('tx123', 5)).rejects.toThrow('Transaction or output index not found');
+  });
+});

packages/bitcoin/test/GreedyInputSelector.test.ts

@@ -0,0 +1,61 @@
+/* eslint-disable no-magic-numbers, no-loop-func, @typescript-eslint/no-non-null-assertion, unicorn/consistent-function-scoping, @typescript-eslint/no-explicit-any, @typescript-eslint/no-var-requires, camelcase */
+import { GreedyInputSelector } from '../src/wallet/lib/input-selection/GreedyInputSelector';
+
+describe('GreedyInputSelector', () => {
+  const selector = new GreedyInputSelector();
+  const feeRate = 1; // sat/byte
+  const changeAddress = 'change-address';
+
+  const createUTXO = (satoshis: bigint, id = Math.random().toString()) => ({
+    txId: id,
+    index: 0,
+    address: 'address1',
+    vout: 0,
+    satoshis
+  });
+
+  it('selects sufficient UTXOs and returns change', () => {
+    const utxos = [createUTXO(BigInt(5000)), createUTXO(BigInt(8000))];
+    const outputs = [{ address: 'address1', value: BigInt(4000) }];
+    const result = selector.selectInputs(changeAddress, utxos, outputs, feeRate);
+
+    expect(result).toBeDefined();
+    expect(result!.selectedUTxOs.length).toBeGreaterThan(0);
+    expect(result!.outputs.some((o) => o.address === changeAddress)).toBe(true);
+    expect(result!.fee).toBeGreaterThan(0);
+  });
+
+  it('returns undefined if inputs are insufficient', () => {
+    const utxos = [createUTXO(BigInt(1000))];
+    const outputs = [{ address: 'address1', value: BigInt(2000) }];
+    const result = selector.selectInputs(changeAddress, utxos, outputs, feeRate);
+
+    expect(result).toBeUndefined();
+  });
+
+  it('includes all outputs and correct change when no dust', () => {
+    const utxos = [createUTXO(BigInt(10_000))];
+    const outputs = [
+      { address: 'address1', value: BigInt(3000) },
+      { address: 'address2', value: BigInt(2000) }
+    ];
+    const result = selector.selectInputs(changeAddress, utxos, outputs, feeRate);
+
+    expect(result).toBeDefined();
+    const sumOutputs = result!.outputs.reduce((acc, o) => acc + o.value, 0);
+    const sumInputs = result!.selectedUTxOs.reduce((acc, u) => acc + Number(u.satoshis), 0);
+    expect(sumInputs - sumOutputs - result!.fee).toBe(0);
+  });
+
+  it('adds dust change to fee instead of outputting it', () => {
+    const utxos = [createUTXO(BigInt(6000))];
+    const outputs = [{ address: 'address1', value: BigInt(5500) }];
+    const result = selector.selectInputs(changeAddress, utxos, outputs, feeRate);
+
+    expect(result).toBeDefined();
+    expect(result!.outputs.some((o) => o.address === changeAddress)).toBe(false);
+    const sumOutputs = result!.outputs.reduce((acc, o) => acc + o.value, 0);
+    const sumInputs = result!.selectedUTxOs.reduce((acc, u) => acc + Number(u.satoshis), 0);
+    expect(sumInputs - sumOutputs - result!.fee).toBe(0);
+  });
+});

packages/bitcoin/test/MaestroBitcoinDataProvider.test.ts

@@ -0,0 +1,135 @@
+/* eslint-disable no-magic-numbers, no-loop-func, @typescript-eslint/no-non-null-assertion, unicorn/consistent-function-scoping, @typescript-eslint/no-explicit-any, @typescript-eslint/no-var-requires, camelcase */
+import { MaestroBitcoinDataProvider } from '../src/wallet/lib/providers/MaestroBitcoinDataProvider';
+import { TransactionStatus, FeeEstimationMode } from '../src/wallet/lib/providers/BitcoinDataProvider';
+import { Network } from '../src/wallet/lib/common';
+
+describe('MaestroBitcoinDataProvider', () => {
+  let provider: MaestroBitcoinDataProvider;
+  let mockAxios: any;
+  let mockCache: any;
+  let mockLogger: any;
+
+  const mockTxDetails = {
+    vin: [{ txid: 'abc', vout: 0, address: 'addr1', value: '0.0001' }],
+    vout: [{ address: 'addr2', value: '0.00009' }],
+    confirmations: 5,
+    blockheight: 100_000,
+    blocktime: 1_696_969_696
+  };
+
+  beforeEach(() => {
+    mockAxios = {
+      get: jest.fn(),
+      post: jest.fn()
+    };
+
+    mockCache = {
+      get: jest.fn(),
+      set: jest.fn()
+    };
+
+    mockLogger = {
+      debug: jest.fn()
+    };
+
+    jest.spyOn(require('axios'), 'create').mockReturnValue(mockAxios);
+
+    provider = new MaestroBitcoinDataProvider('dummy-token', mockCache, mockLogger, Network.Mainnet);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('fetches last known block', async () => {
+    mockAxios.get.mockResolvedValue({ data: { last_updated: { block_height: 100, block_hash: 'abc123' } } });
+
+    const result = await provider.getLastKnownBlock();
+    expect(result).toEqual({ height: 100, hash: 'abc123' });
+  });
+
+  it('fetches transaction details', async () => {
+    const txHash = 'tx123';
+    const txDetails = {
+      vin: [{ txid: 'prevTx', vout: 0, address: 'addr1', value: '0.0001' }],
+      vout: [{ address: 'addr2', value: '0.00009' }],
+      confirmations: 10,
+      blockheight: 500,
+      blocktime: 1_234_567
+    };
+
+    mockCache.get.mockResolvedValue();
+    mockAxios.get.mockResolvedValue({ data: { data: txDetails } });
+
+    const result = await provider.getTransaction(txHash);
+    expect(result.transactionHash).toBe(txHash);
+    expect(result.status).toBe(TransactionStatus.Confirmed);
+    expect(result.inputs[0].address).toBe('addr1');
+    expect(result.outputs[0].address).toBe('addr2');
+  });
+
+  it('fetches transaction history with pagination', async () => {
+    mockAxios.get
+      .mockResolvedValueOnce({ data: { data: [{ tx_hash: 'tx1' }], next_cursor: 'next-cursor' } })
+      .mockResolvedValueOnce({ data: { data: mockTxDetails } });
+
+    mockCache.get.mockResolvedValue();
+
+    const result = await provider.getTransactions('addr1');
+    expect(result.transactions.length).toBe(1);
+    expect(result.transactions[0].transactionHash).toBe('tx1');
+    expect(result.nextCursor).toBe('next-cursor');
+  });
+
+  it('fetches mempool transactions', async () => {
+    mockAxios.get
+      .mockResolvedValueOnce({ data: { data: [{ txid: 'tx-mempool', mempool: true }] } })
+      .mockResolvedValueOnce({ data: { data: mockTxDetails } });
+
+    mockCache.get.mockResolvedValue();
+
+    const result = await provider.getTransactionsInMempool('addr1');
+    expect(result.length).toBe(1);
+    expect(result[0].transactionHash).toBe('tx-mempool');
+    expect(result[0].status).toBe(TransactionStatus.Pending);
+  });
+
+  it('fetches UTXOs', async () => {
+    const utxoData = [{ txid: 'abc', vout: 0, satoshis: '10000', address: 'addr1' }];
+    mockAxios.get.mockResolvedValue({ data: { data: utxoData } });
+
+    const result = await provider.getUTxOs('addr1');
+    expect(result[0].txId).toBe('abc');
+    expect(result[0].address).toBe('addr1');
+    expect(typeof result[0].satoshis).toBe('bigint');
+  });
+
+  it('submits transaction and returns hash', async () => {
+    mockAxios.post.mockResolvedValue({ status: 201, data: 'txhash123' });
+
+    const result = await provider.submitTransaction('rawtx');
+    expect(result).toBe('txhash123');
+  });
+
+  it('returns status as Confirmed', async () => {
+    mockAxios.get.mockResolvedValue({ data: { confirmations: 3 } });
+
+    const result = await provider.getTransactionStatus('tx1');
+    expect(result).toBe(TransactionStatus.Confirmed);
+  });
+
+  it('returns status as Dropped for 404', async () => {
+    mockAxios.get.mockRejectedValue({ response: { status: 404 } });
+
+    const result = await provider.getTransactionStatus('tx404');
+    expect(result).toBe(TransactionStatus.Dropped);
+  });
+
+  it('estimates fees', async () => {
+    mockAxios.get.mockResolvedValue({ status: 200, data: { data: { feerate: 22, blocks: 3 } } });
+
+    const result = await provider.estimateFee(3, FeeEstimationMode.Conservative);
+    expect(result.feeRate).toBe(22);
+    expect(result.blocks).toBe(3);
+  });
+});