@bitgo-forks/avalanchejs 4.1.0-alpha.1

package/src/utils/builderUtils.ts

@@ -0,0 +1,46 @@
+import { TransferableInput } from '../serializable/avax';
+import type { Utxo } from '../serializable/avax/utxo';
+import { addressesFromBytes } from './addressesFromBytes';
+import { matchOwners } from './matchOwners';
+import { isTransferOut } from './typeGuards';
+
+type GetImportedInputsFromUtxosOutput = {
+  importedInputs: TransferableInput[];
+  inputUTXOs: Utxo[];
+  importedAmounts: Record<string, bigint>;
+};
+
+export const getImportedInputsFromUtxos = (
+  utxos: Utxo[],
+  fromAddressesBytes: Uint8Array[],
+  minIssuanceTime: bigint,
+): GetImportedInputsFromUtxosOutput => {
+  const fromAddresses = addressesFromBytes(fromAddressesBytes);
+  const outputs: GetImportedInputsFromUtxosOutput = {
+    importedInputs: [],
+    inputUTXOs: [],
+    importedAmounts: {},
+  };
+
+  return utxos.reduce((agg, utxo): GetImportedInputsFromUtxosOutput => {
+    const { importedInputs, inputUTXOs, importedAmounts } = agg;
+    const out = utxo.output;
+    if (!isTransferOut(out)) return agg;
+
+    const sigData = matchOwners(
+      out.outputOwners,
+      fromAddresses,
+      minIssuanceTime,
+    );
+
+    if (!sigData) return agg;
+
+    importedInputs.push(
+      TransferableInput.fromUtxoAndSigindicies(utxo, sigData.sigIndicies),
+    );
+    inputUTXOs.push(utxo);
+    importedAmounts[utxo.getAssetId()] =
+      (importedAmounts[utxo.getAssetId()] ?? 0n) + out.amount();
+    return agg;
+  }, outputs);
+};

package/src/utils/bytesCompare.spec.ts

@@ -0,0 +1,58 @@
+import { bytesCompare, bytesEqual } from './bytesCompare';
+
+describe('bytesCompare', () => {
+  it('compares bytes', () => {
+    const specs = [
+      {
+        bytes1: new Uint8Array([0, 0, 0, 0, 0, 1]),
+        bytes2: new Uint8Array([0, 0, 0, 0, 0, 0]),
+        expected: 1,
+      },
+      {
+        bytes1: new Uint8Array([0, 0, 0, 0, 0, 0]),
+        bytes2: new Uint8Array([0, 0, 0, 0, 0, 1]),
+        expected: -1,
+      },
+      {
+        bytes1: new Uint8Array([0, 0, 0, 0, 0, 1]),
+        bytes2: new Uint8Array([1, 0, 0, 0, 0, 0]),
+        expected: -1,
+      },
+      {
+        bytes1: new Uint8Array([0, 0, 0, 0, 0, 0]),
+        bytes2: new Uint8Array([0, 0, 0, 0, 0, 0]),
+        expected: 0,
+      },
+    ];
+
+    specs.forEach(({ bytes1, bytes2, expected }) => {
+      expect(bytesCompare(bytes1, bytes2)).toBe(expected);
+    });
+  });
+});
+
+describe('bytesEqual', () => {
+  it('equal bytes', () => {
+    const specs = [
+      {
+        bytes1: new Uint8Array([0, 0, 0, 0, 0, 0]),
+        bytes2: new Uint8Array([0, 0, 0, 0, 0, 0]),
+        expected: true,
+      },
+      {
+        bytes1: new Uint8Array([0, 0, 0, 0, 0, 0]),
+        bytes2: new Uint8Array([0, 0, 0, 0, 0, 1]),
+        expected: false,
+      },
+      {
+        bytes1: new Uint8Array([0, 0, 0, 0, 0]),
+        bytes2: new Uint8Array([0, 0, 0, 0, 0, 1]),
+        expected: false,
+      },
+    ];
+
+    specs.forEach(({ bytes1, bytes2, expected }) => {
+      expect(bytesEqual(bytes1, bytes2)).toBe(expected);
+    });
+  });
+});

package/src/utils/bytesCompare.ts

@@ -0,0 +1,22 @@
+export const bytesCompare = (a: Uint8Array, b: Uint8Array) => {
+  let i;
+  for (i = 0; i < a.length && i < b.length; i++) {
+    const aByte = a[i];
+    const bByte = b[i];
+    if (aByte !== bByte) {
+      return aByte - bByte;
+    }
+  }
+  if (i === a.length && i === b.length) {
+    // throw error?
+    return 0;
+  }
+  return i === a.length ? -1 : 1;
+};
+
+export const bytesEqual = (bytes1: Uint8Array, bytes2: Uint8Array): boolean => {
+  if (bytes1.length !== bytes2.length) {
+    return false;
+  }
+  return bytesCompare(bytes1, bytes2) === 0;
+};

package/src/utils/consolidate.spec.ts

@@ -0,0 +1,55 @@
+import { consolidate } from './consolidate';
+
+describe('consolidate', () => {
+  it('combines elements', () => {
+    const arr = [true, false, true, false];
+    const canCombine = (a: boolean, b: boolean) => a === b;
+    const combine = (a: boolean) => a;
+
+    const consolidated = consolidate(arr, canCombine, combine);
+
+    expect(consolidated.length).toEqual(2);
+    expect(consolidated[0]).toEqual(true);
+    expect(consolidated[1]).toEqual(false);
+  });
+
+  it('preserves combining order', () => {
+    const arr = [1, 2, 3, 4, 5, 6];
+    const canCombine = (a: number, b: number) => a % 2 === 0 && b % 2 === 0;
+    const combine = (a: number, b: number) => a + b;
+
+    const consolidated = consolidate(arr, canCombine, combine);
+
+    expect(consolidated.length).toEqual(4);
+    expect(consolidated[0]).toEqual(1);
+    expect(consolidated[1]).toEqual(12);
+    expect(consolidated[2]).toEqual(3);
+    expect(consolidated[3]).toEqual(5);
+  });
+
+  it('returns identical array if cannot combine anything', () => {
+    const arr = [1, 2, 3, 4, 5, 6];
+    const canCombine = () => false;
+    const combine = (a: number, b: number) => a + b;
+
+    const consolidated = consolidate(arr, canCombine, combine);
+
+    expect(consolidated.length).toEqual(arr.length);
+    expect(consolidated[0]).toEqual(1);
+    expect(consolidated[1]).toEqual(2);
+    expect(consolidated[2]).toEqual(3);
+    expect(consolidated[3]).toEqual(4);
+    expect(consolidated[4]).toEqual(5);
+    expect(consolidated[5]).toEqual(6);
+  });
+
+  it('handles empty lists gracefully', () => {
+    const arr: number[] = [];
+    const canCombine = () => true;
+    const combine = (a: number, b: number) => a + b;
+
+    const consolidated = consolidate(arr, canCombine, combine);
+
+    expect(consolidated.length).toEqual(arr.length);
+  });
+});

package/src/utils/consolidate.ts

@@ -0,0 +1,32 @@
+/**
+ * This implementation of `consolidate` `combine`s all elements of `arr`
+ * for which `canCombine` returns `true`. It is assumed that all combinations
+ * can be determined with an initial scan of `arr`, and that `canCombine` is transitive,
+ * meaning if `canCombine(A, B)` and `canCombine(B, C)` then `canCombine(combine(A, B), C)`
+ * @param arr - an array of elements
+ * @param canCombine - a function which determines if 2 elements can combine
+ * @param combine - a function which combines 2 elements
+ * @returns an array combined elements
+ */
+export const consolidate = <T>(
+  arr: T[],
+  canCombine: (a: T, b: T) => boolean,
+  combine: (a: T, b: T) => T,
+): T[] => {
+  const consolidated: T[] = [];
+  for (const el of arr) {
+    let combined = false;
+    for (let i = 0; i < consolidated.length; i++) {
+      const existing = consolidated[i];
+      if (canCombine(existing, el)) {
+        consolidated[i] = combine(existing, el);
+        combined = true;
+        break;
+      }
+    }
+    if (!combined) {
+      consolidated.push(el);
+    }
+  }
+  return consolidated;
+};

package/src/utils/costs.ts

@@ -0,0 +1,18 @@
+import type { UnsignedTx } from '../vms/common/unsignedTx';
+
+export const CTxBytesGas = 1n;
+export const CCostPerSignature = 1000n;
+export const CFixedFee = 10000;
+
+export function costCorethTx(tx: UnsignedTx): bigint {
+  const bytesCost = calcBytesCost(tx.toBytes().length);
+
+  const sigCost =
+    BigInt(tx.getSigIndices().flatMap((a) => a).length) * CCostPerSignature;
+  const fixedFee = 10000n;
+  return bytesCost + sigCost + fixedFee;
+}
+
+export function calcBytesCost(len: number): bigint {
+  return BigInt(len) * CTxBytesGas;
+}

package/src/utils/devutils.ts

@@ -0,0 +1,16 @@
+import util from 'util';
+import { bufferToHex } from './buffer';
+
+// useful for printing transactions
+export const printJSON = (obj: any) => {
+  console.log(JSON.stringify(obj, null, 2));
+};
+
+// useful for printing nested objects
+export const printDeep = (obj: any) => {
+  console.log(util.inspect(obj, { depth: null, colors: true }));
+};
+
+export const printHex = (bytes: Uint8Array, name = '') => {
+  console.log(`name = ${name}`, bufferToHex(bytes));
+};