@bitgo-forks/avalanchejs 4.1.0-alpha.1

package/src/utils/getTransferableInputsByTx.test.ts

@@ -0,0 +1,43 @@
+import {
+  avmBaseTx,
+  importTx as avmImportTx,
+  transferableInputs,
+} from '../fixtures/avax';
+import { importTx as pvmImportTx } from '../fixtures/pvm';
+import {
+  importTx as evmImportTx,
+  exportTx as evmExportTx,
+} from '../fixtures/evm';
+import { getTransferableInputsByTx } from './getTransferableInputsByTx';
+
+describe('getTransferableInputsByTx', () => {
+  it('returns the inputs of a PVM import tx correctly', () => {
+    expect(getTransferableInputsByTx(pvmImportTx())).toStrictEqual([
+      ...transferableInputs(),
+      ...transferableInputs(),
+    ]);
+  });
+
+  it('returns the inputs of an AVM import tx correctly', () => {
+    expect(getTransferableInputsByTx(avmImportTx())).toStrictEqual([
+      ...transferableInputs(),
+      ...transferableInputs(),
+    ]);
+  });
+
+  it('returns the inputs of an EVM import tx correctly', () => {
+    expect(getTransferableInputsByTx(evmImportTx())).toStrictEqual(
+      transferableInputs(),
+    );
+  });
+
+  it('returns the inputs of an EVM export tx correctly', () => {
+    expect(getTransferableInputsByTx(evmExportTx())).toStrictEqual([]);
+  });
+
+  it('returns the inputs of a non-import tx correctly', () => {
+    expect(getTransferableInputsByTx(avmBaseTx())).toStrictEqual(
+      transferableInputs(),
+    );
+  });
+});

package/src/utils/getTransferableInputsByTx.ts

@@ -0,0 +1,29 @@
+import { isImportTx as isAvmImportTx } from '../serializable/avm';
+import { isImportTx as isPvmImportTx } from '../serializable/pvm';
+import {
+  isExportTx as isEvmExportTx,
+  isImportExportTx,
+  isEvmTx,
+} from '../serializable/evm';
+import type { AvaxTx } from '../serializable/avax';
+import type { EVMTx } from '../serializable/evm/abstractTx';
+
+export const getTransferableInputsByEvmTx = (tx: EVMTx) => {
+  if (isImportExportTx(tx)) {
+    return isEvmExportTx(tx) ? [] : tx.importedInputs;
+  }
+
+  // Unreachable
+  return [];
+};
+
+export const getTransferableInputsByTx = (tx: AvaxTx | EVMTx) => {
+  if (isEvmTx(tx)) {
+    return getTransferableInputsByEvmTx(tx);
+  }
+  if (isAvmImportTx(tx) || isPvmImportTx(tx)) {
+    return [...(tx.baseTx.inputs ?? []), ...(tx.ins ?? [])];
+  }
+
+  return tx.getInputs();
+};

package/src/utils/getTransferableOutputsByTx.test.ts

@@ -0,0 +1,113 @@
+import {
+  exportTx as evmExportTx,
+  importTx as evmImportTx,
+} from '../fixtures/evm';
+import { getTransferableOutputsByTx } from './getTransferableOutputsByTx';
+import {
+  avmBaseTx,
+  exportTx as avmExportTx,
+  importTx as avmImportTx,
+  pvmBaseTx,
+  transferableOutputs,
+} from '../fixtures/avax';
+import {
+  addDelegatorTx,
+  addPermissionlessDelegatorTx,
+  addPermissionlessValidatorTx,
+  addValidatorTx,
+  importTx as pvmImportTx,
+  exportTx as pvmExportTx,
+  createSubnetTx,
+  addSubnetValidatorTx,
+  removeValidatorTx,
+  transferSubnetOwnershipTx,
+  transformSubnetTx,
+} from '../fixtures/pvm';
+import { outputOwner } from '../fixtures/secp256k1';
+
+describe('getTransferableOutputsByTx', () => {
+  const testData = [
+    // EVM
+    { tx: evmImportTx(), outs: [] },
+    { tx: evmExportTx(), outs: transferableOutputs() },
+    // AVM
+    {
+      tx: avmBaseTx(),
+      outs: transferableOutputs(),
+    },
+    {
+      tx: avmImportTx(),
+      outs: transferableOutputs(),
+    },
+    {
+      tx: avmExportTx(),
+      outs: [...transferableOutputs(), ...transferableOutputs()],
+    },
+    // PVM
+    {
+      tx: pvmBaseTx(),
+      outs: transferableOutputs(),
+    },
+    {
+      tx: pvmImportTx(),
+      outs: transferableOutputs(),
+    },
+    {
+      tx: pvmExportTx(),
+      outs: [...transferableOutputs(), ...transferableOutputs()],
+    },
+    {
+      tx: addValidatorTx(),
+      outs: [
+        ...transferableOutputs(),
+        ...transferableOutputs(),
+        outputOwner(),
+        outputOwner(),
+      ],
+    },
+    {
+      tx: addDelegatorTx(),
+      outs: [...transferableOutputs(), ...transferableOutputs(), outputOwner()],
+    },
+    {
+      tx: addPermissionlessValidatorTx(),
+      outs: [
+        ...transferableOutputs(),
+        ...transferableOutputs(),
+        outputOwner(),
+        outputOwner(),
+      ],
+    },
+    {
+      tx: addPermissionlessDelegatorTx(),
+      outs: [...transferableOutputs(), ...transferableOutputs(), outputOwner()],
+    },
+    {
+      tx: createSubnetTx(),
+      outs: [...transferableOutputs(), outputOwner()],
+    },
+    {
+      tx: addSubnetValidatorTx(),
+      outs: transferableOutputs(),
+    },
+    {
+      tx: removeValidatorTx(),
+      outs: transferableOutputs(),
+    },
+    {
+      tx: transferSubnetOwnershipTx(),
+      outs: transferableOutputs(),
+    },
+    {
+      tx: transformSubnetTx(),
+      outs: transferableOutputs(),
+    },
+  ];
+
+  it.each(testData)(
+    'returns all the transferable outputs of a $tx._type correctly',
+    ({ tx, outs }) => {
+      expect(getTransferableOutputsByTx(tx)).toStrictEqual(outs);
+    },
+  );
+});

package/src/utils/getTransferableOutputsByTx.ts

@@ -0,0 +1,63 @@
+import {
+  isExportTx as isEvmExportTx,
+  isEvmTx,
+  isImportExportTx,
+} from '../serializable/evm';
+import { isExportTx as isAvmExportTx } from '../serializable/avm';
+import {
+  isAddDelegatorTx,
+  isAddPermissionlessDelegatorTx,
+  isAddPermissionlessValidatorTx,
+  isAddValidatorTx,
+  isCreateSubnetTx,
+  isExportTx as isPvmExportTx,
+} from '../serializable/pvm';
+import type { AvaxTx } from '../serializable/avax';
+import type { EVMTx } from '../serializable/evm/abstractTx';
+import type { TransferableOutput } from '../serializable/avax';
+import type { OutputOwners } from '../serializable';
+
+export const getTransferableOutputsByEvmTx = (tx: EVMTx) => {
+  if (isImportExportTx(tx)) {
+    return isEvmExportTx(tx) ? tx.exportedOutputs : [];
+  }
+  // Unreachable
+  return [];
+};
+
+export const getTransferableOutputsByTx = (tx: AvaxTx | EVMTx) => {
+  if (isEvmTx(tx)) {
+    return getTransferableOutputsByEvmTx(tx);
+  }
+  if (isAvmExportTx(tx) || isPvmExportTx(tx)) {
+    return [...(tx.baseTx?.outputs ?? []), ...(tx.outs ?? [])];
+  } else if (
+    isAddValidatorTx(tx) ||
+    isAddDelegatorTx(tx) ||
+    isAddPermissionlessValidatorTx(tx) ||
+    isAddPermissionlessDelegatorTx(tx)
+  ) {
+    const outs: (TransferableOutput | OutputOwners)[] = [
+      ...(tx.baseTx?.outputs ?? []),
+      ...(tx.stake ?? []),
+    ];
+
+    if (isAddValidatorTx(tx)) {
+      // validation reward + delegation reward after cortina upgrade
+      outs.push(tx.getRewardsOwner(), tx.getRewardsOwner());
+    } else if (isAddDelegatorTx(tx)) {
+      outs.push(tx.getRewardsOwner());
+    } else if (isAddPermissionlessValidatorTx(tx)) {
+      outs.push(tx.getValidatorRewardsOwner(), tx.getDelegatorRewardsOwner());
+    } else {
+      outs.push(tx.getDelegatorRewardsOwner());
+    }
+
+    return outs;
+  } else if (isCreateSubnetTx(tx)) {
+    return [...tx.baseTx.outputs, tx.getSubnetOwners()];
+  } else {
+    // This covers base tx, import, other subnet related transactions
+    return tx?.baseTx?.outputs ?? [];
+  }
+};

package/src/utils/index.ts

@@ -0,0 +1,16 @@
+export * from './address';
+export * from './addressesFromBytes';
+export * from './base58';
+export * from './buffer';
+export * from './bytesCompare';
+export * from './costs';
+export * from './devutils';
+export * from './typeGuards';
+export * from './UTXOSet';
+export * from './addChecksum';
+export * from './addressMap';
+export * from './getTransferableInputsByTx';
+export * from './getTransferableOutputsByTx';
+export * from './getBurnedAmountByTx';
+export * from './validateBurnedAmount';
+export { unpackWithManager, getManagerForVM, packTx } from './packTx';

package/src/utils/matchOwners.spec.ts

@@ -0,0 +1,73 @@
+import { Address } from '../serializable/fxs/common';
+import { address } from '../fixtures/common';
+import { OutputOwners } from '../serializable/fxs/secp256k1';
+import { addressesFromBytes } from './addressesFromBytes';
+import { AddressMap } from './addressMap';
+import { hexToBuffer } from './buffer';
+import { matchOwners } from './matchOwners';
+
+describe('matchOwners', () => {
+  it('matches owners', () => {
+    const owner1 = address();
+    const owner2 = Address.fromHex('7db97c7cece249c2b98bdc0226cc4c2a57bf52fc');
+    const ownerAddresses: Uint8Array[] = [owner1.toBytes(), owner2.toBytes()];
+    const goodOwner = OutputOwners.fromNative(ownerAddresses, 0n, 1);
+    const threasholdTooHigh = OutputOwners.fromNative(ownerAddresses, 0n, 5);
+    const wrongOwner = OutputOwners.fromNative(
+      [hexToBuffer('0x12345123451234512345')],
+      0n,
+      5,
+    );
+    const locked = OutputOwners.fromNative(
+      ownerAddresses,
+      9999999999999999999999999999999999n,
+      5,
+    );
+
+    const specs = [
+      {
+        testCase: goodOwner,
+        expectedSigIndices: [0],
+        expectedAddressMap: new AddressMap([[owner1, 0]]),
+      },
+      {
+        testCase: threasholdTooHigh,
+        expectedSigIndices: undefined,
+        expectedAddressMap: undefined,
+      },
+      {
+        testCase: locked,
+        expectedSigIndices: undefined,
+        expectedAddressMap: undefined,
+      },
+      {
+        testCase: wrongOwner,
+        expectedSigIndices: undefined,
+        expectedAddressMap: undefined,
+      },
+      {
+        testCase: goodOwner,
+        sigindices: [1],
+        expectedSigIndices: [1],
+        expectedAddressMap: new AddressMap([[owner2, 1]]),
+      },
+      {
+        testCase: goodOwner,
+        sigindices: [2],
+        expectedSigIndices: undefined,
+        expectedAddressMap: undefined,
+      },
+    ];
+
+    specs.forEach((spec) => {
+      const result = matchOwners(
+        spec.testCase,
+        addressesFromBytes(ownerAddresses),
+        50n,
+        spec.sigindices,
+      );
+      expect(result?.sigIndicies).toEqual(spec.expectedSigIndices);
+      expect(result?.addressMap).toEqual(spec.expectedAddressMap);
+    });
+  });
+});

package/src/utils/matchOwners.ts

@@ -0,0 +1,43 @@
+import type { Address } from '../serializable/fxs/common';
+import type { OutputOwners } from '../serializable/fxs/secp256k1';
+import { AddressMap } from './addressMap';
+
+export type MatchOwnerResult = {
+  sigIndicies: number[];
+  addressMap: AddressMap;
+};
+export const matchOwners = (
+  owners: OutputOwners,
+  inputAddrs: Address[],
+  minIssuanceTime: bigint,
+  sigindices?: number[],
+): MatchOwnerResult | undefined => {
+  if (owners.locktime.value() > minIssuanceTime) {
+    return undefined;
+  }
+
+  const inputAddrSet = new Set(inputAddrs.map((a) => a.toString()));
+  const addressMap = owners.addrs.reduce((agg, addr, i) => {
+    if (
+      agg.size() < owners.threshold.value() &&
+      inputAddrSet.has(addr.value())
+    ) {
+      // only add actual signer addresses if sigindices are known
+      if (sigindices?.length && !sigindices.includes(i)) {
+        return agg;
+      }
+
+      return agg.set(addr, i);
+    }
+    return agg;
+  }, new AddressMap());
+
+  if (addressMap.size() < owners.threshold.value()) {
+    return undefined;
+  }
+
+  return {
+    sigIndicies: Array.from(addressMap.values()),
+    addressMap: addressMap,
+  };
+};

package/src/utils/models.ts

@@ -0,0 +1,7 @@
+export type UnpackReturn =
+  | Uint8Array
+  | number
+  | bigint
+  | string
+  | string[]
+  | number[];

package/src/utils/packTx.ts

@@ -0,0 +1,39 @@
+import { DEFAULT_CODEC_VERSION } from '../constants/codec';
+import { getAVMManager } from '../serializable/avm/codec';
+import type { Manager } from '../serializable/codec';
+import type { Serializable } from '../serializable/common/types';
+import type { VM } from '../serializable/constants';
+import { getEVMManager } from '../serializable/evm/codec';
+import { Short } from '../serializable/primitives';
+import { getPVMManager } from '../serializable/pvm/codec';
+
+export interface GenericTransaction extends Serializable {
+  vm: VM;
+}
+
+export function getManagerForVM(vm: VM): Manager {
+  switch (vm) {
+    case 'AVM':
+      return getAVMManager();
+    case 'EVM':
+      return getEVMManager();
+    case 'PVM':
+      return getPVMManager();
+    default:
+      throw new Error('unknown VM');
+  }
+}
+
+export function unpackWithManager(vm: VM, txBytes: Uint8Array) {
+  return getManagerForVM(vm).unpackTransaction(txBytes);
+}
+
+export function packTx(tx: GenericTransaction) {
+  return getManagerForVM(tx.vm).packCodec(tx);
+}
+
+export function getDefaultCodecFromTx(tx: GenericTransaction) {
+  return getManagerForVM(tx.vm).getCodecForVersion(
+    new Short(DEFAULT_CODEC_VERSION),
+  );
+}

package/src/utils/removeDuplicateUTXOs.ts

@@ -0,0 +1,12 @@
+import type { Utxo } from '../serializable/avax/utxo';
+
+/**
+ * Returns a new array of unique UTXOs.
+ * @param utxos
+ */
+export function filterDuplicateUTXOs(utxos: Utxo[]) {
+  const ids = utxos.map((utxo) => utxo.ID());
+  return utxos.filter((utxo, index) => {
+    return ids.indexOf(utxo.ID()) == index;
+  });
+}

package/src/utils/serializeList.spec.ts

@@ -0,0 +1,34 @@
+import { TransferableInput } from '../serializable/avax';
+import { transferableInputs, transferableInputsBytes } from '../fixtures/avax';
+import { testCodec } from '../fixtures/codec';
+import { address, addressesBytes } from '../fixtures/common';
+import { Address } from '../serializable/fxs/common';
+import { packList, toListStruct, unpackList } from './serializeList';
+import { unpack } from './struct';
+
+describe('SerializeList', () => {
+  it('unpacks list', () => {
+    const adds = addressesBytes();
+    expect(unpackList(adds, Address, testCodec())).toEqual([
+      [address(), address()],
+      new Uint8Array([]),
+    ]);
+  });
+
+  it('unpacks list', () => {
+    expect(packList([address(), address()], testCodec())).toEqual(
+      addressesBytes(),
+    );
+  });
+
+  it('unpack for list type', () => {
+    const transferableInputsType = toListStruct(TransferableInput);
+    const [result, remaining] = unpack(
+      transferableInputsBytes(),
+      [transferableInputsType],
+      testCodec(),
+    );
+    expect(result).toEqual(transferableInputs());
+    expect(remaining).toHaveLength(0);
+  });
+});

package/src/utils/serializeList.ts

@@ -0,0 +1,64 @@
+import { bytesForInt } from '../fixtures/utils/bytesFor';
+import type { Codec } from '../serializable/codec';
+import type {
+  Serializable,
+  SerializableStatic,
+} from '../serializable/common/types';
+import { Int } from '../serializable/primitives/int';
+import { concatBytes } from './buffer';
+
+type unpackFunc = (buf: Uint8Array, codec: Codec) => [any, Uint8Array];
+
+export const unpackList = <T extends SerializableStatic>(
+  buf: Uint8Array,
+  serializable: T,
+  codec: Codec,
+): [ReturnType<T['fromBytes']>[0][], Uint8Array] => {
+  return unpackListForEach(buf, serializable.fromBytes, codec);
+};
+
+export const unpackListForEach = <T extends unpackFunc>(
+  buf: Uint8Array,
+  callback: T,
+  codec: Codec,
+): [ReturnType<T>[0][], Uint8Array] => {
+  let len;
+  [len, buf] = Int.fromBytes(buf);
+  const result: ReturnType<T>[0][] = [];
+  for (let i = 0; i < len.value(); i++) {
+    if (buf.length === 0) {
+      throw new Error('not enough bytes');
+    }
+    let res: any;
+    [res, buf] = callback(buf, codec);
+    result.push(res);
+  }
+  return [result, buf];
+};
+
+export const toListStruct = <T extends SerializableStatic>(
+  serializable: T,
+) => ({
+  fromBytes: (buff: Uint8Array, codec: Codec) =>
+    unpackList(buff, serializable, codec),
+});
+
+export const unpackCodecList = {
+  fromBytes: (
+    buff: Uint8Array,
+    codec?: Codec,
+  ): [Serializable[], Uint8Array] => {
+    if (!codec) throw new Error('codec required when using unpackCodecList');
+    return unpackListForEach(buff, codec.UnpackPrefix, codec);
+  },
+};
+
+export const packList = (
+  serializables: Serializable[],
+  codec: Codec,
+): Uint8Array => {
+  return concatBytes(
+    bytesForInt(serializables.length),
+    ...serializables.map((ser) => ser.toBytes(codec)),
+  );
+};

package/src/utils/sort.spec.ts

@@ -0,0 +1,83 @@
+import { jest } from '@jest/globals';
+import { testCodec, testPVMCodec } from '../fixtures/codec';
+import {
+  getStakeableLockedTransferableOutForTest,
+  getTransferableOutForTest,
+} from '../fixtures/transactions';
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+jest.unstable_mockModule('./bytesCompare', () => ({
+  bytesCompare: jest.fn(),
+}));
+
+const { bytesCompare } = await import('./bytesCompare');
+const { compareTransferableOutputs } = await import('./sort');
+
+describe('compareTransferableOutputs', () => {
+  const avmCodec = testCodec();
+  const pvmCodec = testPVMCodec();
+
+  beforeEach(() => {
+    jest.restoreAllMocks();
+    (bytesCompare as jest.Mock).mockReturnValueOnce(-1);
+  });
+
+  it('sorts transferable outputs correctly', () => {
+    const transferableOutput1 = getTransferableOutForTest(1n);
+    const transferableOutput2 = getTransferableOutForTest(2n);
+
+    const result = compareTransferableOutputs(
+      transferableOutput1,
+      transferableOutput2,
+    );
+
+    expect(result).toEqual(-1);
+    expect(bytesCompare).toBeCalledTimes(1);
+    expect(bytesCompare).toBeCalledWith(
+      transferableOutput1.toBytes(avmCodec),
+      transferableOutput2.toBytes(avmCodec),
+    );
+  });
+
+  it('sorts stakeable locked outs correctly', () => {
+    const transferableOutput1 = getStakeableLockedTransferableOutForTest(
+      1n,
+      100n,
+    );
+    const transferableOutput2 = getStakeableLockedTransferableOutForTest(
+      2n,
+      200n,
+    );
+
+    const result = compareTransferableOutputs(
+      transferableOutput1,
+      transferableOutput2,
+    );
+
+    expect(result).toEqual(-1);
+    expect(bytesCompare).toBeCalledWith(
+      transferableOutput1.toBytes(pvmCodec),
+      transferableOutput2.toBytes(pvmCodec),
+    );
+  });
+
+  it('sorts transferable outputs and stakeable locked outs correctly', () => {
+    const transferableOutput1 = getTransferableOutForTest(1n);
+    const transferableOutput2 = getStakeableLockedTransferableOutForTest(
+      1n,
+      100n,
+    );
+
+    const result = compareTransferableOutputs(
+      transferableOutput1,
+      transferableOutput2,
+    );
+
+    expect(result).toEqual(-1);
+    expect(bytesCompare).toBeCalledWith(
+      transferableOutput1.toBytes(avmCodec),
+      transferableOutput2.toBytes(pvmCodec),
+    );
+  });
+});

package/src/utils/sort.ts

@@ -0,0 +1,37 @@
+import { getPVMManager } from '../serializable/pvm/codec';
+import type { TransferableOutput } from '../serializable/avax';
+import { getAVMManager } from '../serializable/avm/codec';
+import type { Output } from '../serializable/evm';
+import { Id } from '../serializable/fxs/common';
+import { bytesCompare } from './bytesCompare';
+import { isStakeableLockOut } from './typeGuards';
+
+export const compareTransferableOutputs = (
+  output1: TransferableOutput,
+  output2: TransferableOutput,
+): number => {
+  const assetIdRes = Id.compare(output1.assetId, output2.assetId);
+  if (assetIdRes !== 0) {
+    return assetIdRes;
+  }
+
+  const pvmOutputTypes = [isStakeableLockOut];
+  const avmCodec = getAVMManager().getDefaultCodec();
+  const pvmCodec = getPVMManager().getDefaultCodec();
+
+  const codec1 = pvmOutputTypes.some((checker) => checker(output1.output))
+    ? pvmCodec
+    : avmCodec;
+  const codec2 = pvmOutputTypes.some((checker) => checker(output2.output))
+    ? pvmCodec
+    : avmCodec;
+
+  return bytesCompare(output1.toBytes(codec1), output2.toBytes(codec2));
+};
+
+export const compareEVMOutputs = (a: Output, b: Output) => {
+  if (a.address.value() === b.address.value()) {
+    return bytesCompare(a.assetId.toBytes(), b.assetId.toBytes());
+  }
+  return a.address.value().localeCompare(b.address.value());
+};