refactor(utxo-core): split Output and descriptor Output

Issue: BTC-1826

Author: OttoAllmendinger

modules/utxo-core/src/Output.ts

@@ -0,0 +1,72 @@
+export type Output<TValue = bigint> = {
+  script: Buffer;
+  value: TValue;
+};
+export type MaxOutput = Output<'max'>;
+type ValueBigInt = { value: bigint };
+type ValueMax = { value: 'max' };
+
+/**
+ * @return true if the output is a max output
+ */
+export function isMaxOutput<A extends ValueBigInt, B extends ValueMax>(output: A | B): output is B {
+  return output.value === 'max';
+}
+
+/**
+ * @return the max output if there is one
+ * @throws if there are multiple max outputs
+ */
+export function getMaxOutput<A extends ValueBigInt, B extends ValueMax>(outputs: (A | B)[]): B | undefined {
+  const max = outputs.filter(isMaxOutput<A, B>);
+  if (max.length === 0) {
+    return undefined;
+  }
+  if (max.length > 1) {
+    throw new Error('Multiple max outputs');
+  }
+  return max[0];
+}
+
+/**
+ * @return the sum of the outputs
+ */
+export function getOutputSum(outputs: ValueBigInt[]): bigint {
+  return outputs.reduce((sum, output) => sum + output.value, 0n);
+}
+
+/**
+ * @return the sum of the outputs that are not 'max'
+ */
+export function getFixedOutputSum(outputs: (ValueBigInt | ValueMax)[]): bigint {
+  return getOutputSum(outputs.filter((o): o is Output => !isMaxOutput(o)));
+}
+
+/**
+ * @param outputs
+ * @param params
+ * @return the outputs with the 'max' output replaced with the max amount
+ */
+export function toFixedOutputs<A extends ValueBigInt, B extends ValueMax>(
+  outputs: (A | B)[],
+  params: { maxAmount: bigint }
+): A[] {
+  // assert that there is at most one max output
+  const maxOutput = getMaxOutput<A, B>(outputs);
+  return outputs.map((output): A => {
+    if (isMaxOutput(output)) {
+      if (output !== maxOutput) {
+        throw new Error('illegal state');
+      }
+      return { ...output, value: params.maxAmount };
+    } else {
+      return output;
+    }
+  });
+}
+
+export type PrevOutput = {
+  hash: string;
+  index: number;
+  witnessUtxo: Output;
+};

modules/utxo-core/src/descriptor/Output.ts

@@ -1,77 +1,10 @@
 import { Descriptor } from '@bitgo/wasm-miniscript';
 
+import { getFixedOutputSum, MaxOutput, Output, PrevOutput } from '../Output';
+
 import { DescriptorMap } from './DescriptorMap';
 import { createScriptPubKeyFromDescriptor } from './address';
 
-export type Output<TValue = bigint> = {
-  script: Buffer;
-  value: TValue;
-};
-
-export type MaxOutput = Output<'max'>;
-
-type ValueBigInt = { value: bigint };
-type ValueMax = { value: 'max' };
-
-/**
- * @return true if the output is a max output
- */
-export function isMaxOutput<A extends ValueBigInt, B extends ValueMax>(output: A | B): output is B {
-  return output.value === 'max';
-}
-
-/**
- * @return the max output if there is one
- * @throws if there are multiple max outputs
- */
-export function getMaxOutput<A extends ValueBigInt, B extends ValueMax>(outputs: (A | B)[]): B | undefined {
-  const max = outputs.filter(isMaxOutput<A, B>);
-  if (max.length === 0) {
-    return undefined;
-  }
-  if (max.length > 1) {
-    throw new Error('Multiple max outputs');
-  }
-  return max[0];
-}
-
-/**
- * @return the sum of the outputs
- */
-export function getOutputSum(outputs: ValueBigInt[]): bigint {
-  return outputs.reduce((sum, output) => sum + output.value, 0n);
-}
-
-/**
- * @return the sum of the outputs that are not 'max'
- */
-export function getFixedOutputSum(outputs: (ValueBigInt | ValueMax)[]): bigint {
-  return getOutputSum(outputs.filter((o): o is Output => !isMaxOutput(o)));
-}
-
-/**
- * @param outputs
- * @param params
- * @return the outputs with the 'max' output replaced with the max amount
- */
-export function toFixedOutputs<A extends ValueBigInt, B extends ValueMax>(
-  outputs: (A | B)[],
-  params: { maxAmount: bigint }
-): A[] {
-  // assert that there is at most one max output
-  const maxOutput = getMaxOutput<A, B>(outputs);
-  return outputs.map((output): A => {
-    if (isMaxOutput(output)) {
-      if (output !== maxOutput) {
-        throw new Error('illegal state');
-      }
-      return { ...output, value: params.maxAmount };
-    } else {
-      return output;
-    }
-  });
-}
-
 export type WithDescriptor<T> = T & {
   descriptor: Descriptor;
 };
@@ -96,12 +29,6 @@ export function getExternalFixedAmount(outputs: WithOptDescriptor<Output | MaxOu
   return getFixedOutputSum(outputs.filter(isExternalOutput));
 }
 
-export type PrevOutput = {
-  hash: string;
-  index: number;
-  witnessUtxo: Output;
-};
-
 export type DescriptorWalletOutput = PrevOutput & {
   descriptorName: string;
   descriptorIndex: number;

modules/utxo-core/src/descriptor/index.ts

@@ -3,3 +3,6 @@ export * from './address';
 export * from './DescriptorMap';
 export * from './Output';
 export * from './VirtualSize';
+
+/** @deprecated - import from @bitgo/utxo-core directly instead */
+export * from '../Output';

modules/utxo-core/src/descriptor/psbt/createPsbt.ts

@@ -1,7 +1,8 @@
 import * as utxolib from '@bitgo/utxo-lib';
 import { Descriptor } from '@bitgo/wasm-miniscript';
 
-import { DerivedDescriptorWalletOutput, Output, WithOptDescriptor } from '../Output';
+import { DerivedDescriptorWalletOutput, WithOptDescriptor } from '../Output';
+import { Output } from '../../Output';
 
 import { toUtxoPsbt, toWrappedPsbt } from './wrap';
 import { assertSatisfiable } from './assertSatisfiable';

modules/utxo-core/src/index.ts

@@ -2,3 +2,4 @@ export * as bip65 from './bip65';
 export * as descriptor from './descriptor';
 export * as testutil from './testutil';
 export * from './dustThreshold';
+export * from './Output';

modules/utxo-core/test/Output.ts

@@ -0,0 +1,41 @@
+import * as assert from 'assert';
+
+import { getFixedOutputSum, getMaxOutput, getOutputSum, isMaxOutput, toFixedOutputs } from '../src';
+
+describe('Output', function () {
+  const oBigInt = { value: 1n };
+  const oBigInt2 = { value: 2n };
+  const oMax = { value: 'max' } as const;
+
+  it('getMaxOutput returns expected values', function () {
+    assert.strictEqual(getMaxOutput([oBigInt]), undefined);
+    assert.strictEqual(getMaxOutput([oBigInt, oBigInt]), undefined);
+    assert.strictEqual(getMaxOutput([oBigInt, oMax]), oMax);
+    assert.throws(() => getMaxOutput([oMax, oMax]), /Multiple max outputs/);
+  });
+
+  it('isMaxOutput correctly identifies max outputs', function () {
+    assert.strictEqual(isMaxOutput(oBigInt), false);
+    assert.strictEqual(isMaxOutput(oMax), true);
+  });
+
+  it('getOutputSum calculates sum correctly', function () {
+    assert.strictEqual(getOutputSum([]), 0n);
+    assert.strictEqual(getOutputSum([oBigInt]), 1n);
+    assert.strictEqual(getOutputSum([oBigInt, oBigInt2]), 3n);
+  });
+
+  it('getFixedOutputSum handles mixed outputs', function () {
+    assert.strictEqual(getFixedOutputSum([]), 0n);
+    assert.strictEqual(getFixedOutputSum([oBigInt]), 1n);
+    assert.strictEqual(getFixedOutputSum([oBigInt, oMax]), 1n);
+    assert.strictEqual(getFixedOutputSum([oBigInt, oBigInt2, oMax]), 3n);
+  });
+
+  it('toFixedOutputs converts max outputs correctly', function () {
+    const maxAmount = 10n;
+    assert.deepStrictEqual(toFixedOutputs([oBigInt], { maxAmount }), [oBigInt]);
+    assert.deepStrictEqual(toFixedOutputs([oMax], { maxAmount }), [{ ...oMax, value: maxAmount }]);
+    assert.throws(() => toFixedOutputs([oMax, oMax], { maxAmount }), /Multiple max outputs/);
+  });
+});

modules/utxo-core/test/descriptor/Output.ts

@@ -1,55 +1,12 @@
-import * as assert from 'assert';
+import assert from 'assert';
 
 import { Descriptor } from '@bitgo/wasm-miniscript';
 
-import {
-  getMaxOutput,
-  isMaxOutput,
-  getOutputSum,
-  getFixedOutputSum,
-  toFixedOutputs,
-  isInternalOutput,
-  isExternalOutput,
-} from '../../src/descriptor';
+import { isExternalOutput, isInternalOutput } from '../../src/descriptor';
 
-describe('Output', function () {
-  const oBigInt = { value: 1n };
-  const oBigInt2 = { value: 2n };
-  const oMax = { value: 'max' } as const;
+describe('decscriptor.Output', function () {
   const mockDescriptor = {} as Descriptor;
 
-  it('getMaxOutput returns expected values', function () {
-    assert.strictEqual(getMaxOutput([oBigInt]), undefined);
-    assert.strictEqual(getMaxOutput([oBigInt, oBigInt]), undefined);
-    assert.strictEqual(getMaxOutput([oBigInt, oMax]), oMax);
-    assert.throws(() => getMaxOutput([oMax, oMax]), /Multiple max outputs/);
-  });
-
-  it('isMaxOutput correctly identifies max outputs', function () {
-    assert.strictEqual(isMaxOutput(oBigInt), false);
-    assert.strictEqual(isMaxOutput(oMax), true);
-  });
-
-  it('getOutputSum calculates sum correctly', function () {
-    assert.strictEqual(getOutputSum([]), 0n);
-    assert.strictEqual(getOutputSum([oBigInt]), 1n);
-    assert.strictEqual(getOutputSum([oBigInt, oBigInt2]), 3n);
-  });
-
-  it('getFixedOutputSum handles mixed outputs', function () {
-    assert.strictEqual(getFixedOutputSum([]), 0n);
-    assert.strictEqual(getFixedOutputSum([oBigInt]), 1n);
-    assert.strictEqual(getFixedOutputSum([oBigInt, oMax]), 1n);
-    assert.strictEqual(getFixedOutputSum([oBigInt, oBigInt2, oMax]), 3n);
-  });
-
-  it('toFixedOutputs converts max outputs correctly', function () {
-    const maxAmount = 10n;
-    assert.deepStrictEqual(toFixedOutputs([oBigInt], { maxAmount }), [oBigInt]);
-    assert.deepStrictEqual(toFixedOutputs([oMax], { maxAmount }), [{ ...oMax, value: maxAmount }]);
-    assert.throws(() => toFixedOutputs([oMax, oMax], { maxAmount }), /Multiple max outputs/);
-  });
-
   it('isInternalOutput correctly identifies internal outputs', function () {
     const internalOutput = { value: 1n, descriptor: mockDescriptor };
     const externalOutput = { value: 1n };