feat(abstract-utxo): add support for 'max' value parse.ts

Issue: BTC-1697

Author: OttoAllmendinger

modules/abstract-utxo/src/transaction/descriptor/parse.ts

@@ -17,24 +17,28 @@ import { fromExtendedAddressFormatToScript, toExtendedAddressFormat } from '../r
 
 import { outputDifferencesWithExpected, OutputDifferenceWithExpected } from './outputDifference';
 
-function toParsedOutput(recipient: ITransactionRecipient, network: utxolib.Network): ParsedOutput {
+export type RecipientOutput = Omit<ParsedOutput, 'value'> & {
+  value: bigint | 'max';
+};
+
+function toRecipientOutput(recipient: ITransactionRecipient, network: utxolib.Network): RecipientOutput {
   return {
     address: recipient.address,
-    value: BigInt(recipient.amount),
+    value: recipient.amount === 'max' ? 'max' : BigInt(recipient.amount),
     script: fromExtendedAddressFormatToScript(recipient.address, network),
   };
 }
 
 // TODO(BTC-1697): allow outputs with `value: 'max'` here
-type ParsedOutputs = OutputDifferenceWithExpected<ParsedOutput, ParsedOutput> & {
+type ParsedOutputs = OutputDifferenceWithExpected<ParsedOutput, RecipientOutput> & {
   outputs: ParsedOutput[];
   changeOutputs: ParsedOutput[];
 };
 
 function parseOutputsWithPsbt(
   psbt: utxolib.bitgo.UtxoPsbt,
   descriptorMap: coreDescriptors.DescriptorMap,
-  recipientOutputs: ParsedOutput[]
+  recipientOutputs: RecipientOutput[]
 ): ParsedOutputs {
   const parsed = coreDescriptors.parse(psbt, descriptorMap, psbt.network);
   const externalOutputs = parsed.outputs.filter((o) => o.scriptId === undefined);
@@ -51,17 +55,22 @@ function sumValues(arr: { value: bigint }[]): bigint {
   return arr.reduce((sum, e) => sum + e.value, BigInt(0));
 }
 
-function toBaseOutputs(outputs: ParsedOutput[], network: utxolib.Network): BaseOutput<bigint>[] {
+function toBaseOutputs(outputs: ParsedOutput[], network: utxolib.Network): BaseOutput<bigint>[];
+function toBaseOutputs(outputs: RecipientOutput[], network: utxolib.Network): BaseOutput<bigint | 'max'>[];
+function toBaseOutputs(
+  outputs: (ParsedOutput | RecipientOutput)[],
+  network: utxolib.Network
+): BaseOutput<bigint | 'max'>[] {
   return outputs.map(
-    (o): BaseOutput<bigint> => ({
+    (o): BaseOutput<bigint | 'max'> => ({
       address: toExtendedAddressFormat(o.script, network),
-      amount: BigInt(o.value),
+      amount: o.value === 'max' ? 'max' : BigInt(o.value),
       external: o.scriptId === undefined,
     })
   );
 }
 
-export type ParsedOutputsBigInt = BaseParsedTransactionOutputs<bigint, BaseOutput<bigint>>;
+export type ParsedOutputsBigInt = BaseParsedTransactionOutputs<bigint, BaseOutput<bigint | 'max'>>;
 
 function toBaseParsedTransactionOutputs(
   { outputs, changeOutputs, explicitExternalOutputs, implicitExternalOutputs, missingOutputs }: ParsedOutputs,
@@ -88,15 +97,15 @@ export function toBaseParsedTransactionOutputsFromPsbt(
     parseOutputsWithPsbt(
       psbt,
       descriptorMap,
-      recipients.map((r) => toParsedOutput(r, psbt.network))
+      recipients.map((r) => toRecipientOutput(r, psbt.network))
     ),
     network
   );
 }
 
 export type ParsedDescriptorTransaction<TAmount extends number | bigint> = BaseParsedTransaction<
   TAmount,
-  BaseOutput<TAmount>
+  BaseOutput<TAmount | 'max'>
 >;
 
 export function parse(

modules/abstract-utxo/src/transaction/descriptor/parseToAmountType.ts

@@ -6,6 +6,9 @@ import { parse, ParsedDescriptorTransaction } from './parse';
 type AmountType = 'number' | 'bigint' | 'string';
 
 export function toAmountType(v: number | bigint | string, t: AmountType): number | bigint | string {
+  if (v === 'max') {
+    return v;
+  }
   switch (t) {
     case 'number':
       return Number(v);
@@ -22,7 +25,7 @@ type AmountTypeOptions = {
 };
 
 function baseOutputToTNumber<TAmount extends number | bigint>(
-  output: BaseOutput<bigint>,
+  output: BaseOutput<bigint | 'max'>,
   amountType: AmountType
 ): BaseOutput<TAmount> {
   return {

modules/abstract-utxo/src/transaction/descriptor/verifyTransaction.ts

@@ -13,13 +13,13 @@ export class ValidationError extends Error {
 }
 
 export class ErrorMissingOutputs extends ValidationError {
-  constructor(public missingOutputs: BaseOutput<bigint>[]) {
+  constructor(public missingOutputs: BaseOutput<bigint | 'max'>[]) {
     super(`missing outputs (count=${missingOutputs.length})`);
   }
 }
 
 export class ErrorImplicitExternalOutputs extends ValidationError {
-  constructor(public implicitExternalOutputs: BaseOutput<bigint>[]) {
+  constructor(public implicitExternalOutputs: BaseOutput<bigint | 'max'>[]) {
     super(`unexpected implicit external outputs (count=${implicitExternalOutputs.length})`);
   }
 }
@@ -31,7 +31,7 @@ export class AggregateValidationError extends ValidationError {
 }
 
 export function assertExpectedOutputDifference(
-  parsedOutputs: BaseParsedTransactionOutputs<bigint, BaseOutput<bigint>>
+  parsedOutputs: BaseParsedTransactionOutputs<bigint, BaseOutput<bigint | 'max'>>
 ): void {
   const errors: ValidationError[] = [];
   if (parsedOutputs.missingOutputs.length > 0) {

modules/abstract-utxo/test/transaction/descriptor/parse.ts

@@ -1,7 +1,5 @@
 import assert from 'assert';
 
-import * as utxolib from '@bitgo/utxo-lib';
-
 import { mockPsbtDefaultWithDescriptorTemplate } from '../../core/descriptor/psbt/mock.utils';
 import { ParsedOutputsBigInt, toBaseParsedTransactionOutputsFromPsbt } from '../../../src/transaction/descriptor/parse';
 import { getDefaultXPubs, getDescriptorMap } from '../../core/descriptor/descriptor.utils';
@@ -17,26 +15,38 @@ import { BaseOutput } from '../../../src';
 
 import { assertEqualFixture } from './fixtures.utils';
 
-function toBaseOutput<TNumber>(output: utxolib.PsbtTxOutput, amountType: 'bigint' | 'string'): BaseOutput<TNumber> {
+type OutputWithValue<T = number | bigint | string> = {
+  address?: string;
+  value: T;
+};
+
+function toBaseOutput<TNumber>(output: OutputWithValue, amountType: 'bigint' | 'string'): BaseOutput<TNumber> {
   assert(output.address);
   return {
     address: output.address,
     amount: toAmountType(output.value, amountType) as TNumber,
   };
 }
 
-function toBaseOutputBigInt(output: utxolib.PsbtTxOutput): BaseOutput<bigint> {
+function toBaseOutputBigInt(output: OutputWithValue): BaseOutput<bigint> {
   return toBaseOutput(output, 'bigint');
 }
 
-function toBaseOutputString(output: utxolib.PsbtTxOutput): BaseOutput<string> {
+function toBaseOutputString(output: OutputWithValue): BaseOutput<string> {
   return toBaseOutput(output, 'string');
 }
 
+function toMaxOutput(output: OutputWithValue): OutputWithValue<'max'> {
+  return {
+    ...output,
+    value: 'max',
+  };
+}
+
 describe('parse', function () {
   const psbt = mockPsbtDefaultWithDescriptorTemplate('Wsh2Of3');
 
-  function getBaseParsedTransaction(recipients: utxolib.PsbtTxOutput[]): ParsedOutputsBigInt {
+  function getBaseParsedTransaction(recipients: OutputWithValue[]): ParsedOutputsBigInt {
     return toBaseParsedTransactionOutputsFromPsbt(
       psbt,
       getDescriptorMap('Wsh2Of3', getDefaultXPubs('a')),
@@ -49,6 +59,11 @@ describe('parse', function () {
     it('should return the correct BaseParsedTransactionOutputs', async function () {
       await assertEqualFixture('parseWithoutRecipients.json', toPlainObject(getBaseParsedTransaction([])));
       await assertEqualFixture('parseWithRecipient.json', toPlainObject(getBaseParsedTransaction([psbt.txOutputs[0]])));
+      await assertEqualFixture(
+        'parseWithRecipient.json',
+        // max recipient: ignore actual value
+        toPlainObject(getBaseParsedTransaction([toMaxOutput(psbt.txOutputs[0])]))
+      );
     });
 
     function assertEqualValidationError(actual: unknown, expected: AggregateValidationError) {
@@ -88,6 +103,14 @@ describe('parse', function () {
           new ErrorImplicitExternalOutputs([{ ...toBaseOutputBigInt(psbt.txOutputs[0]), external: true }]),
         ])
       );
+
+      assertValidationError(
+        () => assertExpectedOutputDifference(getBaseParsedTransaction([toMaxOutput(psbt.txOutputs[1])])),
+        new AggregateValidationError([
+          new ErrorMissingOutputs([{ ...toBaseOutputBigInt(toMaxOutput(psbt.txOutputs[1])), external: true }]),
+          new ErrorImplicitExternalOutputs([{ ...toBaseOutputBigInt(psbt.txOutputs[0]), external: true }]),
+        ])
+      );
     });
   });
 });