@leather.io/bitcoin 0.19.29 → 0.19.30

package/src/validation/address-validation.spec.ts

@@ -0,0 +1,396 @@
+import { Network } from 'bitcoin-address-validation';
+
+import {
+  TEST_ACCOUNT_1_NATIVE_SEGWIT_ADDRESS,
+  TEST_ACCOUNT_1_TAPROOT_ADDRESS,
+  TEST_TESNET_ACCOUNT_1_NATIVE_SEGWIT_ADDRESS,
+  TEST_TESTNET_ACCOUNT_2_BTC_ADDRESS,
+  inValidCharactersAddress,
+  inValidLengthAddress,
+} from '../mocks/mocks';
+import {
+  getBitcoinAddressNetworkType,
+  isValidBitcoinAddress,
+  isValidBitcoinNetworkAddress,
+} from './address-validation';
+
+describe('getBitcoinAddressNetworkType', () => {
+  it('returns the correct network type', () => {
+    expect(getBitcoinAddressNetworkType('mainnet')).toEqual(Network.mainnet);
+    expect(getBitcoinAddressNetworkType('testnet')).toEqual(Network.testnet);
+    expect(getBitcoinAddressNetworkType('regtest')).toEqual(Network.regtest);
+  });
+
+  it('returns Network.testnet type for signet', () => {
+    expect(getBitcoinAddressNetworkType('signet')).toEqual(Network.testnet);
+  });
+
+  it('returns false for invalid bitcoin addresses', () => {
+    // expect(() => isValidBitcoinAddress(inValidLengthAddress)).toThrow(BitcoinError);
+    expect(isValidBitcoinAddress('')).toBe(false);
+
+    // @ts-expect-error arg type is invalid
+    expect(isValidBitcoinAddress(null)).toBe(false);
+    // @ts-expect-error arg type is invalid
+    expect(isValidBitcoinAddress(undefined)).toBe(false);
+  });
+
+  it('returns false for addresses with invalid characters', () => {
+    expect(isValidBitcoinAddress(inValidCharactersAddress)).toBe(false);
+  });
+
+  it('returns false for addresses with invalid length', () => {
+    expect(isValidBitcoinAddress(inValidLengthAddress)).toBe(false);
+  });
+});
+
+describe('isValidBitcoinAddress', () => {
+  it('returns true for valid bitcoin addresses', () => {
+    expect(isValidBitcoinAddress(TEST_ACCOUNT_1_NATIVE_SEGWIT_ADDRESS)).toBe(true);
+    expect(isValidBitcoinAddress(TEST_ACCOUNT_1_TAPROOT_ADDRESS)).toBe(true);
+  });
+
+  it('returns false for invalid bitcoin addresses', () => {
+    // expect(() => isValidBitcoinAddress(inValidLengthAddress)).toThrow(BitcoinError);
+    expect(isValidBitcoinAddress('')).toBe(false);
+
+    // @ts-expect-error arg type is invalid
+    expect(isValidBitcoinAddress(null)).toBe(false);
+    // @ts-expect-error arg type is invalid
+    expect(isValidBitcoinAddress(undefined)).toBe(false);
+  });
+
+  it('returns false for addresses with invalid characters', () => {
+    expect(isValidBitcoinAddress(inValidCharactersAddress)).toBe(false);
+  });
+
+  it('returns false for addresses with invalid length', () => {
+    expect(isValidBitcoinAddress(inValidLengthAddress)).toBe(false);
+  });
+});
+
+describe('isValidBitcoinNetworkAddress', () => {
+  it('returns true for valid bitcoin network addresses', () => {
+    expect(isValidBitcoinNetworkAddress(TEST_ACCOUNT_1_NATIVE_SEGWIT_ADDRESS, 'mainnet')).toBe(
+      true
+    );
+    expect(isValidBitcoinNetworkAddress(TEST_ACCOUNT_1_NATIVE_SEGWIT_ADDRESS, 'mainnet')).toBe(
+      true
+    );
+    expect(isValidBitcoinNetworkAddress(TEST_TESTNET_ACCOUNT_2_BTC_ADDRESS, 'testnet')).toBe(true);
+    expect(
+      isValidBitcoinNetworkAddress(TEST_TESNET_ACCOUNT_1_NATIVE_SEGWIT_ADDRESS, 'testnet')
+    ).toBe(true);
+  });
+
+  it('returns false for invalid bitcoin network addresses', () => {
+    expect(isValidBitcoinNetworkAddress(TEST_ACCOUNT_1_NATIVE_SEGWIT_ADDRESS, 'testnet')).toBe(
+      false
+    );
+    expect(isValidBitcoinNetworkAddress(TEST_ACCOUNT_1_TAPROOT_ADDRESS, 'testnet')).toBe(false);
+    expect(
+      isValidBitcoinNetworkAddress(TEST_TESNET_ACCOUNT_1_NATIVE_SEGWIT_ADDRESS, 'mainnet')
+    ).toBe(false);
+    expect(isValidBitcoinNetworkAddress(TEST_TESTNET_ACCOUNT_2_BTC_ADDRESS, 'mainnet')).toBe(false);
+  });
+
+  it('returns false for addresses with invalid characters', () => {
+    expect(isValidBitcoinNetworkAddress(inValidCharactersAddress, 'mainnet')).toBe(false);
+  });
+
+  it('returns false for addresses with invalid length', () => {
+    expect(isValidBitcoinNetworkAddress(inValidLengthAddress, 'mainnet')).toBe(false);
+  });
+
+  it('returns false for invalid network types', () => {
+    expect(
+      // @ts-expect-error arg type is invalid
+      isValidBitcoinNetworkAddress(TEST_ACCOUNT_1_NATIVE_SEGWIT_ADDRESS, 'invalid-network')
+    ).toBe(false);
+  });
+});
+
+// taken from bitcoin-address-validation/blob/master/tests/index.spec.ts
+// adapted to our code to ensure completeness
+
+describe('bitcoin-address-validation address tests', () => {
+  describe('Validation and parsing', () => {
+    it('validates Mainnet P2PKH', () => {
+      const address = '17VZNX1SN5NtKa8UQFxwQbFeFc3iqRYhem';
+
+      expect(isValidBitcoinAddress(address)).not.toBe(false);
+    });
+    it('validates Testnet P2PKH', () => {
+      const address = 'mipcBbFg9gMiCh81Kj8tqqdgoZub1ZJRfn';
+
+      expect(isValidBitcoinAddress(address)).not.toBe(false);
+    });
+
+    it('validates Mainnet P2SH', () => {
+      const address = '3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy';
+
+      expect(isValidBitcoinAddress(address)).not.toBe(false);
+    });
+
+    it('validates Testnet P2SH', () => {
+      const address = '2MzQwSSnBHWHqSAqtTVQ6v47XtaisrJa1Vc';
+
+      expect(isValidBitcoinAddress(address)).not.toBe(false);
+    });
+
+    it('validates Mainnet Bech32 P2WPKH', () => {
+      const addresses = [
+        'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4',
+        'bc1q973xrrgje6etkkn9q9azzsgpxeddats8ckvp5s',
+      ];
+
+      expect(isValidBitcoinAddress(addresses[0])).not.toBe(false);
+      expect(isValidBitcoinAddress(addresses[1])).not.toBe(false);
+    });
+
+    it('validates Testnet Bech32 P2WPKH', () => {
+      const address = 'tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx';
+
+      expect(isValidBitcoinAddress(address)).not.toBe(false);
+    });
+
+    it('validates Regtest Bech32 P2WPKH', () => {
+      const address = 'bcrt1q6z64a43mjgkcq0ul2znwneq3spghrlau9slefp';
+
+      expect(isValidBitcoinAddress(address)).not.toBe(false);
+    });
+
+    it('validates Mainnet Bech32 P2WSH', () => {
+      const address = 'bc1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3qccfmv3';
+
+      expect(isValidBitcoinAddress(address)).not.toBe(false);
+    });
+
+    it('validates Testnet Bech32 P2WSH', () => {
+      const address = 'tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7';
+
+      expect(isValidBitcoinAddress(address)).not.toBe(false);
+    });
+
+    it('validates Regtest Bech32 P2WSH', () => {
+      const address = 'bcrt1q5n2k3frgpxces3dsw4qfpqk4kksv0cz96pldxdwxrrw0d5ud5hcqzzx7zt';
+
+      expect(isValidBitcoinAddress(address)).not.toBe(false);
+    });
+
+    it('validates Signet Bech32 P2WKH', () => {
+      const address = 'bcrt1qc7evl8kdgp69h7qmm8cndaq07xkhj6ulyck0x5';
+
+      expect(isValidBitcoinAddress(address)).not.toBe(false);
+    });
+
+    it('validates Testnet P2PKH', () => {
+      const address = 'mipcBbFg9gMiCh81Kj8tqqdgoZub1ZJRfn';
+
+      expect(isValidBitcoinAddress(address)).not.toBe(false);
+    });
+
+    it('fails on invalid P2PKH', () => {
+      const address = '17VZNX1SN5NtKa8UFFxwQbFeFc3iqRYhem';
+
+      expect(isValidBitcoinAddress(address)).toBe(false);
+    });
+
+    it('validates Mainnet P2SH', () => {
+      const address = '3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy';
+
+      expect(isValidBitcoinAddress(address)).not.toBe(false);
+    });
+
+    it('validates Testnet P2SH', () => {
+      const address = '2MzQwSSnBHWHqSAqtTVQ6v47XtaisrJa1Vc';
+
+      expect(isValidBitcoinAddress(address)).not.toBe(false);
+    });
+
+    it('fails on invalid P2SH', () => {
+      const address = '17VZNX1SN5NtKa8UFFxwQbFFFc3iqRYhem';
+
+      expect(isValidBitcoinAddress(address)).toBe(false);
+    });
+
+    it('handles bogus address', () => {
+      const address = 'x';
+
+      expect(isValidBitcoinAddress(address)).toBe(false);
+    });
+
+    it('validates Mainnet Bech32 P2WPKH', () => {
+      const addresses = [
+        'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4',
+        'bc1q973xrrgje6etkkn9q9azzsgpxeddats8ckvp5s',
+      ];
+
+      expect(isValidBitcoinAddress(addresses[0])).not.toBe(false);
+
+      expect(isValidBitcoinAddress(addresses[1])).not.toBe(false);
+    });
+
+    it('validates uppercase Bech32 P2WPKH', () => {
+      const addresses = [
+        'BC1Q973XRRGJE6ETKKN9Q9AZZSGPXEDDATS8CKVP5S',
+        'BC1QW508D6QEJXTDG4Y5R3ZARVARY0C5XW7KV8F3T4',
+      ];
+
+      expect(isValidBitcoinAddress(addresses[0])).not.toBe(false);
+
+      expect(isValidBitcoinAddress(addresses[1])).not.toBe(false);
+    });
+
+    it('validates Testnet Bech32 P2WPKH', () => {
+      const address = 'tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx';
+
+      expect(isValidBitcoinAddress(address)).not.toBe(false);
+    });
+
+    it('validates Regtest Bech32 P2WPKH', () => {
+      const address = 'bcrt1q6z64a43mjgkcq0ul2znwneq3spghrlau9slefp';
+
+      expect(isValidBitcoinAddress(address)).not.toBe(false);
+    });
+
+    it('validates Mainnet Bech32 P2TR', () => {
+      const address = 'bc1ptxs597p3fnpd8gwut5p467ulsydae3rp9z75hd99w8k3ljr9g9rqx6ynaw';
+
+      expect(isValidBitcoinAddress(address)).not.toBe(false);
+    });
+
+    it('validates Testnet Bech32 P2TR', () => {
+      const address = 'tb1p84x2ryuyfevgnlpnxt9f39gm7r68gwtvllxqe5w2n5ru00s9aquslzggwq';
+
+      expect(isValidBitcoinAddress(address)).not.toBe(false);
+    });
+
+    it('validates Regtest Bech32 P2TR', () => {
+      const address = 'bcrt1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqc8gma6';
+
+      expect(isValidBitcoinAddress(address)).not.toBe(false);
+    });
+
+    it('validates Mainnet Bech32 P2WSH', () => {
+      const address = 'bc1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3qccfmv3';
+
+      expect(isValidBitcoinAddress(address)).not.toBe(false);
+    });
+
+    it('validates Testnet Bech32 P2WSH', () => {
+      const address = 'tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7';
+
+      expect(isValidBitcoinAddress(address)).not.toBe(false);
+    });
+
+    it('validates Regtest Bech32 P2WSH', () => {
+      const address = 'bcrt1q5n2k3frgpxces3dsw4qfpqk4kksv0cz96pldxdwxrrw0d5ud5hcqzzx7zt';
+
+      expect(isValidBitcoinAddress(address)).not.toBe(false);
+    });
+
+    it('validates Signet Bech32 P2WKH', () => {
+      const address = 'bcrt1qc7evl8kdgp69h7qmm8cndaq07xkhj6ulyck0x5';
+
+      expect(isValidBitcoinAddress(address)).not.toBe(false);
+    });
+
+    it('fails on invalid Bech32', () => {
+      const address = 'bc1qw508d6qejxtdg4y5r3zrrvary0c5xw7kv8f3t4';
+
+      expect(isValidBitcoinAddress(address)).toBe(false);
+    });
+  });
+
+  describe('Validation & network', () => {
+    it('validates Mainnet P2PKH', () => {
+      const address = '17VZNX1SN5NtKa8UQFxwQbFeFc3iqRYhem';
+
+      expect(isValidBitcoinNetworkAddress(address, Network.mainnet)).toBe(true);
+    });
+
+    it('validates Testnet P2PKH', () => {
+      const address = 'mipcBbFg9gMiCh81Kj8tqqdgoZub1ZJRfn';
+
+      expect(isValidBitcoinNetworkAddress(address, Network.testnet)).toBe(true);
+    });
+
+    it('fails on invalid P2PKH', () => {
+      const address = '17VZNX1SN5NtKa8UFFxwQbFeFc3iqRYhem';
+
+      expect(isValidBitcoinNetworkAddress(address, Network.mainnet)).toBe(false);
+    });
+
+    it('validates Mainnet P2SH', () => {
+      const address = '3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy';
+
+      expect(isValidBitcoinNetworkAddress(address, Network.mainnet)).toBe(true);
+    });
+
+    it('validates Testnet P2SH', () => {
+      const address = '2MzQwSSnBHWHqSAqtTVQ6v47XtaisrJa1Vc';
+
+      expect(isValidBitcoinNetworkAddress(address, Network.testnet)).toBe(true);
+    });
+
+    it('fails on invalid P2SH', () => {
+      const address = '17VZNX1SN5NtKa8UFFxwQbFFFc3iqRYhem';
+
+      expect(isValidBitcoinNetworkAddress(address, Network.mainnet)).toBe(false);
+    });
+
+    it('handles bogus address', () => {
+      const address = 'x';
+
+      expect(isValidBitcoinNetworkAddress(address, Network.mainnet)).toBe(false);
+    });
+
+    it('validates Mainnet Bech32 P2WPKH', () => {
+      const addresses = [
+        'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4',
+        'bc1q973xrrgje6etkkn9q9azzsgpxeddats8ckvp5s',
+      ];
+
+      expect(isValidBitcoinNetworkAddress(addresses[0], Network.mainnet)).toBe(true);
+
+      expect(isValidBitcoinNetworkAddress(addresses[1], Network.mainnet)).toBe(true);
+    });
+
+    it('validates Testnet Bech32 P2WPKH', () => {
+      const address = 'tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx';
+
+      expect(isValidBitcoinNetworkAddress(address, Network.testnet)).toBe(true);
+    });
+
+    it('validates Regtest Bech32 P2WPKH', () => {
+      const address = 'bcrt1q6z64a43mjgkcq0ul2znwneq3spghrlau9slefp';
+
+      expect(isValidBitcoinNetworkAddress(address, Network.regtest)).toBe(true);
+    });
+
+    it('validates Mainnet Bech32 P2WSH', () => {
+      const address = 'bc1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3qccfmv3';
+
+      expect(isValidBitcoinNetworkAddress(address, Network.mainnet)).toBe(true);
+    });
+
+    it('validates Testnet Bech32 P2WSH', () => {
+      const address = 'tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7';
+
+      expect(isValidBitcoinNetworkAddress(address, Network.testnet)).toBe(true);
+    });
+
+    it('validates Regtest Bech32 P2WSH', () => {
+      const address = 'bcrt1q5n2k3frgpxces3dsw4qfpqk4kksv0cz96pldxdwxrrw0d5ud5hcqzzx7zt';
+
+      expect(isValidBitcoinNetworkAddress(address, Network.regtest)).toBe(true);
+    });
+
+    it('fails on invalid Bech32', () => {
+      const address = 'bc1qw508d6qejxtdg4y5r3zrrvary0c5xw7kv8f3t4';
+
+      expect(isValidBitcoinNetworkAddress(address, Network.mainnet)).toBe(false);
+    });
+  });
+});

package/src/validation/address-validation.ts

@@ -0,0 +1,28 @@
+import { Network, validate } from 'bitcoin-address-validation';
+
+import { BitcoinNetworkModes } from '@leather.io/models';
+import { isEmptyString, isUndefined } from '@leather.io/utils';
+
+// todo investigate handling this in bitcoinNetworkToNetworkMode
+export function getBitcoinAddressNetworkType(network: BitcoinNetworkModes): Network {
+  // Signet uses testnet address format, this parsing is to please the
+  // validation library - 'bitcoin-address-validation'
+  if (network === 'signet') return Network.testnet;
+  return network as Network;
+}
+
+export function isValidBitcoinAddress(address: string) {
+  if (isUndefined(address) || isEmptyString(address)) {
+    return false;
+  }
+
+  return validate(address);
+}
+
+export function isValidBitcoinNetworkAddress(address: string, network: BitcoinNetworkModes) {
+  if (!isValidBitcoinAddress(address) || !network) {
+    return false;
+  }
+
+  return validate(address, getBitcoinAddressNetworkType(network));
+}

package/src/validation/amount-validation.spec.ts

@@ -0,0 +1,39 @@
+import BigNumber from 'bignumber.js';
+
+import { createMoney } from '@leather.io/utils';
+
+import { isBtcBalanceSufficient, isBtcMinimumSpend } from './amount-validation';
+
+describe('isBtcBalanceSufficient', () => {
+  it('returns true if the balance is sufficient', () => {
+    const args = {
+      amount: createMoney(1, 'BTC'),
+      spendableBtc: new BigNumber(2),
+    };
+    expect(isBtcBalanceSufficient(args)).toBe(true);
+  });
+
+  it('returns false if the balance is not sufficient', () => {
+    const args = {
+      amount: createMoney(2, 'BTC'),
+      spendableBtc: new BigNumber(1),
+    };
+    expect(isBtcBalanceSufficient(args)).toBe(false);
+  });
+});
+
+describe('isBtcMinimumSpend', () => {
+  it('returns true if the amount is greater than or equal to the minimum spend', () => {
+    const args = {
+      amount: createMoney(1, 'BTC'),
+    };
+    expect(isBtcMinimumSpend(args)).toBe(true);
+  });
+
+  it('returns false if the amount is less than the minimum spend', () => {
+    const args = {
+      amount: createMoney(0.000005, 'BTC'),
+    };
+    expect(isBtcMinimumSpend(args)).toBe(false);
+  });
+});

package/src/validation/amount-validation.ts

@@ -0,0 +1,31 @@
+import BigNumber from 'bignumber.js';
+
+import { Money } from '@leather.io/models';
+import { btcToSat } from '@leather.io/utils';
+
+export const minSpendAmountInSats = 546;
+
+interface isBtcBalanceSufficientArgs {
+  amount: Money;
+  spendableBtc: BigNumber;
+}
+export function isBtcBalanceSufficient({
+  amount: { amount },
+  spendableBtc,
+}: isBtcBalanceSufficientArgs) {
+  if (!spendableBtc) return false;
+  const desiredSpend = new BigNumber(amount);
+  if (desiredSpend.isGreaterThan(spendableBtc)) return false;
+  return true;
+}
+
+interface IsBtcMinimumSpendArgs {
+  amount: Money;
+}
+export function isBtcMinimumSpend({ amount: { amount } }: IsBtcMinimumSpendArgs) {
+  if (!amount) return false;
+
+  const desiredSpend = btcToSat(amount);
+  if (desiredSpend.isLessThan(minSpendAmountInSats)) return false;
+  return true;
+}

package/src/validation/bitcoin-address.ts

@@ -0,0 +1,23 @@
+import { isValidBitcoinAddress } from './address-validation';
+import { BitcoinError } from './bitcoin-error';
+
+// Branded type for Bitcoin addresses
+export type BitcoinAddress = string & { readonly __brand: unique symbol };
+
+export function isBitcoinAddress(value: string): value is BitcoinAddress {
+  try {
+    isValidBitcoinAddress(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Function to create a BitcoinAddress
+export function createBitcoinAddress(value: string): BitcoinAddress {
+  if (!isBitcoinAddress(value)) {
+    throw new BitcoinError('InvalidAddress');
+  }
+
+  return value;
+}

package/src/{bitcoin-error.ts → validation/bitcoin-error.ts}

@@ -1,3 +1,5 @@
+type TransactionErrorKey = 'InvalidAddress' | 'InsufficientFunds' | 'InvalidNetworkAddress';
+
 export class BitcoinError extends Error {
   public message: BitcoinErrorKey;
   constructor(message: BitcoinErrorKey) {
@@ -11,7 +13,7 @@ export class BitcoinError extends Error {
 }
 
 export type BitcoinErrorKey =
-  | 'InvalidAddress'
-  | 'InsufficientFunds'
+  | TransactionErrorKey
+  | 'InsufficientAmount'
   | 'NoInputsToSign'
   | 'NoOutputsToSign';

package/src/validation/transaction-validation.spec.ts

@@ -0,0 +1,60 @@
+import BigNumber from 'bignumber.js';
+
+import { BitcoinNetworkModes } from '@leather.io/models';
+import { createMoney } from '@leather.io/utils';
+
+import {
+  TEST_ACCOUNT_1_NATIVE_SEGWIT_ADDRESS,
+  TEST_ACCOUNT_1_TAPROOT_ADDRESS,
+  inValidCharactersAddress,
+} from '../mocks/mocks';
+import { BitcoinError } from '../validation/bitcoin-error';
+import { isValidBitcoinTransaction } from './transaction-validation';
+
+const mockTransaction = {
+  amount: createMoney(1, 'USD'),
+  payer: TEST_ACCOUNT_1_TAPROOT_ADDRESS,
+  recipient: TEST_ACCOUNT_1_NATIVE_SEGWIT_ADDRESS,
+  network: 'testnet' as BitcoinNetworkModes,
+  utxos: [],
+  feeRate: 1,
+  feeRates: {
+    fastestFee: new BigNumber(3),
+    halfHourFee: new BigNumber(2),
+    hourFee: new BigNumber(1),
+  },
+};
+
+describe('isValidBitcoinTransaction', () => {
+  it('should throw an error if the payer address is invalid', () => {
+    const transaction = {
+      ...mockTransaction,
+      payer: inValidCharactersAddress,
+    };
+    expect(() => isValidBitcoinTransaction(transaction)).toThrow(BitcoinError);
+  });
+
+  it('should throw an error if the recipient address is invalid', () => {
+    const transaction = {
+      ...mockTransaction,
+      recipient: inValidCharactersAddress,
+    };
+    expect(() => isValidBitcoinTransaction(transaction)).toThrow(BitcoinError);
+  });
+
+  it('should throw an error if the amount is insufficient', () => {
+    const transaction = {
+      ...mockTransaction,
+      amount: createMoney(0, 'USD'),
+    };
+    expect(() => isValidBitcoinTransaction(transaction)).toThrow(BitcoinError);
+  });
+
+  it('should throw an error if the balance is insufficient', () => {
+    const transaction = {
+      ...mockTransaction,
+      amount: createMoney(200, 'USD'),
+    };
+    expect(() => isValidBitcoinTransaction(transaction)).toThrow(BitcoinError);
+  });
+});

package/src/validation/transaction-validation.ts

@@ -0,0 +1,46 @@
+import { type BitcoinNetworkModes, Money } from '@leather.io/models';
+
+import { calculateMaxSpend } from '../coin-selection/calculate-max-spend';
+import { GetBitcoinFeesArgs } from '../fees/bitcoin-fees';
+import { BitcoinError } from '../validation/bitcoin-error';
+import { isValidBitcoinAddress, isValidBitcoinNetworkAddress } from './address-validation';
+import { isBtcBalanceSufficient, isBtcMinimumSpend } from './amount-validation';
+import { BitcoinAddress } from './bitcoin-address';
+
+interface BitcoinTransaction extends Omit<GetBitcoinFeesArgs, 'recipients'> {
+  amount: Money;
+  payer: BitcoinAddress;
+  recipient: BitcoinAddress;
+  network: BitcoinNetworkModes;
+  feeRate: number;
+}
+
+export function isValidBitcoinTransaction({
+  amount,
+  payer,
+  recipient,
+  network,
+  utxos,
+  feeRate,
+  feeRates,
+}: BitcoinTransaction) {
+  if (!isValidBitcoinAddress(payer) || !isValidBitcoinAddress(recipient)) {
+    throw new BitcoinError('InvalidAddress');
+  }
+  if (
+    !isValidBitcoinNetworkAddress(payer, network) ||
+    !isValidBitcoinNetworkAddress(recipient, network)
+  ) {
+    throw new BitcoinError('InvalidNetworkAddress');
+  }
+
+  if (!isBtcMinimumSpend({ amount })) {
+    throw new BitcoinError('InsufficientAmount');
+  }
+
+  const { spendableBtc } = calculateMaxSpend({ recipient, utxos, feeRate, feeRates });
+
+  if (!isBtcBalanceSufficient({ amount, spendableBtc })) {
+    throw new BitcoinError('InsufficientFunds');
+  }
+}