@originals/sdk 1.1.0

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

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

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