Merge commit 'b28bbf26ecb13db38b5569b1b4c6bf26726b00fe' into rel/latest

Author: bitgobot

.husky/commit-msg

@@ -0,0 +1,6 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+rootDir=$(pwd)
+cd "$rootDir"
+
+yarn check-commits

commitlint.config.js

@@ -67,6 +67,9 @@ module.exports = {
         'VL-',
         'WIN-',
         'WP-',
+        'WAL-',
+        'WCN-',
+        'WCI-',
         'COIN-',
         'FIAT-',
         'ME-',

modules/abstract-eth/src/abstractEthLikeNewCoins.ts

@@ -359,6 +359,7 @@ interface EthTransactionParams extends TransactionParams {
   hop?: boolean;
   prebuildTx?: PrebuildTransactionResult;
   tokenName?: string;
+  feeToken?: string;
 }
 
 export interface VerifyEthTransactionOptions extends VerifyTransactionOptions {

modules/abstract-lightning/src/abstractLightningCoin.ts

@@ -2,6 +2,7 @@ import {
   AuditDecryptedKeyParams,
   BaseCoin,
   BitGoBase,
+  InvalidAddressError,
   KeyPair,
   ParsedTransaction,
   ParseTransactionOptions,
@@ -15,16 +16,20 @@ import * as utxolib from '@bitgo/utxo-lib';
 import { randomBytes } from 'crypto';
 import { bip32 } from '@bitgo/utxo-lib';
 
+export interface LightningVerifyAddressOptions extends VerifyAddressOptions {
+  walletId: string;
+}
+
 export abstract class AbstractLightningCoin extends BaseCoin {
   protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
-  private readonly _network: utxolib.Network;
+  protected readonly network: utxolib.Network;
   protected constructor(bitgo: BitGoBase, network: utxolib.Network, staticsCoin?: Readonly<StaticsBaseCoin>) {
     super(bitgo);
     if (!staticsCoin) {
       throw new Error('missing required constructor parameter staticsCoin');
     }
     this._staticsCoin = staticsCoin;
-    this._network = network;
+    this.network = network;
   }
 
   getBaseFactor(): number {
@@ -35,8 +40,24 @@ export abstract class AbstractLightningCoin extends BaseCoin {
     throw new Error('Method not implemented.');
   }
 
-  isWalletAddress(params: VerifyAddressOptions): Promise<boolean> {
-    throw new Error('Method not implemented.');
+  async isWalletAddress(params: LightningVerifyAddressOptions): Promise<boolean> {
+    const { address, walletId } = params;
+
+    if (!this.isValidAddress(address)) {
+      throw new InvalidAddressError(`invalid address: ${address}`);
+    }
+
+    // Node pubkeys are valid addresses but not wallet addresses
+    if (/^(02|03)[0-9a-fA-F]{64}$/.test(address)) {
+      return false;
+    }
+
+    try {
+      await this.bitgo.get(this.url(`/wallet/${walletId}/address/${encodeURIComponent(address)}`)).result();
+      return true;
+    } catch (e) {
+      return false;
+    }
   }
 
   parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {
@@ -58,11 +79,23 @@ export abstract class AbstractLightningCoin extends BaseCoin {
   }
 
   isValidPub(pub: string): boolean {
-    throw new Error('Method not implemented.');
+    try {
+      return bip32.fromBase58(pub).isNeutered();
+    } catch (e) {
+      return false;
+    }
   }
 
   isValidAddress(address: string): boolean {
-    throw new Error('Method not implemented.');
+    if (/^(02|03)[0-9a-fA-F]{64}$/.test(address)) {
+      return true;
+    }
+    try {
+      const script = utxolib.address.toOutputScript(address, this.network);
+      return address === utxolib.address.fromOutputScript(script, this.network);
+    } catch (e) {
+      return false;
+    }
   }
 
   signTransaction(params: SignTransactionOptions): Promise<SignedTransaction> {

modules/abstract-utxo/package.json

@@ -66,7 +66,7 @@
     "@bitgo/utxo-core": "^1.35.2",
     "@bitgo/utxo-lib": "^11.22.0",
     "@bitgo/utxo-ord": "^1.28.1",
-    "@bitgo/wasm-utxo": "^2.1.0",
+    "@bitgo/wasm-utxo": "^4.1.0",
     "@types/lodash": "^4.14.121",
     "@types/superagent": "4.1.15",
     "bignumber.js": "^9.0.2",

modules/abstract-utxo/src/abstractUtxoCoin.ts

@@ -13,6 +13,7 @@ import {
   ExtraPrebuildParamsOptions,
   HalfSignedUtxoTransaction,
   IBaseCoin,
+  isBolt11Invoice,
   InvalidAddressDerivationPropertyError,
   InvalidAddressError,
   IRequestTracer,
@@ -344,6 +345,8 @@ type UtxoBaseSignTransactionOptions<TNumber extends number | bigint = number> =
    * When false, return finalized PSBT. Useful for testing to keep transactions in PSBT format.
    */
   extractTransaction?: boolean;
+  /** When true, embeds WASM-UTXO version metadata into the signed PSBT. Defaults to false. */
+  writeSignedWith?: boolean;
 };
 
 export type SignTransactionOptions<TNumber extends number | bigint = number> = UtxoBaseSignTransactionOptions<TNumber> &
@@ -489,11 +492,24 @@ export abstract class AbstractUtxoCoin
    * @param address
    * @param param
    */
-  isValidAddress(address: string, param?: { anyFormat: boolean } | /* legacy parameter */ boolean): boolean {
+  isValidAddress(
+    address: string,
+    param?: { anyFormat?: boolean; allowLightning?: boolean } | /* legacy parameter */ boolean
+  ): boolean {
     if (typeof param === 'boolean' && param) {
       throw new Error('deprecated');
     }
 
+    const allowLightning = (param as { allowLightning?: boolean } | undefined)?.allowLightning ?? false;
+    if (allowLightning) {
+      if (/^(02|03)[0-9a-fA-F]{64}$/.test(address)) {
+        return true;
+      }
+      if (isBolt11Invoice(address)) {
+        return true;
+      }
+    }
+
     // By default, allow all address formats.
     // At the time of writing, the only additional address format is bch cashaddr.
     const anyFormat = (param as { anyFormat: boolean } | undefined)?.anyFormat ?? true;

modules/abstract-utxo/src/transaction/fixedScript/signPsbtWasm.ts

@@ -1,6 +1,6 @@
 import assert from 'assert';
 
-import { BIP32, bip32, ECPair, fixedScriptWallet } from '@bitgo/wasm-utxo';
+import { BIP32, bip32, ECPair, fixedScriptWallet, getWasmUtxoVersion } from '@bitgo/wasm-utxo';
 
 import { toWasmBIP32 } from '../../wasmUtil';
 
@@ -37,7 +37,8 @@ export function signAndVerifyPsbtWasm(
   tx: fixedScriptWallet.BitGoPsbt,
   signerKeychain: bip32.BIP32Interface | BIP32,
   rootWalletKeys: fixedScriptWallet.RootWalletKeys,
-  replayProtection: ReplayProtectionKeys
+  replayProtection: ReplayProtectionKeys,
+  { writeSignedWith = false }: { writeSignedWith?: boolean } = {}
 ): fixedScriptWallet.BitGoPsbt {
   const wasmSigner = toWasmBIP32(signerKeychain);
 
@@ -74,6 +75,17 @@ export function signAndVerifyPsbtWasm(
     throw new TransactionSigningError([], verifyErrors);
   }
 
+  if (writeSignedWith) {
+    const versionInfo = getWasmUtxoVersion();
+    const versionPayload = new TextEncoder().encode(
+      JSON.stringify({
+        version: versionInfo.version,
+        gitHash: versionInfo.gitHash,
+      })
+    );
+    tx.setKV({ type: 'bitgo', subtype: fixedScriptWallet.BitGoKeySubtype.WasmUtxoSignedWith }, versionPayload);
+  }
+
   return tx;
 }
 
@@ -86,6 +98,7 @@ export async function signPsbtWithMusig2ParticipantWasm(
     replayProtection: ReplayProtectionKeys;
     signingStep: 'signerNonce' | 'cosignerNonce' | 'signerSignature' | undefined;
     walletId: string | undefined;
+    writeSignedWith?: boolean;
   }
 ): Promise<fixedScriptWallet.BitGoPsbt> {
   const wasmSigner = signerKeychain ? toWasmBIP32(signerKeychain) : undefined;
@@ -135,5 +148,7 @@ export async function signPsbtWithMusig2ParticipantWasm(
   }
 
   assert(signerKeychain);
-  return signAndVerifyPsbtWasm(tx, signerKeychain, rootWalletKeys, params.replayProtection);
+  return signAndVerifyPsbtWasm(tx, signerKeychain, rootWalletKeys, params.replayProtection, {
+    writeSignedWith: params.writeSignedWith,
+  });
 }

modules/abstract-utxo/src/transaction/fixedScript/signTransaction.ts

@@ -23,32 +23,36 @@ export function signAndVerifyPsbt(
   psbt: utxolib.bitgo.UtxoPsbt,
   signerKeychain: bip32.BIP32Interface | BIP32,
   rootWalletKeys: fixedScriptWallet.RootWalletKeys | undefined,
-  replayProtection: ReplayProtectionKeys | undefined
+  replayProtection: ReplayProtectionKeys | undefined,
+  options?: { writeSignedWith?: boolean }
 ): utxolib.bitgo.UtxoPsbt;
 export function signAndVerifyPsbt(
   psbt: fixedScriptWallet.BitGoPsbt,
   signerKeychain: bip32.BIP32Interface | BIP32,
   rootWalletKeys: fixedScriptWallet.RootWalletKeys,
-  replayProtection: ReplayProtectionKeys
+  replayProtection: ReplayProtectionKeys,
+  options?: { writeSignedWith?: boolean }
 ): fixedScriptWallet.BitGoPsbt;
 export function signAndVerifyPsbt(
   psbt: utxolib.bitgo.UtxoPsbt | fixedScriptWallet.BitGoPsbt,
   signerKeychain: bip32.BIP32Interface | BIP32,
   rootWalletKeys: fixedScriptWallet.RootWalletKeys,
-  replayProtection: ReplayProtectionKeys
+  replayProtection: ReplayProtectionKeys,
+  options?: { writeSignedWith?: boolean }
 ): utxolib.bitgo.UtxoPsbt | fixedScriptWallet.BitGoPsbt;
 export function signAndVerifyPsbt(
   psbt: utxolib.bitgo.UtxoPsbt | fixedScriptWallet.BitGoPsbt,
   signerKeychain: bip32.BIP32Interface | BIP32,
   rootWalletKeys: fixedScriptWallet.RootWalletKeys | undefined,
-  replayProtection: ReplayProtectionKeys | undefined
+  replayProtection: ReplayProtectionKeys | undefined,
+  options: { writeSignedWith?: boolean } = {}
 ): utxolib.bitgo.UtxoPsbt | fixedScriptWallet.BitGoPsbt {
   if (psbt instanceof bitgo.UtxoPsbt) {
     return signAndVerifyPsbtUtxolib(psbt, toUtxolibBIP32(signerKeychain));
   }
   assert(rootWalletKeys, 'rootWalletKeys required for wasm-utxo signing');
   assert(replayProtection, 'replayProtection required for wasm-utxo signing');
-  return signAndVerifyPsbtWasm(psbt, signerKeychain, rootWalletKeys, replayProtection);
+  return signAndVerifyPsbtWasm(psbt, signerKeychain, rootWalletKeys, replayProtection, options);
 }
 
 export async function signTransaction<
@@ -69,6 +73,7 @@ export async function signTransaction<
     cosignerPub: string | undefined;
     /** When true (default), extract finalized PSBT to legacy transaction format. When false, return finalized PSBT. */
     extractTransaction?: boolean;
+    writeSignedWith?: boolean;
   }
 ): Promise<
   utxolib.bitgo.UtxoPsbt | utxolib.bitgo.UtxoTransaction<bigint | number> | fixedScriptWallet.BitGoPsbt | Buffer
@@ -115,6 +120,7 @@ export async function signTransaction<
         },
         signingStep: params.signingStep,
         walletId: params.walletId,
+        writeSignedWith: params.writeSignedWith,
       }
     );
     if (isLastSignature) {

modules/abstract-utxo/src/transaction/signTransaction.ts

@@ -79,6 +79,7 @@ export async function signTransaction<TNumber extends number | bigint>(
       pubs: params.pubs,
       cosignerPub: params.cosignerPub,
       extractTransaction: params.extractTransaction,
+      writeSignedWith: params.writeSignedWith,
     });
 
     // Convert half-signed PSBT to legacy format when the caller explicitly requested txFormat: 'legacy'

modules/abstract-utxo/test/unit/coins.ts

@@ -4,7 +4,7 @@ import * as utxolib from '@bitgo/utxo-lib';
 
 import { getMainnetCoinName, utxoCoinsMainnet, utxoCoinsTestnet } from '../../src/names';
 
-import { getNetworkForCoinName, getUtxoCoinForNetwork, utxoCoins } from './util';
+import { getNetworkForCoinName, getUtxoCoinForNetwork, getUtxoCoin, utxoCoins } from './util';
 
 describe('utxoCoins', function () {
   it('has expected chain/network values for items', function () {
@@ -76,6 +76,74 @@ describe('utxoCoins', function () {
     );
   });
 
+  describe('isValidAddress with allowLightning', function () {
+    const btc = getUtxoCoin('btc');
+    const tbtc = getUtxoCoin('tbtc');
+    const bch = getUtxoCoin('bch');
+
+    it('should reject node pubkeys and invoices without allowLightning', function () {
+      assert.strictEqual(
+        btc.isValidAddress('02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619'),
+        false
+      );
+      assert.strictEqual(btc.isValidAddress('lnbc1500n1pj0ggavpp5example'), false);
+    });
+
+    it('should accept node pubkeys with allowLightning', function () {
+      assert.strictEqual(
+        btc.isValidAddress('02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619', {
+          allowLightning: true,
+        }),
+        true
+      );
+      assert.strictEqual(
+        tbtc.isValidAddress('03e7156ae33b0a208d0744199163177e909e80176e55d97a2f221ede0f934dd9ad', {
+          allowLightning: true,
+        }),
+        true
+      );
+    });
+
+    it('should reject invalid node pubkeys even with allowLightning', function () {
+      // wrong prefix
+      assert.strictEqual(
+        btc.isValidAddress('04eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619', {
+          allowLightning: true,
+        }),
+        false
+      );
+      // too short
+      assert.strictEqual(
+        btc.isValidAddress('02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f28368', {
+          allowLightning: true,
+        }),
+        false
+      );
+    });
+
+    it('should accept bolt11 invoices with allowLightning', function () {
+      assert.strictEqual(btc.isValidAddress('lnbc1500n1pj0ggavpp5example', { allowLightning: true }), true);
+      assert.strictEqual(tbtc.isValidAddress('lntb1500n1pj0ggavpp5example', { allowLightning: true }), true);
+    });
+
+    it('should reject non-bolt11 strings with allowLightning', function () {
+      assert.strictEqual(btc.isValidAddress('lnxyz1500n1pj0ggavpp5example', { allowLightning: true }), false);
+      assert.strictEqual(btc.isValidAddress('not-an-address', { allowLightning: true }), false);
+    });
+
+    it('should still accept regular bitcoin addresses with allowLightning', function () {
+      assert.strictEqual(btc.isValidAddress('1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa', { allowLightning: true }), true);
+    });
+
+    it('should not accept lightning addresses for non-btc coins without allowLightning', function () {
+      assert.strictEqual(
+        bch.isValidAddress('02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619'),
+        false
+      );
+      assert.strictEqual(bch.isValidAddress('lnbc1500n1pj0ggavpp5example'), false);
+    });
+  });
+
   it('getMainnetCoinName returns correct mainnet coin name', function () {
     // Mainnet coins return themselves
     for (const coin of utxoCoinsMainnet) {