@originals/sdk 1.4.2 → 1.4.3

package/tests/unit/bitcoin/transactions/commit.test.ts

@@ -1,649 +0,0 @@
-/**
- * Tests for commit transaction creation
- */
-import { describe, test, expect, beforeEach } from 'bun:test';
-import {
-  createCommitTransaction,
-  type CommitTransactionParams,
-  type CommitTransactionResult
-} from '../../../../src/bitcoin/transactions/commit.js';
-import type { Utxo } from '../../../../src/types/bitcoin.js';
-
-// Helper to create test UTXOs
-const createUtxo = (value: number, index: number = 0, network: 'mainnet' | 'testnet' | 'signet' | 'regtest' = 'mainnet'): Utxo => {
-  const addressMap = {
-    mainnet: 'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4',
-    testnet: 'tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx',
-    signet: 'tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx',
-    regtest: 'tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx' // Use testnet format for regtest compatibility with @scure/btc-signer
-  };
-
-  return {
-    txid: `${'a'.repeat(62)}${index.toString().padStart(2, '0')}`,
-    vout: index,
-    value,
-    scriptPubKey: '0014' + 'b'.repeat(40), // Mock P2WPKH scriptPubKey
-    address: addressMap[network]
-  };
-};
-
-// Helper to create basic commit params
-const createCommitParams = (overrides: Partial<CommitTransactionParams> = {}): CommitTransactionParams => {
-  const network = overrides.network || 'mainnet';
-  const addressMap = {
-    mainnet: 'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4',
-    testnet: 'tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx',
-    signet: 'tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx',
-    regtest: 'tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx' // Use testnet format for regtest compatibility with @scure/btc-signer
-  };
-
-  return {
-    content: Buffer.from('Hello Ordinals'),
-    contentType: 'text/plain',
-    utxos: overrides.utxos || [createUtxo(10000, 0, network)],
-    changeAddress: addressMap[network],
-    feeRate: 10,
-    network,
-    ...overrides
-  };
-};
-
-describe('createCommitTransaction', () => {
-  describe('Basic Functionality', () => {
-    test('creates commit transaction with valid inputs', async () => {
-      const params = createCommitParams();
-      const result = await createCommitTransaction(params);
-
-      expect(result).toBeDefined();
-      expect(result.commitAddress).toBeDefined();
-      expect(result.commitPsbtBase64).toBeDefined();
-      expect(result.commitPsbt).toBeDefined();
-      expect(result.selectedUtxos).toHaveLength(1);
-      expect(result.fees.commit).toBeGreaterThan(0);
-    });
-
-    test('generates valid P2TR commit address', async () => {
-      const params = createCommitParams();
-      const result = await createCommitTransaction(params);
-
-      // P2TR addresses start with bc1p for mainnet
-      expect(result.commitAddress).toMatch(/^bc1p[a-z0-9]{58}$/);
-    });
-
-    test('generates reveal keypair', async () => {
-      const params = createCommitParams();
-      const result = await createCommitTransaction(params);
-
-      expect(result.revealPrivateKey).toBeDefined();
-      expect(result.revealPublicKey).toBeDefined();
-      expect(result.revealPrivateKey).toHaveLength(64); // 32 bytes in hex
-      expect(result.revealPublicKey).toHaveLength(64); // 32 bytes x-only pubkey in hex
-    });
-
-    test('includes inscription script data', async () => {
-      const params = createCommitParams();
-      const result = await createCommitTransaction(params);
-
-      expect(result.inscriptionScript).toBeDefined();
-      expect(result.inscriptionScript.script).toBeInstanceOf(Uint8Array);
-      expect(result.inscriptionScript.controlBlock).toBeInstanceOf(Uint8Array);
-      expect(result.inscriptionScript.leafVersion).toBe(0xc0);
-    });
-
-    test('returns correct commit amount', async () => {
-      const params = createCommitParams({ minimumCommitAmount: 1000 });
-      const result = await createCommitTransaction(params);
-
-      expect(result.commitAmount).toBeGreaterThanOrEqual(1000);
-      expect(result.commitAmount).toBeGreaterThanOrEqual(546); // Dust limit
-    });
-  });
-
-  describe('UTXO Selection', () => {
-    test('selects single UTXO when sufficient', async () => {
-      const params = createCommitParams({
-        utxos: [createUtxo(10000, 0)]
-      });
-      const result = await createCommitTransaction(params);
-
-      expect(result.selectedUtxos).toHaveLength(1);
-      expect(result.selectedUtxos[0].value).toBe(10000);
-    });
-
-    test('selects multiple UTXOs when needed', async () => {
-      const params = createCommitParams({
-        utxos: [
-          createUtxo(2000, 0),
-          createUtxo(2000, 1),
-          createUtxo(2000, 2)
-        ],
-        minimumCommitAmount: 2000
-      });
-      const result = await createCommitTransaction(params);
-
-      expect(result.selectedUtxos.length).toBeGreaterThan(1);
-      const totalValue = result.selectedUtxos.reduce((sum, utxo) => sum + utxo.value, 0);
-      expect(totalValue).toBeGreaterThanOrEqual(2000 + result.fees.commit);
-    });
-
-    test('throws when insufficient funds', async () => {
-      const params = createCommitParams({
-        utxos: [createUtxo(100, 0)], // Not enough for commit + fees
-        minimumCommitAmount: 546
-      });
-
-      await expect(createCommitTransaction(params)).rejects.toThrow(/Insufficient funds/);
-    });
-  });
-
-  describe('Fee Calculation', () => {
-    test('calculates correct fee for 1 input', async () => {
-      const feeRate = 10; // 10 sats/vB
-      const params = createCommitParams({
-        feeRate,
-        utxos: [createUtxo(10000, 0)]
-      });
-      const result = await createCommitTransaction(params);
-
-      // Fee should be reasonable for 1 input, 2 outputs (commit + change)
-      // Estimate: ~10.5 overhead + 68 input + 43 P2TR + 31 change = ~152 vB
-      // At 10 sats/vB = ~1520 sats
-      expect(result.fees.commit).toBeGreaterThan(1000);
-      expect(result.fees.commit).toBeLessThan(3000);
-    });
-
-    test('fee scales with fee rate', async () => {
-      const params1 = createCommitParams({ feeRate: 5 });
-      const params2 = createCommitParams({ feeRate: 50 });
-
-      const result1 = await createCommitTransaction(params1);
-      const result2 = await createCommitTransaction(params2);
-
-      // Fee should be ~10x higher for 10x fee rate
-      expect(result2.fees.commit).toBeGreaterThan(result1.fees.commit * 8);
-      expect(result2.fees.commit).toBeLessThan(result1.fees.commit * 12);
-    });
-
-    test('fee increases with multiple inputs', async () => {
-      const params1 = createCommitParams({
-        utxos: [createUtxo(10000, 0)]
-      });
-      const params2 = createCommitParams({
-        utxos: [
-          createUtxo(1500, 0),
-          createUtxo(1500, 1),
-          createUtxo(1500, 2),
-          createUtxo(1500, 3)
-        ],
-        minimumCommitAmount: 2000 // Force use of multiple UTXOs
-      });
-
-      const result1 = await createCommitTransaction(params1);
-      const result2 = await createCommitTransaction(params2);
-
-      // More inputs = higher fee
-      expect(result2.fees.commit).toBeGreaterThan(result1.fees.commit);
-    });
-  });
-
-  describe('PSBT Construction', () => {
-    test('PSBT has correct number of inputs', async () => {
-      const params = createCommitParams({
-        utxos: [createUtxo(10000, 0)]
-      });
-      const result = await createCommitTransaction(params);
-
-      expect(result.commitPsbt.inputsLength).toBe(1);
-    });
-
-    test('PSBT includes commit output', async () => {
-      const params = createCommitParams();
-      const result = await createCommitTransaction(params);
-
-      expect(result.commitPsbt.outputsLength).toBeGreaterThanOrEqual(1);
-    });
-
-    test('PSBT creates change output when needed', async () => {
-      const params = createCommitParams({
-        utxos: [createUtxo(100000, 0)], // Large UTXO
-        minimumCommitAmount: 546
-      });
-      const result = await createCommitTransaction(params);
-
-      // Should have commit output + change output
-      expect(result.commitPsbt.outputsLength).toBe(2);
-    });
-
-    test('PSBT omits change when below dust limit', async () => {
-      const params = createCommitParams({
-        utxos: [createUtxo(2500, 0)], // Enough for commit + fees with minimal change below dust
-        minimumCommitAmount: 546,
-        feeRate: 10
-      });
-      const result = await createCommitTransaction(params);
-
-      // Should have only commit output (change below dust limit)
-      expect(result.commitPsbt.outputsLength).toBe(1);
-    });
-
-    test('PSBT is valid base64', async () => {
-      const params = createCommitParams();
-      const result = await createCommitTransaction(params);
-
-      expect(result.commitPsbtBase64).toBeDefined();
-      expect(typeof result.commitPsbtBase64).toBe('string');
-
-      // Should be valid base64
-      const decoded = Buffer.from(result.commitPsbtBase64, 'base64');
-      expect(decoded.length).toBeGreaterThan(0);
-    });
-  });
-
-  describe('Inscription Content', () => {
-    test('handles text content', async () => {
-      const params = createCommitParams({
-        content: Buffer.from('Hello World'),
-        contentType: 'text/plain'
-      });
-      const result = await createCommitTransaction(params);
-
-      expect(result).toBeDefined();
-      expect(result.commitAddress).toBeDefined();
-    });
-
-    test('handles JSON content', async () => {
-      const params = createCommitParams({
-        content: Buffer.from(JSON.stringify({ test: 'data' })),
-        contentType: 'application/json'
-      });
-      const result = await createCommitTransaction(params);
-
-      expect(result).toBeDefined();
-      expect(result.commitAddress).toBeDefined();
-    });
-
-    test('handles binary content', async () => {
-      const params = createCommitParams({
-        content: Buffer.from([0x89, 0x50, 0x4E, 0x47]), // PNG header
-        contentType: 'image/png'
-      });
-      const result = await createCommitTransaction(params);
-
-      expect(result).toBeDefined();
-      expect(result.commitAddress).toBeDefined();
-    });
-
-    test('handles large content (1KB)', async () => {
-      const largeContent = Buffer.alloc(1024, 'a');
-      const params = createCommitParams({
-        content: largeContent,
-        contentType: 'text/plain',
-        utxos: [createUtxo(100000, 0)]
-      });
-      const result = await createCommitTransaction(params);
-
-      expect(result).toBeDefined();
-      expect(result.commitAddress).toBeDefined();
-    });
-
-    test('includes metadata when provided', async () => {
-      const params = createCommitParams({
-        metadata: { title: 'Test Inscription', author: 'Tester' }
-      });
-      const result = await createCommitTransaction(params);
-
-      expect(result).toBeDefined();
-      expect(result.commitAddress).toBeDefined();
-    });
-
-    test('handles missing pointer gracefully', async () => {
-      // Pointer is optional, test that it works without it
-      const params = createCommitParams();
-      const result = await createCommitTransaction(params);
-
-      expect(result).toBeDefined();
-      expect(result.commitAddress).toBeDefined();
-    });
-  });
-
-  describe('Network Support', () => {
-    test('creates mainnet commit address', async () => {
-      const params = createCommitParams({ network: 'mainnet' });
-      const result = await createCommitTransaction(params);
-
-      expect(result.commitAddress).toMatch(/^bc1p/);
-    });
-
-    test('creates testnet commit address', async () => {
-      const params = createCommitParams({ network: 'testnet' });
-      const result = await createCommitTransaction(params);
-
-      expect(result.commitAddress).toMatch(/^tb1p/);
-    });
-
-    test('creates signet commit address', async () => {
-      const params = createCommitParams({ network: 'signet' });
-      const result = await createCommitTransaction(params);
-
-      expect(result.commitAddress).toMatch(/^tb1p/);
-    });
-
-    test('creates regtest commit address', async () => {
-      const params = createCommitParams({ network: 'regtest' });
-      const result = await createCommitTransaction(params);
-
-      // Regtest uses TEST_NETWORK which generates tb1p addresses
-      expect(result.commitAddress).toMatch(/^tb1p/);
-    });
-  });
-
-  describe('Error Handling', () => {
-    test('throws when no UTXOs provided', async () => {
-      const params = createCommitParams({ utxos: [] });
-      await expect(createCommitTransaction(params)).rejects.toThrow(/No UTXOs provided/);
-    });
-
-    test('throws when content is empty', async () => {
-      const params = createCommitParams({ content: Buffer.from([]) });
-      await expect(createCommitTransaction(params)).rejects.toThrow(/missing content/);
-    });
-
-    test('throws when contentType is missing', async () => {
-      const params = createCommitParams({ contentType: '' });
-      await expect(createCommitTransaction(params)).rejects.toThrow(/missing content type/);
-    });
-
-    test('throws when changeAddress is missing', async () => {
-      const params = createCommitParams({ changeAddress: '' });
-      await expect(createCommitTransaction(params)).rejects.toThrow(/Change address is required/);
-    });
-
-    test('throws when feeRate is invalid', async () => {
-      const params = createCommitParams({ feeRate: 0 });
-      await expect(createCommitTransaction(params)).rejects.toThrow(/Invalid fee rate/);
-    });
-
-    test('throws when all UTXOs are missing scriptPubKey', async () => {
-      const invalidUtxo1: Utxo = {
-        txid: 'a'.repeat(64),
-        vout: 0,
-        value: 10000
-        // Missing scriptPubKey
-      };
-
-      const invalidUtxo2: Utxo = {
-        txid: 'b'.repeat(64),
-        vout: 1,
-        value: 10000
-        // Missing scriptPubKey
-      };
-
-      const params = createCommitParams({
-        utxos: [invalidUtxo1, invalidUtxo2]
-      });
-
-      // Should throw error because no valid UTXOs remain after filtering
-      await expect(createCommitTransaction(params)).rejects.toThrow(/No valid spendable UTXOs available/);
-      await expect(createCommitTransaction(params)).rejects.toThrow(/missing scriptPubKey/);
-    });
-
-    test('filters out invalid UTXOs and uses only valid ones', async () => {
-      const invalidUtxo: Utxo = {
-        txid: 'a'.repeat(64),
-        vout: 0,
-        value: 10000
-        // Missing scriptPubKey
-      };
-
-      const params = createCommitParams({
-        utxos: [invalidUtxo, createUtxo(50000, 1), createUtxo(50000, 2)]
-      });
-
-      // Should filter out the invalid UTXO and use only the valid ones
-      const result = await createCommitTransaction(params);
-      expect(result).toBeDefined();
-      // Should only use valid UTXOs
-      expect(result.selectedUtxos.every(u => u.scriptPubKey)).toBe(true);
-    });
-  });
-
-  describe('Dust Handling', () => {
-    test('respects minimum dust limit (546 sats)', async () => {
-      const params = createCommitParams({ minimumCommitAmount: 100 });
-      const result = await createCommitTransaction(params);
-
-      // Should use dust limit instead of 100
-      expect(result.commitAmount).toBeGreaterThanOrEqual(546);
-    });
-
-    test('uses custom minimum when above dust limit', async () => {
-      const params = createCommitParams({
-        minimumCommitAmount: 10000,
-        utxos: [createUtxo(15000, 0)] // Enough to cover 10000 + fees
-      });
-      const result = await createCommitTransaction(params);
-
-      expect(result.commitAmount).toBe(10000);
-    });
-
-    test('adds dust change to fee', async () => {
-      // Create scenario where change would be < 546 sats
-      const params = createCommitParams({
-        utxos: [createUtxo(1500, 0)],
-        minimumCommitAmount: 546,
-        feeRate: 5
-      });
-      const result = await createCommitTransaction(params);
-
-      // Should have only commit output (no change)
-      expect(result.commitPsbt.outputsLength).toBe(1);
-    });
-  });
-
-  describe('Consistency', () => {
-    test('generates different addresses for different content', async () => {
-      const params1 = createCommitParams({ content: Buffer.from('Content 1') });
-      const params2 = createCommitParams({ content: Buffer.from('Content 2') });
-
-      const result1 = await createCommitTransaction(params1);
-      const result2 = await createCommitTransaction(params2);
-
-      // Different content should generate different addresses
-      expect(result1.commitAddress).not.toBe(result2.commitAddress);
-    });
-
-    test('generates different addresses on each call (random keypair)', async () => {
-      const params = createCommitParams();
-
-      const result1 = await createCommitTransaction(params);
-      const result2 = await createCommitTransaction(params);
-
-      // Different reveal keypairs should generate different addresses
-      expect(result1.commitAddress).not.toBe(result2.commitAddress);
-      expect(result1.revealPrivateKey).not.toBe(result2.revealPrivateKey);
-    });
-
-    test('total value equals commit + change + fees', async () => {
-      const params = createCommitParams({
-        utxos: [createUtxo(100000, 0)]
-      });
-      const result = await createCommitTransaction(params);
-
-      const totalInput = result.selectedUtxos.reduce((sum, utxo) => sum + utxo.value, 0);
-      const totalOutput = result.commitAmount;
-      const fee = result.fees.commit;
-
-      // Get change amount from PSBT if it exists
-      let changeAmount = 0;
-      if (result.commitPsbt.outputsLength === 2) {
-        changeAmount = totalInput - totalOutput - fee;
-      }
-
-      expect(totalInput).toBe(totalOutput + changeAmount + fee);
-    });
-
-    test('inputs always cover outputs (no negative change)', async () => {
-      // Test with various fee rates to ensure iterative selection works
-      const feeRates = [1, 5, 10, 20, 50];
-
-      for (const feeRate of feeRates) {
-        const params = createCommitParams({
-          utxos: [createUtxo(10000, 0), createUtxo(20000, 1), createUtxo(30000, 2)],
-          feeRate
-        });
-
-        const result = await createCommitTransaction(params);
-
-        const totalInput = result.selectedUtxos.reduce((sum, utxo) => sum + utxo.value, 0);
-        const totalOutput = result.commitAmount + result.fees.commit;
-
-        // Critical check: inputs must always be >= outputs
-        expect(totalInput).toBeGreaterThanOrEqual(totalOutput);
-
-        // Calculate actual change
-        const actualChange = totalInput - totalOutput;
-        expect(actualChange).toBeGreaterThanOrEqual(0);
-      }
-    });
-  });
-
-  describe('Iterative UTXO Selection', () => {
-    test('reselects UTXOs when fee increases after accurate calculation', async () => {
-      // Create scenario where 1 UTXO isn't enough after fee recalculation
-      const params = createCommitParams({
-        utxos: [
-          createUtxo(1500, 0),  // Not enough alone
-          createUtxo(2000, 1),  // Will need this one too
-          createUtxo(5000, 2)   // May need this as well
-        ],
-        minimumCommitAmount: 546,
-        feeRate: 10
-      });
-
-      const result = await createCommitTransaction(params);
-
-      // Should have selected enough UTXOs to cover commit + fees
-      const totalInput = result.selectedUtxos.reduce((sum, utxo) => sum + utxo.value, 0);
-      expect(totalInput).toBeGreaterThanOrEqual(result.commitAmount + result.fees.commit);
-    });
-
-    test('stops iteration when sufficient funds are found', async () => {
-      // Create scenario with plenty of UTXOs
-      const params = createCommitParams({
-        utxos: [
-          createUtxo(100000, 0), // This should be enough
-          createUtxo(100000, 1),
-          createUtxo(100000, 2)
-        ],
-        feeRate: 10
-      });
-
-      const result = await createCommitTransaction(params);
-
-      // Should not need all UTXOs since first one is sufficient
-      expect(result.selectedUtxos.length).toBeLessThan(3);
-    });
-
-    test('throws error if max iterations reached without sufficient funds', async () => {
-      // Create scenario where UTXOs are just barely insufficient
-      // This would require many iterations if the algorithm isn't working
-      const params = createCommitParams({
-        utxos: [
-          createUtxo(500, 0),
-          createUtxo(500, 1)
-        ],
-        minimumCommitAmount: 546,
-        feeRate: 50 // High fee rate makes it impossible
-      });
-
-      // Should throw after max iterations
-      await expect(createCommitTransaction(params)).rejects.toThrow(/Insufficient funds/);
-    });
-  });
-
-  describe('UTXO Validation', () => {
-    test('validates UTXO has txid', async () => {
-      const invalidUtxo: Utxo = {
-        txid: '', // Empty txid
-        vout: 0,
-        value: 10000,
-        scriptPubKey: '0014' + 'a'.repeat(40)
-      };
-
-      const params = createCommitParams({
-        utxos: [invalidUtxo]
-      });
-
-      await expect(createCommitTransaction(params)).rejects.toThrow(/No valid spendable UTXOs/);
-    });
-
-    test('validates UTXO has valid vout', async () => {
-      const invalidUtxo: any = {
-        txid: 'a'.repeat(64),
-        vout: 'invalid', // Invalid vout type
-        value: 10000,
-        scriptPubKey: '0014' + 'a'.repeat(40)
-      };
-
-      const params = createCommitParams({
-        utxos: [invalidUtxo]
-      });
-
-      await expect(createCommitTransaction(params)).rejects.toThrow(/No valid spendable UTXOs/);
-    });
-
-    test('validates UTXO has positive value', async () => {
-      const invalidUtxo: Utxo = {
-        txid: 'a'.repeat(64),
-        vout: 0,
-        value: 0, // Zero value
-        scriptPubKey: '0014' + 'a'.repeat(40)
-      };
-
-      const params = createCommitParams({
-        utxos: [invalidUtxo]
-      });
-
-      await expect(createCommitTransaction(params)).rejects.toThrow(/No valid spendable UTXOs/);
-    });
-
-    test('provides detailed error message for invalid UTXOs', async () => {
-      const invalidUtxos: Utxo[] = [
-        {
-          txid: 'a'.repeat(64),
-          vout: 0,
-          value: 10000
-          // Missing scriptPubKey
-        },
-        {
-          txid: '', // Missing txid
-          vout: 1,
-          value: 10000,
-          scriptPubKey: '0014' + 'a'.repeat(40)
-        },
-        {
-          txid: 'c'.repeat(64),
-          vout: 2,
-          value: 0, // Invalid value
-          scriptPubKey: '0014' + 'a'.repeat(40)
-        }
-      ];
-
-      const params = createCommitParams({
-        utxos: invalidUtxos
-      });
-
-      try {
-        await createCommitTransaction(params);
-        throw new Error('Should have thrown');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        if (error instanceof Error) {
-          // Should contain detailed information about what's wrong
-          expect(error.message).toMatch(/No valid spendable UTXOs available/);
-          expect(error.message).toMatch(/3 UTXO.*provided but all are invalid/);
-        }
-      }
-    });
-  });
-});

package/tests/unit/bitcoin/transfer.test.ts

@@ -1,31 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { buildTransferTransaction } from '../../../src/bitcoin/transfer';
-import { DUST_LIMIT_SATS, Utxo } from '../../../src/types';
-
-describe('buildTransferTransaction', () => {
-  const utxo = (value: number, i: number = 0): Utxo => ({ txid: 't', vout: i, value });
-
-  test('creates tx with recipient output and change when above dust', () => {
-    const { tx, selection } = buildTransferTransaction([utxo(100_000)], 'bc1qto', 50_000, 1);
-    expect(tx.vout[0].address).toBe('bc1qto');
-    expect(tx.vout[0].value).toBe(50_000);
-    expect(selection.changeSats).toBeGreaterThanOrEqual(DUST_LIMIT_SATS);
-    // change output present when change >= dust
-    expect(tx.vout.length).toBe(2);
-  });
-
-  test('suppresses change output when below dust threshold', () => {
-    const { tx, selection } = buildTransferTransaction([utxo(800)], 'addr', DUST_LIMIT_SATS, 1);
-    expect(selection.changeSats).toBe(0);
-    // only recipient output
-    expect(tx.vout.length).toBe(1);
-  });
-
-  test('uses input address as default change address when provided', () => {
-    const inputWithAddr: Utxo = { txid: 't', vout: 0, value: 100000, address: 'bc1qchange' };
-    const { tx, selection } = buildTransferTransaction([inputWithAddr], 'bc1qto', 50000, 1);
-    expect(selection.changeSats).toBeGreaterThanOrEqual(DUST_LIMIT_SATS);
-    // change output address should be input address when not passed explicitly
-    expect(tx.vout[1].address).toBe('bc1qchange');
-  });
-});