@leather.io/bitcoin 0.8.0

package/src/bip322/bip322-utils.spec.ts

@@ -0,0 +1,18 @@
+import { hexToBytes, utf8ToBytes } from '@noble/hashes/utils';
+
+import { hashBip322Message } from './bip322-utils';
+
+describe('Message hashing', () => {
+  test('empty string', () =>
+    expect(hashBip322Message(utf8ToBytes(''))).toEqual(
+      hexToBytes('c90c269c4f8fcbe6880f72a721ddfbf1914268a794cbb21cfafee13770ae19f1')
+    ));
+
+  const helloWorld = 'Hello World';
+
+  test(helloWorld, () =>
+    expect(hashBip322Message(utf8ToBytes(helloWorld))).toEqual(
+      hexToBytes('f0eb03b1a75ac6d9847f55c624a99169b5dccba2a31f5b23bea77ba270de0a7a')
+    )
+  );
+});

package/src/bip322/bip322-utils.ts

@@ -0,0 +1,85 @@
+import ecc from '@bitcoinerlab/secp256k1';
+import { sha256 } from '@noble/hashes/sha256';
+import { hexToBytes, utf8ToBytes } from '@stacks/common';
+import * as bitcoin from 'bitcoinjs-lib';
+import { ECPairFactory } from 'ecpair';
+import { encode } from 'varuint-bitcoin';
+
+import { PaymentTypes } from '@leather.io/rpc';
+import { isString } from '@leather.io/utils';
+
+import { toXOnly } from '../bitcoin.utils';
+
+const bip322MessageTag = 'BIP0322-signed-message';
+
+const ECPair = ECPairFactory(ecc);
+bitcoin.initEccLib(ecc);
+
+export function ecPairFromPrivateKey(key: Uint8Array) {
+  return ECPair.fromPrivateKey(Buffer.from(key));
+}
+
+// See tagged hashes section of BIP-340
+// https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki#design
+const messageTagHash = Uint8Array.from([
+  ...sha256(utf8ToBytes(bip322MessageTag)),
+  ...sha256(utf8ToBytes(bip322MessageTag)),
+]);
+
+export function hashBip322Message(message: Uint8Array | string) {
+  return sha256(
+    Uint8Array.from([...messageTagHash, ...(isString(message) ? utf8ToBytes(message) : message)])
+  );
+}
+
+export const bip322TransactionToSignValues = {
+  prevoutHash: hexToBytes('0000000000000000000000000000000000000000000000000000000000000000'),
+  prevoutIndex: 0xffffffff,
+  sequence: 0,
+};
+
+function encodeVarString(b: Buffer) {
+  return Buffer.concat([encode(b.byteLength), b]);
+}
+
+const supportedMessageSigningPaymentTypes: PaymentTypes[] = ['p2wpkh', 'p2tr'];
+
+export function isSupportedMessageSigningPaymentType(paymentType: string) {
+  return supportedMessageSigningPaymentTypes.includes(paymentType as PaymentTypes);
+}
+
+/**
+ * Encode witness data for a BIP322 message
+ * TODO: Refactor to remove `Buffer` use
+ */
+export function encodeMessageWitnessData(witnessArray: Buffer[]) {
+  const len = encode(witnessArray.length);
+  return Buffer.concat([len, ...witnessArray.map(witness => encodeVarString(witness))]);
+}
+
+function tapTweakHash(pubKey: Buffer, h: Buffer | undefined): Buffer {
+  return bitcoin.crypto.taggedHash('TapTweak', Buffer.concat(h ? [pubKey, h] : [pubKey]));
+}
+
+export function tweakSigner(signer: bitcoin.Signer, opts: any = {}): bitcoin.Signer {
+  // @ts-expect-error privateKey exists on signer
+  let privateKey: Uint8Array | undefined = signer.privateKey!;
+  if (!privateKey) {
+    throw new Error('Private key is required for tweaking signer!');
+  }
+  if (signer.publicKey[0] === 3) {
+    privateKey = ecc.privateNegate(privateKey);
+  }
+
+  const tweakedPrivateKey = ecc.privateAdd(
+    privateKey,
+    tapTweakHash(toXOnly(signer.publicKey), opts.tweakHash)
+  );
+  if (!tweakedPrivateKey) {
+    throw new Error('Invalid tweaked private key!');
+  }
+
+  return ECPair.fromPrivateKey(Buffer.from(tweakedPrivateKey), {
+    network: opts.network,
+  });
+}

package/src/bip322/sign-message-bip322-bitcoinjs.ts

@@ -0,0 +1,93 @@
+import { base64 } from '@scure/base';
+import * as btc from '@scure/btc-signer';
+import * as bitcoin from 'bitcoinjs-lib';
+
+import { BitcoinNetworkModes } from '@leather.io/models';
+
+import { getBitcoinJsLibNetworkConfigByMode } from '../bitcoin.network';
+import {
+  bip322TransactionToSignValues,
+  ecPairFromPrivateKey,
+  encodeMessageWitnessData,
+  hashBip322Message,
+  tweakSigner,
+} from './bip322-utils';
+
+export function createNativeSegwitBitcoinJsSigner(privateKey: Buffer) {
+  return ecPairFromPrivateKey(privateKey);
+}
+
+export function createTaprootBitcoinJsSigner(privateKey: Buffer) {
+  return tweakSigner(ecPairFromPrivateKey(privateKey));
+}
+
+export function createToSpendTx(address: string, message: string, network: BitcoinNetworkModes) {
+  const { prevoutHash, prevoutIndex, sequence } = bip322TransactionToSignValues;
+
+  const script = bitcoin.address.toOutputScript(
+    address,
+    getBitcoinJsLibNetworkConfigByMode(network)
+  );
+
+  const hash = hashBip322Message(message);
+  const commands = [0, Buffer.from(hash)];
+  const scriptSig = bitcoin.script.compile(commands);
+
+  const virtualToSpend = new bitcoin.Transaction();
+  virtualToSpend.version = 0;
+  virtualToSpend.addInput(Buffer.from(prevoutHash), prevoutIndex, sequence, scriptSig);
+  virtualToSpend.addOutput(script, 0);
+  return { virtualToSpend, script };
+}
+
+function createToSignTx(toSpendTxHex: Buffer, script: Buffer, network: BitcoinNetworkModes) {
+  const virtualToSign = new bitcoin.Psbt({ network: getBitcoinJsLibNetworkConfigByMode(network) });
+  virtualToSign.setVersion(0);
+  const prevTxHash = toSpendTxHex;
+  const prevOutIndex = 0;
+  const toSignScriptSig = bitcoin.script.compile([bitcoin.script.OPS.OP_RETURN]);
+
+  virtualToSign.addInput({
+    hash: prevTxHash,
+    index: prevOutIndex,
+    sequence: 0,
+    witnessUtxo: { script, value: 0 },
+  });
+
+  virtualToSign.addOutput({ script: toSignScriptSig, value: 0 });
+  return virtualToSign;
+}
+
+interface SignBip322MessageSimple {
+  address: string;
+  message: string;
+  network: BitcoinNetworkModes;
+  signPsbt(psbt: bitcoin.Psbt): Promise<btc.Transaction>;
+}
+export async function signBip322MessageSimple(args: SignBip322MessageSimple) {
+  const { address, message, network, signPsbt } = args;
+
+  const { virtualToSpend, script } = createToSpendTx(address, message, network);
+
+  const virtualToSign = createToSignTx(virtualToSpend.getHash(), script, network);
+
+  const signedTx = await signPsbt(virtualToSign);
+
+  const asBitcoinJsTransaction = bitcoin.Psbt.fromBuffer(Buffer.from(signedTx.toPSBT()));
+
+  asBitcoinJsTransaction.finalizeInput(0);
+
+  // sign the tx
+  // section 5.1
+  // github.com/LegReq/bip0322-signatures/blob/master/BIP0322_signing.ipynb
+  const toSignTx = asBitcoinJsTransaction.extractTransaction();
+
+  const result = encodeMessageWitnessData(toSignTx.ins[0].witness);
+
+  return {
+    virtualToSpend,
+    virtualToSign: toSignTx,
+    unencodedSig: result,
+    signature: base64.encode(result),
+  };
+}

package/src/bip322/sign-message-bip322.spec.ts

@@ -0,0 +1,168 @@
+import * as secp from '@noble/secp256k1';
+import * as btc from '@scure/btc-signer';
+import { bytesToHex } from '@stacks/common';
+import * as bitcoin from 'bitcoinjs-lib';
+
+import { ecdsaPublicKeyToSchnorr } from '../bitcoin.utils';
+import {
+  createNativeSegwitBitcoinJsSigner,
+  createTaprootBitcoinJsSigner,
+  createToSpendTx,
+  signBip322MessageSimple,
+} from './sign-message-bip322-bitcoinjs';
+
+describe(createToSpendTx.name, () => {
+  test('bitcoinjs example', () => {
+    const result = createToSpendTx(
+      'bc1q9vza2e8x573nczrlzms0wvx3gsqjx7vavgkx0l',
+      'generatedWithBitcoinJs',
+      'mainnet'
+    );
+
+    expect(result.script.toString('hex')).toEqual('00142b05d564e6a7a33c087f16e0f730d1440123799d');
+
+    expect(result.virtualToSpend.toHex()).toEqual(
+      '00000000010000000000000000000000000000000000000000000000000000000000000000ffffffff220020093bbd44da65116318b960749b3d6172ab9775b5d1923a7c71e18845c6524852000000000100000000000000001600142b05d564e6a7a33c087f16e0f730d1440123799d00000000'
+    );
+  });
+});
+
+//
+// https://github.com/bitcoin/bips/blob/master/bip-0322.mediawiki#test-vectors
+describe(signBip322MessageSimple.name, () => {
+  const testVectorKey = btc.WIF().decode('L3VFeEujGtevx9w18HD1fhRbCH67Az2dpCymeRE1SoPK6XQtaN2k');
+
+  describe('Message signing, Native Segwit', () => {
+    const nativeSegwitAddress = btc.getAddress('wpkh', testVectorKey);
+    const payment = btc.p2wpkh(secp.getPublicKey(testVectorKey, true));
+
+    async function signPsbt(psbt: bitcoin.Psbt) {
+      psbt.signAllInputs(createNativeSegwitBitcoinJsSigner(Buffer.from(testVectorKey)));
+      return btc.Transaction.fromPSBT(psbt.toBuffer());
+    }
+
+    if (!nativeSegwitAddress) throw new Error('nativeSegwitAddress is undefined');
+
+    test('Addresses against native segwit test vectors', () => {
+      expect(nativeSegwitAddress).toEqual('bc1q9vza2e8x573nczrlzms0wvx3gsqjx7vavgkx0l');
+      expect(payment.address).toEqual('bc1q9vza2e8x573nczrlzms0wvx3gsqjx7vavgkx0l');
+    });
+
+    test('Signature: "" (empty string)', async () => {
+      const {
+        virtualToSpend: emptyStringToSpend,
+        virtualToSign: emptyStringToSign,
+        signature: emptyStringSig,
+      } = await signBip322MessageSimple({
+        address: nativeSegwitAddress,
+        message: '',
+        network: 'mainnet',
+        signPsbt,
+      });
+      expect(emptyStringToSpend.getId()).toEqual(
+        'c5680aa69bb8d860bf82d4e9cd3504b55dde018de765a91bb566283c545a99a7'
+      );
+      expect(emptyStringToSign.getId()).toEqual(
+        '1e9654e951a5ba44c8604c4de6c67fd78a27e81dcadcfe1edf638ba3aaebaed6'
+      );
+
+      // Signature
+      // Bip322 says:
+      // AkcwRAIgM2gBAQqvZX15ZiysmKmQpDrG83avLIT492QBzLnQIxYCIBaTpOaD20qRlEylyxFSeEA2ba9YOixpX8z46TSDtS40ASECx/EgAxlkQpQ9hYjgGu6EBCPMVPwVIVJqO4XCsMvViHI=
+      expect(emptyStringSig).toEqual(
+        'AkgwRQIhAPkJ1Q4oYS0htvyuSFHLxRQpFAY56b70UvE7Dxazen0ZAiAtZfFz1S6T6I23MWI2lK/pcNTWncuyL8UL+oMdydVgzAEhAsfxIAMZZEKUPYWI4BruhAQjzFT8FSFSajuFwrDL1Yhy'
+      );
+    });
+
+    const helloWorld = 'Hello World';
+    test(`Signature: "${helloWorld}"`, async () => {
+      const { virtualToSpend, virtualToSign, unencodedSig, signature } =
+        await signBip322MessageSimple({
+          address: nativeSegwitAddress,
+          message: helloWorld,
+          network: 'mainnet',
+          signPsbt,
+        });
+
+      // section 3
+      expect(virtualToSpend.getId()).toEqual(
+        'b79d196740ad5217771c1098fc4a4b51e0535c32236c71f1ea4d61a2d603352b'
+      );
+
+      // sectuion 4.3 expectedid
+      expect(virtualToSign.getId()).toEqual(
+        '88737ae86f2077145f93cc4b153ae9a1cb8d56afa511988c149c5c8c9d93bddf'
+      );
+
+      // sectioun 5.2 witness
+      expect(virtualToSign.ins[0].witness.map(bytesToHex).join(' ')).toEqual(
+        '3045022100ecf2ca796ab7dde538a26bfb09a6c487a7b3fff33f397db6a20eb9af77c0ee8c022062e67e44c8070f49c3a37f5940a8850842daf7cca35e6af61a6c7c91f1e1a1a301 02c7f12003196442943d8588e01aee840423cc54fc1521526a3b85c2b0cbd58872'
+      );
+
+      expect(unencodedSig.toString('hex')).toEqual(
+        '02483045022100ecf2ca796ab7dde538a26bfb09a6c487a7b3fff33f397db6a20eb9af77c0ee8c022062e67e44c8070f49c3a37f5940a8850842daf7cca35e6af61a6c7c91f1e1a1a3012102c7f12003196442943d8588e01aee840423cc54fc1521526a3b85c2b0cbd58872'
+      );
+
+      // Signature
+      // Bip322 says:
+      // AkcwRAIgZRfIY3p7/DoVTty6YZbWS71bc5Vct9p9Fia83eRmw2QCICK/ENGfwLtptFluMGs2KsqoNSk89pO7F29zJLUx9a/sASECx/EgAxlkQpQ9hYjgGu6EBCPMVPwVIVJqO4XCsMvViHI=
+      expect(signature).toEqual(
+        'AkgwRQIhAOzyynlqt93lOKJr+wmmxIens//zPzl9tqIOua93wO6MAiBi5n5EyAcPScOjf1lAqIUIQtr3zKNeavYabHyR8eGhowEhAsfxIAMZZEKUPYWI4BruhAQjzFT8FSFSajuFwrDL1Yhy'
+      );
+    });
+  });
+
+  describe('Message Signing, Taproot', () => {
+    const taprootAddress = btc.getAddress('tr', testVectorKey);
+
+    if (!taprootAddress) throw new Error('Could not generate taproot address');
+
+    const payment = btc.p2tr(
+      ecdsaPublicKeyToSchnorr(secp.getPublicKey(Buffer.from(testVectorKey), true))
+    );
+
+    async function signPsbt(psbt: bitcoin.Psbt) {
+      psbt.data.inputs.forEach(
+        input => (input.tapInternalKey = Buffer.from(payment.tapInternalKey))
+      );
+      psbt.signAllInputs(createTaprootBitcoinJsSigner(Buffer.from(testVectorKey)));
+      return btc.Transaction.fromPSBT(psbt.toBuffer());
+    }
+
+    test('Addresses against taproot test vectors', () => {
+      expect(taprootAddress).toEqual(
+        'bc1ppv609nr0vr25u07u95waq5lucwfm6tde4nydujnu8npg4q75mr5sxq8lt3'
+      );
+      expect(payment.address).toEqual(
+        'bc1ppv609nr0vr25u07u95waq5lucwfm6tde4nydujnu8npg4q75mr5sxq8lt3'
+      );
+    });
+
+    // Taproot signatures verified with verifymessage request to node
+    test('Signature: "" (empty string)', async () => {
+      const { signature } = await signBip322MessageSimple({
+        address: taprootAddress,
+        message: '',
+        network: 'mainnet',
+        signPsbt,
+      });
+
+      expect(signature).toEqual(
+        'AUD4DxC7li8RxVkoC/H27LIZnaBD/ZCyZOjjVTzyQf7wa1kYMuyv1uX7XshysTXVR05HbexLSChXuGSoZcqJl6zF'
+      );
+    });
+
+    test('Signature: "WearLeather"', async () => {
+      const { signature } = await signBip322MessageSimple({
+        address: taprootAddress,
+        message: 'WearLeather',
+        network: 'mainnet',
+        signPsbt,
+      });
+
+      expect(signature).toEqual(
+        'AUDjK8SJX34boek3m3EKXI94AMBZynJUmdqgO7i4z6JKG6gkUgp+brkWl0ylzWb+8enM4s4B4TWel0iCmcQrKNWS'
+      );
+    });
+  });
+});

package/src/bip322/sign-message-bip322.ts

@@ -0,0 +1,54 @@
+import * as btc from '@scure/btc-signer';
+import { hexToBytes } from '@stacks/common';
+
+import { hashBip322Message } from './bip322-utils';
+
+// TODO: Complete this fn
+// Ran into difficiulties with btc-signer vs bitcoinjs-lib
+// Using that library to unblock for now, but we should go
+// back and replace it when possible.
+// ts-unused-exports:disable-next-line
+export function _UNSAFE_signBip322MessageSimple(script: Uint8Array, message: string) {
+  // nVersion = 0
+  // nLockTime = 0
+  // vin[0].prevout.hash = 0000...000
+  // vin[0].prevout.n = 0xFFFFFFFF
+  // vin[0].nSequence = 0
+  // vin[0].scriptSig = OP_0 PUSH32[ message_hash ]
+  // vin[0].scriptWitness = []
+  // vout[0].nValue = 0
+  // vout[0].scriptPubKey = message_challenge
+
+  const prevoutHash = hexToBytes(
+    '0000000000000000000000000000000000000000000000000000000000000000'
+  );
+  const prevoutIndex = 0xffffffff;
+  const sequence = 0;
+
+  const hash = hashBip322Message(message);
+
+  const commands = [btc.OP.OP_0, hash];
+
+  const virtualToSpend = new btc.Transaction({
+    version: 0,
+    lockTime: 0,
+    allowUnknowInput: true,
+    allowUnknowOutput: true,
+    disableScriptCheck: true,
+    allowLegacyWitnessUtxo: true,
+  });
+
+  virtualToSpend.addInput({
+    txid: prevoutHash,
+    index: prevoutIndex,
+    sequence,
+    witnessScript: btc.Script.encode(commands),
+  });
+
+  virtualToSpend.addOutput({
+    script,
+    amount: 0n,
+  });
+
+  return { virtualToSpend };
+}

package/src/bitcoin-signer.ts

@@ -0,0 +1,19 @@
+import { HDKey } from '@scure/bip32';
+import * as btc from '@scure/btc-signer';
+import { SigHash } from '@scure/btc-signer/transaction';
+
+import type { BitcoinNetworkModes } from '@leather.io/models';
+import { SignatureHash } from '@leather.io/rpc';
+
+export type AllowedSighashTypes = SignatureHash | SigHash;
+
+export interface Signer<Payment> {
+  network: BitcoinNetworkModes;
+  payment: Payment;
+  keychain: HDKey;
+  derivationPath: string;
+  address: string;
+  publicKey: Uint8Array;
+  sign(tx: btc.Transaction): void;
+  signIndex(tx: btc.Transaction, index: number, allowedSighash?: AllowedSighashTypes[]): void;
+}

package/src/bitcoin.network.ts

@@ -0,0 +1,57 @@
+import * as bitcoinJs from 'bitcoinjs-lib';
+
+import { BitcoinNetworkModes } from '@leather.io/models';
+
+// See this PR https://github.com/paulmillr/@scure/btc-signer/pull/15
+// Atttempting to add these directly to the library
+export interface BtcSignerNetwork {
+  bech32: string;
+  pubKeyHash: number;
+  scriptHash: number;
+  wif: number;
+}
+
+const bitcoinMainnet: BtcSignerNetwork = {
+  bech32: 'bc',
+  pubKeyHash: 0x00,
+  scriptHash: 0x05,
+  wif: 0x80,
+};
+
+const bitcoinTestnet: BtcSignerNetwork = {
+  bech32: 'tb',
+  pubKeyHash: 0x6f,
+  scriptHash: 0xc4,
+  wif: 0xef,
+};
+
+const bitcoinRegtest: BtcSignerNetwork = {
+  bech32: 'bcrt',
+  pubKeyHash: 0x6f,
+  scriptHash: 0xc4,
+  wif: 0xef,
+};
+
+const btcSignerLibNetworks: Record<BitcoinNetworkModes, BtcSignerNetwork> = {
+  mainnet: bitcoinMainnet,
+  testnet: bitcoinTestnet,
+  regtest: bitcoinRegtest,
+  // Signet originally was going to have its own prefix but authors decided to
+  // copy testnet
+  signet: bitcoinTestnet,
+};
+
+export function getBtcSignerLibNetworkConfigByMode(network: BitcoinNetworkModes) {
+  return btcSignerLibNetworks[network];
+}
+
+const bitcoinJsLibNetworks: Record<BitcoinNetworkModes, bitcoinJs.Network> = {
+  mainnet: bitcoinJs.networks.bitcoin,
+  testnet: bitcoinJs.networks.testnet,
+  regtest: bitcoinJs.networks.regtest,
+  signet: bitcoinJs.networks.testnet,
+};
+
+export function getBitcoinJsLibNetworkConfigByMode(network: BitcoinNetworkModes) {
+  return bitcoinJsLibNetworks[network];
+}