@leather.io/bitcoin 0.19.29 → 0.19.31

package/src/psbt/psbt-outputs.ts

@@ -1,12 +1,14 @@
 import type { TransactionOutput } from '@scure/btc-signer/psbt';
-import { getBtcSignerLibNetworkConfigByMode } from 'bitcoin.network';
-import { getAddressFromOutScript } from 'bitcoin.utils';
 
-import type { BitcoinNetworkModes } from '@leather.io/models';
+import { BitcoinNetworkModes } from '@leather.io/models';
 import { isDefined, isUndefined } from '@leather.io/utils';
 
+import { getBtcSignerLibNetworkConfigByMode } from '../utils/bitcoin.network';
+import { getAddressFromOutScript } from '../utils/bitcoin.utils';
+import { BitcoinAddress, createBitcoinAddress } from '../validation/bitcoin-address';
+
 export interface PsbtOutput {
-  address: string;
+  address: BitcoinAddress;
   isMutable: boolean;
   toSign: boolean;
   value: number;
@@ -16,7 +18,7 @@ interface GetParsedOutputsArgs {
   isPsbtMutable: boolean;
   outputs: TransactionOutput[];
   networkMode: BitcoinNetworkModes;
-  psbtAddresses: string[];
+  psbtAddresses: BitcoinAddress[];
 }
 
 export function getParsedOutputs({
@@ -34,8 +36,9 @@ export function getParsedOutputs({
         // logger.error('Output has no script');
         return;
       }
-      const outputAddress = getAddressFromOutScript(output.script, bitcoinNetwork);
-
+      const outputAddress = createBitcoinAddress(
+        getAddressFromOutScript(output.script, bitcoinNetwork)
+      );
       const isCurrentAddress = psbtAddresses.includes(outputAddress);
 
       return {

package/src/psbt/psbt-totals.ts

@@ -1,7 +1,7 @@
-import { inferPaymentTypeFromAddress } from 'bitcoin.utils';
-
 import { createMoney, sumNumbers } from '@leather.io/utils';
 
+import { inferPaymentTypeFromAddress } from '../utils/bitcoin.utils';
+import { BitcoinAddress } from '../validation/bitcoin-address';
 import { PsbtInput } from './psbt-inputs';
 import { PsbtOutput } from './psbt-outputs';
 
@@ -35,7 +35,7 @@ function calculatePsbtOutputsTotal(outputs: PsbtOutput[]) {
 }
 
 interface GetPsbtTotalsProps {
-  psbtAddresses: string[];
+  psbtAddresses: BitcoinAddress[];
   parsedInputs: PsbtInput[];
   parsedOutputs: PsbtOutput[];
 }

package/src/{bitcoin-signer.ts → signer/bitcoin-signer.ts}

@@ -14,15 +14,16 @@ import type { BitcoinNetworkModes, ValueOf } from '@leather.io/models';
 import { PaymentTypes, signatureHash } from '@leather.io/rpc';
 import { hexToNumber, toHexString } from '@leather.io/utils';
 
+import { getTaprootPaymentFromAddressIndex } from '../payments/p2tr-address-gen';
+import { getNativeSegwitPaymentFromAddressIndex } from '../payments/p2wpkh-address-gen';
 import {
   SupportedPaymentType,
   ecdsaPublicKeyToSchnorr,
   extractExtendedPublicKeyFromPolicy,
   inferPaymentTypeFromPath,
   whenSupportedPaymentType,
-} from './bitcoin.utils';
-import { getTaprootPaymentFromAddressIndex } from './p2tr-address-gen';
-import { getNativeSegwitPaymentFromAddressIndex } from './p2wpkh-address-gen';
+} from '../utils/bitcoin.utils';
+import { BitcoinAddress } from '../validation/bitcoin-address';
 
 export type AllowedSighashTypes = ValueOf<typeof signatureHash> | SigHash;
 
@@ -41,7 +42,7 @@ export interface BitcoinSigner<Payment> {
   payment: Payment;
   keychain: HDKey;
   derivationPath: string;
-  address: string;
+  address: BitcoinAddress;
   publicKey: Uint8Array;
   sign(tx: btc.Transaction): void;
   signIndex(tx: btc.Transaction, index: number, allowedSighash?: AllowedSighashTypes[]): void;
@@ -50,7 +51,7 @@ export interface BitcoinSigner<Payment> {
 export interface BitcoinPayerBase {
   paymentType: PaymentTypes;
   network: BitcoinNetworkModes;
-  address: string;
+  address: BitcoinAddress;
   keyOrigin: string;
   masterKeyFingerprint: string;
   publicKey: Uint8Array;

package/src/transactions/generate-unsigned-transaction.spec.ts

@@ -3,7 +3,7 @@ import { describe, expect, it } from 'vitest';
 
 import { createMoney } from '@leather.io/utils';
 
-import { getBtcSignerLibNetworkConfigByMode } from '../bitcoin.network';
+import { getBtcSignerLibNetworkConfigByMode } from '../utils/bitcoin.network';
 import {
   GenerateBitcoinUnsignedTransactionArgs,
   generateBitcoinUnsignedTransactionNativeSegwit,

package/src/transactions/generate-unsigned-transaction.ts

@@ -1,15 +1,15 @@
 import { hexToBytes } from '@noble/hashes/utils';
 import * as btc from '@scure/btc-signer';
-import { BtcSignerDefaultBip32Derivation } from 'bitcoin-signer';
 
-import { BitcoinError } from '../bitcoin-error';
-import { BtcSignerNetwork } from '../bitcoin.network';
 import {
   CoinSelectionRecipient,
   CoinSelectionUtxo,
   determineUtxosForSpend,
   determineUtxosForSpendAll,
 } from '../coin-selection/coin-selection';
+import { BtcSignerDefaultBip32Derivation } from '../signer/bitcoin-signer';
+import { BtcSignerNetwork } from '../utils/bitcoin.network';
+import { BitcoinError } from '../validation/bitcoin-error';
 
 export interface GenerateBitcoinUnsignedTransactionArgs {
   feeRate: number;

package/src/{bitcoin.network.ts → utils/bitcoin.network.ts}

@@ -2,6 +2,8 @@ import * as bitcoinJs from 'bitcoinjs-lib';
 
 import { BitcoinNetworkModes } from '@leather.io/models';
 
+// TODO - this PR was merged so we could update this
+// https://github.com/paulmillr/scure-btc-signer/blob/main/src/utils.ts
 // See this PR https://github.com/paulmillr/@scure/btc-signer/pull/15
 // Atttempting to add these directly to the library
 export interface BtcSignerNetwork {

package/src/{bitcoin.utils.spec.ts → utils/bitcoin.utils.spec.ts}

@@ -1,45 +1,50 @@
 import { describe, expect, it } from 'vitest';
 
+import { createBitcoinAddress } from '../validation/bitcoin-address';
 import { inferNetworkFromAddress, inferPaymentTypeFromAddress } from './bitcoin.utils';
 
 describe(inferNetworkFromAddress.name, () => {
   it('should return "mainnet" for P2PKH mainnet addresses', () => {
-    const mainnetAddress = '1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa';
+    const mainnetAddress = createBitcoinAddress('1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa');
     expect(inferNetworkFromAddress(mainnetAddress)).toBe('mainnet');
   });
 
   it('should return "mainnet" for P2SH mainnet addresses', () => {
-    const mainnetP2SHAddress = '3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy';
+    const mainnetP2SHAddress = createBitcoinAddress('3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy');
     expect(inferNetworkFromAddress(mainnetP2SHAddress)).toBe('mainnet');
   });
 
   it('should return "mainnet" for Bech32 mainnet addresses', () => {
-    const mainnetBech32Address = 'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080';
+    const mainnetBech32Address = createBitcoinAddress('bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080');
     expect(inferNetworkFromAddress(mainnetBech32Address)).toBe('mainnet');
   });
 
   it('should return "testnet" for P2PKH testnet addresses', () => {
-    const testnetP2PKHAddress = 'mipcBbFg9gMiCh81Kj8tqqdgoZub1ZJRfn';
+    const testnetP2PKHAddress = createBitcoinAddress('mipcBbFg9gMiCh81Kj8tqqdgoZub1ZJRfn');
     expect(inferNetworkFromAddress(testnetP2PKHAddress)).toBe('testnet');
   });
 
   it('should return "testnet" for P2SH testnet addresses', () => {
-    const testnetP2SHAddress = '2NBFNJTktNa7GZusGbDbGKRZTxdK9VVez3n';
+    const testnetP2SHAddress = createBitcoinAddress('2NBFNJTktNa7GZusGbDbGKRZTxdK9VVez3n');
     expect(inferNetworkFromAddress(testnetP2SHAddress)).toBe('testnet');
   });
 
   it('should return "testnet" for Bech32 testnet addresses', () => {
-    const testnetBech32Address = 'tb1qxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyz';
+    const testnetBech32Address = createBitcoinAddress(
+      'tb1qxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyz'
+    );
     expect(inferNetworkFromAddress(testnetBech32Address)).toBe('testnet');
   });
 
   it('should return "regtest" for Bech32 regtest addresses', () => {
-    const regtestBech32Address = 'bcrt1qxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyz';
+    const regtestBech32Address = createBitcoinAddress(
+      'bcrt1qxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyz'
+    );
     expect(inferNetworkFromAddress(regtestBech32Address)).toBe('regtest');
   });
 
   it('should throw an error for invalid addresses', () => {
-    const invalidAddress = 'invalidAddress';
+    const invalidAddress = createBitcoinAddress('invalidAddress');
     expect(() => inferNetworkFromAddress(invalidAddress)).toThrow(
       'Invalid or unsupported Bitcoin address format'
     );
@@ -49,32 +54,32 @@ describe(inferNetworkFromAddress.name, () => {
 
 describe(inferPaymentTypeFromAddress.name, () => {
   it('should return p2wpkh for mainnet P2WPKH address', () => {
-    const address = 'bc1qxyzabc123'; // Example P2WPKH mainnet address
+    const address = createBitcoinAddress('bc1qxyzabc123'); // Example P2WPKH mainnet address
     expect(inferPaymentTypeFromAddress(address)).toBe('p2wpkh');
   });
 
   it('should return p2tr for mainnet P2TR address', () => {
-    const address = 'bc1pxyzabc123'; // Example P2TR mainnet address
+    const address = createBitcoinAddress('bc1pxyzabc123'); // Example P2TR mainnet address
     expect(inferPaymentTypeFromAddress(address)).toBe('p2tr');
   });
 
   it('should return p2wpkh for testnet P2WPKH address', () => {
-    const address = 'tb1qxyzabc123'; // Example P2WPKH testnet address
+    const address = createBitcoinAddress('tb1qxyzabc123'); // Example P2WPKH testnet address
     expect(inferPaymentTypeFromAddress(address)).toBe('p2wpkh');
   });
 
   it('should return p2tr for testnet P2TR address', () => {
-    const address = 'tb1pxyzabc123'; // Example P2TR testnet address
+    const address = createBitcoinAddress('tb1pxyzabc123'); // Example P2TR testnet address
     expect(inferPaymentTypeFromAddress(address)).toBe('p2tr');
   });
 
   it('should return p2wpkh for regtest P2WPKH address', () => {
-    const address = 'bcrt1qxyzabc123'; // Example P2WPKH regtest address
+    const address = createBitcoinAddress('bcrt1qxyzabc123'); // Example P2WPKH regtest address
     expect(inferPaymentTypeFromAddress(address)).toBe('p2wpkh');
   });
 
   it('should return p2tr for regtest P2TR address', () => {
-    const address = 'bcrt1pxyzabc123'; // Example P2TR regtest address
+    const address = createBitcoinAddress('bcrt1pxyzabc123'); // Example P2TR regtest address
     expect(inferPaymentTypeFromAddress(address)).toBe('p2tr');
   });
 });

package/src/{bitcoin.utils.ts → utils/bitcoin.utils.ts}

@@ -10,15 +10,16 @@ import {
   extractPurposeFromPath,
 } from '@leather.io/crypto';
 import { BitcoinNetworkModes, NetworkModes } from '@leather.io/models';
-import type { PaymentTypes } from '@leather.io/rpc';
+import type { BitcoinPaymentTypes } from '@leather.io/rpc';
 import { defaultWalletKeyId, isDefined, whenNetwork } from '@leather.io/utils';
 
+import { getTaprootPayment } from '../payments/p2tr-address-gen';
+import { getNativeSegwitPaymentFromAddressIndex } from '../payments/p2wpkh-address-gen';
+import { BitcoinAddress } from '../validation/bitcoin-address';
 import { BtcSignerNetwork, getBtcSignerLibNetworkConfigByMode } from './bitcoin.network';
-import { getTaprootPayment } from './p2tr-address-gen';
-import { getNativeSegwitPaymentFromAddressIndex } from './p2wpkh-address-gen';
 
 export interface BitcoinAccount {
-  type: PaymentTypes;
+  type: BitcoinPaymentTypes;
   derivationPath: string;
   keychain: HDKey;
   accountIndex: number;
@@ -100,7 +101,10 @@ export function decodeBitcoinTx(tx: string): ReturnType<typeof btc.RawTx.decode>
   return btc.RawTx.decode(hexToBytes(tx));
 }
 
-export function getAddressFromOutScript(script: Uint8Array, bitcoinNetwork: BtcSignerNetwork) {
+export function getAddressFromOutScript(
+  script: Uint8Array,
+  bitcoinNetwork: BtcSignerNetwork
+): string {
   const outputScript = btc.OutScript.decode(script);
 
   switch (outputScript.type) {
@@ -135,7 +139,7 @@ export function getAddressFromOutScript(script: Uint8Array, bitcoinNetwork: BtcS
  */
 export type BtcSignerLibPaymentTypeIdentifers = 'wpkh' | 'wsh' | 'tr' | 'pkh' | 'sh';
 
-export const paymentTypeMap: Record<BtcSignerLibPaymentTypeIdentifers, PaymentTypes> = {
+export const paymentTypeMap: Record<BtcSignerLibPaymentTypeIdentifers, BitcoinPaymentTypes> = {
   wpkh: 'p2wpkh',
   wsh: 'p2wpkh-p2sh',
   tr: 'p2tr',
@@ -155,14 +159,16 @@ export function isBtcSignerLibPaymentType(
   return payment in paymentTypeMap;
 }
 
-export function parseKnownPaymentType(payment: BtcSignerLibPaymentTypeIdentifers | PaymentTypes) {
+export function parseKnownPaymentType(
+  payment: BtcSignerLibPaymentTypeIdentifers | BitcoinPaymentTypes
+) {
   return isBtcSignerLibPaymentType(payment)
     ? btcSignerLibPaymentTypeToPaymentTypeMap(payment)
     : payment;
 }
 
-export type PaymentTypeMap<T> = Record<PaymentTypes, T>;
-export function whenPaymentType(mode: PaymentTypes | BtcSignerLibPaymentTypeIdentifers) {
+export type PaymentTypeMap<T> = Record<BitcoinPaymentTypes, T>;
+export function whenPaymentType(mode: BitcoinPaymentTypes | BtcSignerLibPaymentTypeIdentifers) {
   return <T>(paymentMap: PaymentTypeMap<T>): T => paymentMap[parseKnownPaymentType(mode)];
 }
 
@@ -178,7 +184,7 @@ export function whenSupportedPaymentType(mode: SupportedPaymentType) {
  * @example
  * `m/86'/1'/0'/0/0`
  */
-export function inferPaymentTypeFromPath(path: string): PaymentTypes {
+export function inferPaymentTypeFromPath(path: string): BitcoinPaymentTypes {
   const purpose = extractPurposeFromPath(path);
   switch (purpose) {
     case 84:
@@ -230,7 +236,7 @@ export function getBitcoinInputAddress(input: TransactionInput, bitcoinNetwork:
 export function getInputPaymentType(
   input: TransactionInput,
   network: BitcoinNetworkModes
-): PaymentTypes {
+): BitcoinPaymentTypes {
   const address = getBitcoinInputAddress(input, getBtcSignerLibNetworkConfigByMode(network));
   if (address === '') throw new Error('Input address cannot be empty');
   if (address.startsWith('bc1p') || address.startsWith('tb1p') || address.startsWith('bcrt1p'))
@@ -319,7 +325,7 @@ export function getPsbtTxOutputs(psbtTx: btc.Transaction): TransactionOutput[] {
   return outputs;
 }
 
-export function inferNetworkFromAddress(address: string): BitcoinNetworkModes {
+export function inferNetworkFromAddress(address: BitcoinAddress): BitcoinNetworkModes {
   if (address.startsWith('bc1')) return 'mainnet';
   if (address.startsWith('tb1')) return 'testnet';
   if (address.startsWith('bcrt1')) return 'regtest';
@@ -333,7 +339,7 @@ export function inferNetworkFromAddress(address: string): BitcoinNetworkModes {
   throw new Error('Invalid or unsupported Bitcoin address format');
 }
 
-export function inferPaymentTypeFromAddress(address: string): SupportedPaymentType {
+export function inferPaymentTypeFromAddress(address: BitcoinAddress): SupportedPaymentType {
   if (address.startsWith('bc1q') || address.startsWith('tb1q') || address.startsWith('bcrt1q'))
     return 'p2wpkh';
 

package/src/{lookup-derivation-by-address.spec.ts → utils/lookup-derivation-by-address.spec.ts}

@@ -1,9 +1,10 @@
 import { deriveRootKeychainFromMnemonic } from '@leather.io/crypto';
 
-import { testMnemonic } from '../../../config/test-helpers';
+import { testMnemonic } from '../../../../config/test-helpers';
+import { deriveTaprootAccount } from '../payments/p2tr-address-gen';
+import { deriveNativeSegwitAccountFromRootKeychain } from '../payments/p2wpkh-address-gen';
+import { createBitcoinAddress } from '../validation/bitcoin-address';
 import { lookupDerivationByAddress } from './lookup-derivation-by-address';
-import { deriveTaprootAccount } from './p2tr-address-gen';
-import { deriveNativeSegwitAccountFromRootKeychain } from './p2wpkh-address-gen';
 
 describe(lookupDerivationByAddress.name, async () => {
   const rootKeychain = await deriveRootKeychainFromMnemonic(testMnemonic);
@@ -35,7 +36,7 @@ describe(lookupDerivationByAddress.name, async () => {
         nativeSegwitXpub: firstNativeSegwitAccountKeychain.keychain.publicExtendedKey,
         iterationLimit: 100,
       });
-      expect(lookup(address).path).toEqual(path);
+      expect(lookup(createBitcoinAddress(address)).path).toEqual(path);
     });
   });
 
@@ -50,7 +51,9 @@ describe(lookupDerivationByAddress.name, async () => {
         iterationLimit: 10,
       });
 
-      expect(lookup('bc1qvgtk702cayady9wvkhvs5jn8c2ldurhazx9nzf').path).toBe(`m/84'/0'/1'/0/0`);
+      expect(lookup(createBitcoinAddress('bc1qvgtk702cayady9wvkhvs5jn8c2ldurhazx9nzf')).path).toBe(
+        `m/84'/0'/1'/0/0`
+      );
     });
   });
 
@@ -65,7 +68,9 @@ describe(lookupDerivationByAddress.name, async () => {
         iterationLimit: 10,
       });
 
-      expect(lookup('bc1qvgsomefakeaddressitwontfind').status).toBe('failure');
+      expect(lookup(createBitcoinAddress('bc1qvgsomefakeaddressitwontfind')).status).toBe(
+        'failure'
+      );
     });
   });
 });

package/src/{lookup-derivation-by-address.ts → utils/lookup-derivation-by-address.ts}

@@ -2,6 +2,9 @@ import { HARDENED_OFFSET, HDKey } from '@scure/bip32';
 
 import { createCounter } from '@leather.io/utils';
 
+import { makeTaprootAddressIndexDerivationPath } from '../payments/p2tr-address-gen';
+import { makeNativeSegwitAddressIndexDerivationPath } from '../payments/p2wpkh-address-gen';
+import { BitcoinAddress } from '../validation/bitcoin-address';
 import {
   getNativeSegwitAddress,
   getTaprootAddress,
@@ -9,8 +12,6 @@ import {
   inferPaymentTypeFromAddress,
   whenSupportedPaymentType,
 } from './bitcoin.utils';
-import { makeTaprootAddressIndexDerivationPath } from './p2tr-address-gen';
-import { makeNativeSegwitAddressIndexDerivationPath } from './p2wpkh-address-gen';
 
 interface LookUpDerivationByAddressArgs {
   taprootXpub: string;
@@ -23,7 +24,7 @@ export function lookupDerivationByAddress(args: LookUpDerivationByAddressArgs) {
   const taprootKeychain = HDKey.fromExtendedKey(taprootXpub);
   const nativeSegwitKeychain = HDKey.fromExtendedKey(nativeSegwitXpub);
 
-  return (address: string) => {
+  return (address: BitcoinAddress) => {
     const network = inferNetworkFromAddress(address);
     const paymentType = inferPaymentTypeFromAddress(address);