@bitgo-forks/avalanchejs 4.1.0-alpha.1

package/src/vms/utils/consolidateOutputs.spec.ts

@@ -0,0 +1,175 @@
+import { isStakeableLockOut, isTransferOut } from '../../utils';
+import {
+  getStakeableLockedTransferableOutForTest,
+  getTransferableOutForTest,
+} from '../../fixtures/transactions';
+
+import { consolidateOutputs } from './consolidateOutputs';
+
+describe('consolidateOutputs', () => {
+  it('consolidate eligible TransferOuts', () => {
+    // GIVEN
+    const a = getTransferableOutForTest(BigInt(100));
+    const b = getTransferableOutForTest(BigInt(50));
+    const c = getTransferableOutForTest(BigInt(50));
+
+    // WHEN
+    const consolidated = consolidateOutputs([a, b, c]);
+
+    // THEN
+    expect(consolidated.length).toEqual(1);
+    const conslidatedOutput = consolidated[0];
+    expect(conslidatedOutput.amount()).toEqual(BigInt(200));
+    expect(conslidatedOutput.getAssetId()).toEqual(a.getAssetId());
+    if (isTransferOut(conslidatedOutput.output) && isTransferOut(a.output)) {
+      expect(
+        conslidatedOutput.output.outputOwners.equals(a.output.outputOwners),
+      ).toBeTruthy();
+    } else {
+      fail(
+        'The consolidated output and first test output should both be transferOuts.',
+      );
+    }
+  });
+  it('consolidates eligible StakeableLockouts', () => {
+    // GIVEN
+    const a = getStakeableLockedTransferableOutForTest(BigInt(100), BigInt(0));
+    const b = getStakeableLockedTransferableOutForTest(BigInt(200), BigInt(0));
+    const c = getStakeableLockedTransferableOutForTest(BigInt(200), BigInt(0));
+
+    // WHEN
+    const consolidated = consolidateOutputs([a, b, c]);
+
+    // THEN
+    expect(consolidated.length).toEqual(1);
+    const conslidatedOutput = consolidated[0];
+    expect(conslidatedOutput.amount()).toEqual(BigInt(500));
+    expect(conslidatedOutput.getAssetId()).toEqual(a.getAssetId());
+    if (
+      isStakeableLockOut(conslidatedOutput.output) &&
+      isStakeableLockOut(a.output)
+    ) {
+      expect(conslidatedOutput.output.getLocktime()).toEqual(
+        a.output.getLocktime(),
+      );
+      expect(
+        conslidatedOutput.output
+          .getOutputOwners()
+          .equals(a.output.getOutputOwners()),
+      ).toBeTruthy();
+    } else {
+      fail(
+        'The consolidated output and first test output should both be stakeableLockouts.',
+      );
+    }
+  });
+  it('consolidates heterogenous inputs', () => {
+    // GIVEN
+    const tOutA = getTransferableOutForTest(BigInt(50));
+    const tOutB = getTransferableOutForTest(BigInt(100));
+    const stlOutA = getStakeableLockedTransferableOutForTest(
+      BigInt(100),
+      BigInt(0),
+    );
+    const stlOutB = getStakeableLockedTransferableOutForTest(
+      BigInt(200),
+      BigInt(0),
+    );
+
+    // WHEN
+    const consolidated = consolidateOutputs([tOutA, tOutB, stlOutA, stlOutB]);
+
+    // THEN
+    expect(consolidated.length).toEqual(2);
+    // THEN - TransferOut
+    expect(consolidated[0].amount()).toEqual(BigInt(150));
+    expect(consolidated[0].getAssetId()).toEqual(tOutA.getAssetId());
+    if (isTransferOut(consolidated[0].output) && isTransferOut(tOutA.output)) {
+      expect(
+        consolidated[0].output.outputOwners.equals(tOutA.output.outputOwners),
+      ).toBeTruthy();
+    } else {
+      fail(
+        'The consolidated output and first test output should both be transferOuts.',
+      );
+    }
+    // THEN - StakeableLockouts
+    expect(consolidated[1].amount()).toEqual(BigInt(300));
+    if (
+      isStakeableLockOut(consolidated[1].output) &&
+      isStakeableLockOut(stlOutA.output)
+    ) {
+      expect(consolidated[1].output.getLocktime()).toEqual(
+        stlOutA.output.getLocktime(),
+      );
+      expect(
+        consolidated[1].output
+          .getOutputOwners()
+          .equals(stlOutA.output.getOutputOwners()),
+      ).toBeTruthy();
+    } else {
+      fail(
+        'The consolidated output and third test output should both be stakeableLockouts.',
+      );
+    }
+  });
+  it('does not consolidate ineligible TransferOuts - locktime', () => {
+    // GIVEN
+    const a = getTransferableOutForTest(BigInt(50));
+    const b = getTransferableOutForTest(BigInt(50), BigInt(100));
+
+    // WHEN
+    const consolidated = consolidateOutputs([a, b]);
+
+    // THEN
+    expect(consolidated.length).toEqual(2);
+    expect(consolidated[0]).toBe(a);
+    expect(consolidated[1]).toBe(b);
+  });
+  it('does not consolidate ineligible TransferOuts - threshold', () => {
+    // GIVEN
+    const a = getTransferableOutForTest(BigInt(50), BigInt(100), 2);
+    const b = getTransferableOutForTest(BigInt(50), BigInt(100), 1);
+
+    // WHEN
+    const consolidated = consolidateOutputs([a, b]);
+
+    // THEN
+    expect(consolidated.length).toEqual(2);
+    expect(consolidated[0]).toBe(a);
+    expect(consolidated[1]).toBe(b);
+  });
+  it('does not consolidate ineligible StakeableLockouts - locktime', () => {
+    // GIVEN
+    const a = getStakeableLockedTransferableOutForTest(BigInt(100), BigInt(0));
+    const b = getStakeableLockedTransferableOutForTest(
+      BigInt(200),
+      BigInt(100),
+    );
+
+    // WHEN
+    const consolidated = consolidateOutputs([a, b]);
+
+    // THEN
+    expect(consolidated.length).toEqual(2);
+    expect(consolidated[0]).toBe(a);
+    expect(consolidated[1]).toBe(b);
+  });
+  it('handles empty arrays gracefully', () => {
+    // WHEN
+    const consolidated = consolidateOutputs([]);
+    // THEN
+    expect(consolidated.length).toEqual(0);
+  });
+  it('handles single output gracefully', () => {
+    // GIVEN
+    const a = getStakeableLockedTransferableOutForTest(BigInt(100), BigInt(0));
+
+    // WHEN
+    const consolidated = consolidateOutputs([a]);
+
+    // THEN
+    expect(consolidated.length).toEqual(1);
+    expect(consolidated[0]).toBe(a);
+  });
+});

package/src/vms/utils/consolidateOutputs.ts

@@ -0,0 +1,52 @@
+import { isStakeableLockOut, isTransferOut } from '../../utils';
+import {
+  TransferableOutput,
+  TransferOutput,
+  BigIntPr,
+  pvmSerial,
+} from '../../serializable';
+import { consolidate } from '../../utils/consolidate';
+
+const canCombine = (a: TransferableOutput, b: TransferableOutput) => {
+  return (
+    a.getAssetId() === b.getAssetId() &&
+    ((isStakeableLockOut(a.output) &&
+      isStakeableLockOut(b.output) &&
+      a.output.getStakeableLocktime() === b.output.getStakeableLocktime() &&
+      a.output.getOutputOwners().equals(b.output.getOutputOwners())) ||
+      (isTransferOut(a.output) &&
+        isTransferOut(b.output) &&
+        a.output.outputOwners.equals(b.output.outputOwners)))
+  );
+};
+
+const combine = (a: TransferableOutput, b: TransferableOutput) => {
+  if (isStakeableLockOut(a.output) && isStakeableLockOut(b.output)) {
+    return new TransferableOutput(
+      a.assetId,
+      new pvmSerial.StakeableLockOut(
+        a.output.lockTime,
+        new TransferOutput(
+          new BigIntPr(a.amount() + b.amount()),
+          a.output.getOutputOwners(),
+        ),
+      ),
+    );
+  } else if (isTransferOut(a.output) && isTransferOut(b.output)) {
+    return new TransferableOutput(
+      a.assetId,
+      new TransferOutput(
+        new BigIntPr(a.amount() + b.amount()),
+        a.output.outputOwners,
+      ),
+    );
+  } else {
+    throw new Error('Calling combine on incompatible TransferableOutputs');
+  }
+};
+
+export const consolidateOutputs = (
+  outputs: TransferableOutput[],
+): TransferableOutput[] => {
+  return consolidate(outputs, canCombine, combine);
+};