chore(utxo-lib): removed functions as class methods and became util func

christopher-fong · christopher-fong · commit 4502d214e18c · 2025-06-13T10:02:44.000-04:00
TICKET: BTC-2183
diff --git a/modules/utxo-lib/src/bitgo/Musig2.ts b/modules/utxo-lib/src/bitgo/Musig2.ts
@@ -12,12 +12,8 @@ import { Tuple } from './types';
 import { calculateTapTweak, tapTweakPubkey } from '../taproot';
 import { Transaction } from '../index';
 import { PsbtInput } from 'bip174/src/lib/interfaces';
-import {
-  getPsbtInputProprietaryKeyVals,
-  ProprietaryKeySubtype,
-  ProprietaryKeyValue,
-  PSBT_PROPRIETARY_IDENTIFIER,
-} from './PsbtUtil';
+import { getPsbtInputProprietaryKeyVals, ProprietaryKeySubtype, PSBT_PROPRIETARY_IDENTIFIER } from './PsbtUtil';
+import { ProprietaryKeyValue } from './ProprietaryKeyValUtils';
 
 /**
  *  Participant key value object.
diff --git a/modules/utxo-lib/src/bitgo/ProprietaryKeyValUtils.ts b/modules/utxo-lib/src/bitgo/ProprietaryKeyValUtils.ts
@@ -0,0 +1,116 @@
+import { KeyValue } from 'bip174/src/lib/interfaces';
+import { decodeProprietaryKey, encodeProprietaryKey, ProprietaryKey } from 'bip174/src/lib/proprietaryKeyVal';
+import { UtxoPsbt } from './UtxoPsbt';
+
+/**
+ * Psbt proprietary keydata object search fields.
+ * <compact size uint identifier length> <bytes identifier> <compact size uint subtype> <bytes subkeydata>
+ */
+export interface ProprietaryKeySearch {
+  identifier: string;
+  subtype?: number;
+  keydata?: Buffer;
+  identifierEncoding?: BufferEncoding;
+}
+/**
+ * Psbt proprietary keydata object.
+ * <compact size uint identifier length> <bytes identifier> <compact size uint subtype> <bytes subkeydata>
+ * => <bytes valuedata>
+ */
+export interface ProprietaryKeyValue {
+  key: ProprietaryKey;
+  value: Buffer;
+}
+
+export interface WithUnknownKeyValues {
+  unknownKeyVals?: KeyValue[];
+}
+
+export function getProprietaryKeyValuesFromUnknownKeyValues(
+  psbtField: WithUnknownKeyValues,
+  keySearch?: ProprietaryKeySearch
+): ProprietaryKeyValue[] {
+  if (!psbtField.unknownKeyVals?.length) {
+    return [];
+  }
+
+  if (keySearch && keySearch.subtype === undefined && Buffer.isBuffer(keySearch.keydata)) {
+    throw new Error('invalid proprietary key search filter combination. subtype is required');
+  }
+  const keyVals = psbtField.unknownKeyVals.map(({ key, value }, i) => {
+    return { key: decodeProprietaryKey(key), value };
+  });
+  return keyVals.filter((keyVal) => {
+    return (
+      keySearch === undefined ||
+      (keySearch.identifier === keyVal.key.identifier &&
+        (keySearch.subtype === undefined ||
+          (keySearch.subtype === keyVal.key.subtype &&
+            (!Buffer.isBuffer(keySearch.keydata) || keySearch.keydata.equals(keyVal.key.keydata)))))
+    );
+  });
+}
+
+export function deleteProprietaryKeyValuesFromUnknownKeyValues(
+  psbtField: WithUnknownKeyValues,
+  keysToDelete?: ProprietaryKeySearch
+): void {
+  if (!psbtField.unknownKeyVals?.length) {
+    return;
+  }
+
+  if (keysToDelete && keysToDelete.subtype === undefined && Buffer.isBuffer(keysToDelete.keydata)) {
+    throw new Error('invalid proprietary key search filter combination. subtype is required');
+  }
+  psbtField.unknownKeyVals = psbtField.unknownKeyVals.filter((keyValue, i) => {
+    const key = decodeProprietaryKey(keyValue.key);
+    return !(
+      keysToDelete === undefined ||
+      (keysToDelete.identifier === key.identifier &&
+        (keysToDelete.subtype === undefined ||
+          (keysToDelete.subtype === key.subtype &&
+            (!Buffer.isBuffer(keysToDelete.keydata) || keysToDelete.keydata.equals(key.keydata)))))
+    );
+  });
+}
+
+export function updateProprietaryKeyValuesToUnknownKeyValues(
+  keyValueData: ProprietaryKeyValue,
+  psbtField: WithUnknownKeyValues
+): void {
+  if (!psbtField.unknownKeyVals?.length) {
+    return;
+  }
+
+  const key = encodeProprietaryKey(keyValueData.key);
+  const { value } = keyValueData;
+  const ukvIndex = psbtField.unknownKeyVals.findIndex((ukv) => ukv.key.equals(key));
+  if (ukvIndex <= -1) {
+    throw new Error(`The Key-Value pair does not exist within the PSBT.`);
+  }
+  psbtField.unknownKeyVals[ukvIndex] = { key, value };
+}
+
+export function addProprietaryKeyValuesToUnknownKeyValues(
+  psbt: UtxoPsbt,
+  entry: string,
+  index: number,
+  keyValueData: ProprietaryKeyValue
+): void {
+  if (index < 0) {
+    throw new Error('Not a valid index within the PSBT to add proprietary key value.');
+  }
+  if (entry === 'input') {
+    psbt.addUnknownKeyValToInput(index, {
+      key: encodeProprietaryKey(keyValueData.key),
+      value: keyValueData.value,
+    });
+  } else if (entry === 'output') {
+    psbt.addUnknownKeyValToOutput(index, {
+      key: encodeProprietaryKey(keyValueData.key),
+      value: keyValueData.value,
+    });
+  } else {
+    throw new Error("Not a valid PSBT entry, only valid for 'input' or 'output'.");
+  }
+}
diff --git a/modules/utxo-lib/src/bitgo/PsbtUtil.ts b/modules/utxo-lib/src/bitgo/PsbtUtil.ts
@@ -1,7 +1,11 @@
-import { ProprietaryKey } from 'bip174/src/lib/proprietaryKeyVal';
 import { PsbtInput, PsbtOutput } from 'bip174/src/lib/interfaces';
 import { Psbt } from 'bitcoinjs-lib/src/psbt';
-import { getProprietaryKeyValuesFromUnknownKeyValues } from './psbt/ProprietaryKeyValUtils';
+
+import {
+  getProprietaryKeyValuesFromUnknownKeyValues,
+  ProprietaryKeySearch,
+  ProprietaryKeyValue,
+} from './ProprietaryKeyValUtils';
 
 /**
  * bitgo proprietary key identifier
@@ -18,27 +22,6 @@ export enum ProprietaryKeySubtype {
   MUSIG2_PARTIAL_SIG = 0x03,
 }
 
-/**
- * Psbt proprietary keydata object.
- * <compact size uint identifier length> <bytes identifier> <compact size uint subtype> <bytes subkeydata>
- * => <bytes valuedata>
- */
-export interface ProprietaryKeyValue {
-  key: ProprietaryKey;
-  value: Buffer;
-}
-
-/**
- * Psbt proprietary keydata object search fields.
- * <compact size uint identifier length> <bytes identifier> <compact size uint subtype> <bytes subkeydata>
- */
-export interface ProprietaryKeySearch {
-  identifier: string;
-  subtype?: number;
-  keydata?: Buffer;
-  identifierEncoding?: BufferEncoding;
-}
-
 /**
  * Search any data from psbt proprietary key value against keydata.
  * Default identifierEncoding is utf-8 for identifier.
@@ -50,7 +33,7 @@ export function getPsbtInputProprietaryKeyVals(
   if (!input.unknownKeyVals?.length) {
     return [];
   }
-  return getProprietaryKeyValuesFromUnknownKeyValues(input.unknownKeyVals, keySearch);
+  return getProprietaryKeyValuesFromUnknownKeyValues(input, keySearch);
 }
 
 export function getPsbtOutputProprietaryKeyVals(
@@ -60,7 +43,7 @@ export function getPsbtOutputProprietaryKeyVals(
   if (!output.unknownKeyVals?.length) {
     return [];
   }
-  return getProprietaryKeyValuesFromUnknownKeyValues(output.unknownKeyVals, keySearch);
+  return getProprietaryKeyValuesFromUnknownKeyValues(output, keySearch);
 }
 
 /**
@@ -79,12 +62,14 @@ export function getPsbtInputSignatureCount(input: PsbtInput): number {
     }).length
   );
 }
+
 /**
  * @return true iff PSBT input is finalized
  */
 export function isPsbtInputFinalized(input: PsbtInput): boolean {
   return Buffer.isBuffer(input.finalScriptSig) || Buffer.isBuffer(input.finalScriptWitness);
 }
+
 /**
  * @return true iff data starts with magic PSBT byte sequence
  * @param data byte array or hex string
@@ -100,6 +85,7 @@ export function isPsbt(data: Buffer | string): boolean {
   }
   return 5 <= data.length && data.readUInt32BE(0) === 0x70736274 && data.readUInt8(4) === 0xff;
 }
+
 /**
  * First checks if the input is already a buffer that starts with the magic PSBT byte sequence.
  * If not, it checks if the input is a base64- or hex-encoded string that starts with PSBT header.
@@ -117,9 +103,11 @@ export function toPsbtBuffer(data: Buffer | string): Buffer {
     if (isPsbt(data)) {
       return data;
     }
+
     // we could be dealing with a buffer that could be a hex or base64 encoded psbt
     data = data.toString('ascii');
   }
+
   if (typeof data === 'string') {
     const encodings = ['hex', 'base64'] as const;
     for (const encoding of encodings) {
@@ -133,10 +121,13 @@ export function toPsbtBuffer(data: Buffer | string): Buffer {
         return buffer;
       }
     }
+
     throw new Error(`data is not in any of the following formats: ${encodings.join(', ')}`);
   }
+
   throw new Error('data must be a buffer or a string');
 }
+
 /**
  * This function allows signing or validating a psbt with non-segwit inputs those do not contain nonWitnessUtxo.
  */
diff --git a/modules/utxo-lib/src/bitgo/UtxoPsbt.ts b/modules/utxo-lib/src/bitgo/UtxoPsbt.ts
@@ -7,7 +7,7 @@ import {
   Transaction as ITransaction,
   TransactionFromBuffer,
 } from 'bip174/src/lib/interfaces';
-import { checkForInput, checkForOutput } from 'bip174/src/lib/utils';
+import { checkForInput } from 'bip174/src/lib/utils';
 import { BufferWriter, varuint } from 'bitcoinjs-lib/src/bufferutils';
 import { SessionKey } from '@brandonblack/musig';
 import { BIP32Factory, BIP32Interface } from 'bip32';
@@ -57,17 +57,10 @@ import { getTaprootOutputKey } from '../taproot';
 import {
   getPsbtInputProprietaryKeyVals,
   getPsbtInputSignatureCount,
-  getPsbtOutputProprietaryKeyVals,
-  ProprietaryKeySearch,
   ProprietaryKeySubtype,
-  ProprietaryKeyValue,
   PSBT_PROPRIETARY_IDENTIFIER,
 } from './PsbtUtil';
-import {
-  deleteProprietaryKeyValuesFromUnknownKeyValues,
-  UnknownKeyValsType,
-  updateProprietaryKeyValuesToUnknownKeyValues,
-} from './psbt/ProprietaryKeyValUtils';
+import { ProprietaryKeySearch, ProprietaryKeyValue } from './ProprietaryKeyValUtils';
 
 type SignatureParams = {
   /** When true, and add the second (last) nonce and signature for a taproot key
@@ -1158,96 +1151,6 @@ export class UtxoPsbt<Tx extends UtxoTransaction<bigint> = UtxoTransaction<bigin
     return this;
   }
 
-  addProprietaryKeyValues(type: UnknownKeyValsType, index: number, keyValueData: ProprietaryKeyValue): this {
-    switch (type) {
-      case 'input':
-        const input = checkForInput(this.data.inputs, index);
-        assert(input);
-        return this.addUnknownKeyValToInput(index, {
-          key: encodeProprietaryKey(keyValueData.key),
-          value: keyValueData.value,
-        });
-      case 'output':
-        const output = checkForOutput(this.data.outputs, index);
-        assert(output);
-        return this.addUnknownKeyValToOutput(index, {
-          key: encodeProprietaryKey(keyValueData.key),
-          value: keyValueData.value,
-        });
-      default:
-        throw new Error('There is no such type, something went wrong.');
-    }
-  }
-
-  addOrUpdateProprietaryKeyValues(type: UnknownKeyValsType, index: number, keyValueData: ProprietaryKeyValue): this {
-    const key = encodeProprietaryKey(keyValueData.key);
-    const { value } = keyValueData;
-    switch (type) {
-      case 'output':
-        const output = checkForOutput(this.data.outputs, index);
-        assert(output);
-        if (output.unknownKeyVals?.length) {
-          updateProprietaryKeyValuesToUnknownKeyValues(keyValueData, output.unknownKeyVals);
-          return this;
-        }
-        return this.addUnknownKeyValToOutput(index, {
-          key,
-          value,
-        });
-      case 'input':
-        const input = checkForInput(this.data.inputs, index);
-        assert(input);
-        if (input.unknownKeyVals?.length) {
-          updateProprietaryKeyValuesToUnknownKeyValues(keyValueData, input.unknownKeyVals);
-          return this;
-        }
-        return this.addUnknownKeyValToInput(index, {
-          key,
-          value,
-        });
-      default:
-        throw new Error('There is no such type. Something went wrong.');
-    }
-  }
-
-  getProprietaryKeyValues(
-    type: UnknownKeyValsType,
-    index: number,
-    keySearch?: ProprietaryKeySearch
-  ): ProprietaryKeyValue[] {
-    switch (type) {
-      case 'input':
-        const input = checkForInput(this.data.inputs, index);
-        return getPsbtInputProprietaryKeyVals(input, keySearch);
-      case 'output':
-        const output = checkForOutput(this.data.outputs, index);
-        return getPsbtOutputProprietaryKeyVals(output, keySearch);
-      default:
-        throw new Error('There is no such type. Something went wrong.');
-    }
-  }
-
-  deleteProprietaryKeyValues(type: UnknownKeyValsType, index: number, keysToDelete?: ProprietaryKeySearch): this {
-    switch (type) {
-      case 'input':
-        const input = checkForInput(this.data.inputs, index);
-        if (!input.unknownKeyVals?.length) {
-          return this;
-        }
-        input.unknownKeyVals = deleteProprietaryKeyValuesFromUnknownKeyValues(input.unknownKeyVals, keysToDelete);
-        return this;
-      case 'output':
-        const output = checkForOutput(this.data.outputs, index);
-        if (!output.unknownKeyVals?.length) {
-          return this;
-        }
-        output.unknownKeyVals = deleteProprietaryKeyValuesFromUnknownKeyValues(output.unknownKeyVals, keysToDelete);
-        return this;
-      default:
-        throw new Error('There is no such type. Something went wrong.');
-    }
-  }
-
   private createMusig2NonceForInput(
     inputIndex: number,
     keyPair: BIP32Interface,
diff --git a/modules/utxo-lib/src/bitgo/index.ts b/modules/utxo-lib/src/bitgo/index.ts
@@ -21,6 +21,7 @@ export * from './zcash';
 export * from './tnumber';
 export * from './litecoin';
 export * from './PsbtUtil';
+export * from './ProprietaryKeyValUtils';
 
 import { PsbtInput } from 'bip174/src/lib/interfaces';
 /**
diff --git a/modules/utxo-lib/src/bitgo/psbt/ProprietaryKeyValUtils.ts b/modules/utxo-lib/src/bitgo/psbt/ProprietaryKeyValUtils.ts
diff --git a/modules/utxo-lib/test/bitgo/psbt/ProprietaryKeyVals.ts b/modules/utxo-lib/test/bitgo/psbt/ProprietaryKeyVals.ts
