@bitgo-forks/avalanchejs 4.1.0-alpha.1

package/src/utils/struct.spec.ts

@@ -0,0 +1,44 @@
+import { TransferableOutput } from '../serializable/avax';
+import { transferableOutput, transferableOutputBytes } from '../fixtures/avax';
+import { testCodec } from '../fixtures/codec';
+import {
+  mintOutput,
+  mintOutputBytes,
+  transferOutput,
+  transferOutputBytes,
+} from '../fixtures/secp256k1';
+import { MintOutput, TransferOutput } from '../serializable/fxs/secp256k1';
+import { concatBytes } from './buffer';
+import { unpack } from './struct';
+
+describe('structSimple', () => {
+  it('unpackSimple', () => {
+    const input: Uint8Array = concatBytes(
+      transferOutputBytes(),
+      mintOutputBytes(),
+    );
+
+    const outputArray = [TransferOutput, MintOutput] as const;
+    const [tsOutput, mntOutput, remaining] = unpack(input, outputArray);
+    expect(tsOutput).toEqual(transferOutput());
+    expect(mntOutput).toEqual(mintOutput());
+    expect(remaining).toEqual(new Uint8Array());
+  });
+
+  it('unpackSimple with codec', () => {
+    const input: Uint8Array = concatBytes(
+      transferableOutputBytes(),
+      mintOutputBytes(),
+    );
+
+    const outputArray = [TransferableOutput, MintOutput] as const;
+    const [tsOutput, mntOutput, remaining] = unpack(
+      input,
+      outputArray,
+      testCodec(),
+    );
+    expect(tsOutput).toEqual(transferableOutput());
+    expect(mntOutput).toEqual(mintOutput());
+    expect(remaining).toEqual(new Uint8Array());
+  });
+});

package/src/utils/struct.ts

@@ -0,0 +1,59 @@
+import type { Codec } from '../serializable/codec';
+import type { Serializable } from '../serializable/common/types';
+import { concatBytes } from './buffer';
+import { packList } from './serializeList';
+
+export type FromBytesReturn<T> = T extends {
+  fromBytes: (buff: Uint8Array, codec?: Codec) => [infer rType, Uint8Array];
+}
+  ? rType
+  : T extends {
+      fromBytes: (buff: Uint8Array, codec: Codec) => [infer rType, Uint8Array];
+    }
+  ? rType
+  : never;
+
+export type ReturnTypes<T extends readonly any[]> = {
+  [i in keyof T]: FromBytesReturn<T[i]>;
+};
+
+export function unpack<O extends readonly any[]>(
+  buffer: Uint8Array,
+  sers: O,
+  codec?: Codec,
+): [...ReturnTypes<O>, Uint8Array] {
+  const unpacked = sers.map((ser) => {
+    let res: ReturnType<typeof ser.fromBytes>[0];
+
+    if (!buffer.length) {
+      throw new Error('not enough bytes');
+    }
+
+    [res, buffer] = ser.fromBytes(buffer, codec);
+
+    return res;
+  });
+
+  return [...unpacked, buffer] as unknown as [...ReturnTypes<O>, Uint8Array];
+}
+
+export function pack(
+  serializables: (Serializable | Serializable[])[],
+  codec: Codec,
+) {
+  return concatBytes(
+    ...serializables.map((ser) => {
+      if (Array.isArray(ser)) {
+        return packList(ser, codec);
+      }
+      return ser.toBytes(codec);
+    }),
+  );
+}
+
+export function packSwitched(
+  codec: Codec,
+  ...serializables: (Serializable | Serializable[])[]
+) {
+  return pack(serializables, codec);
+}

package/src/utils/transferableAmounts.ts

@@ -0,0 +1,13 @@
+import type { Amounter } from '../serializable/common/types';
+
+export interface TransferableSummable extends Amounter {
+  getAssetId(): string;
+}
+
+export const transferableAmounts = (transferables: TransferableSummable[]) => {
+  return transferables.reduce((agg, transferable) => {
+    agg[transferable.getAssetId()] = agg[transferable.getAssetId()] ?? 0n;
+    agg[transferable.getAssetId()] += transferable.amount();
+    return agg;
+  }, {} as Record<string, bigint>);
+};

package/src/utils/typeGuards.ts

@@ -0,0 +1,27 @@
+import type { Serializable } from '../serializable/common/types';
+import type { TransferInput } from '../serializable/fxs/secp256k1';
+import type { OutputOwners } from '../serializable/fxs/secp256k1/outputOwners';
+import type { TransferOutput } from '../serializable/fxs/secp256k1/transferOutput';
+import type { StakeableLockIn } from '../serializable/pvm/stakeableLockIn';
+import type { StakeableLockOut } from '../serializable/pvm/stakeableLockOut';
+import { TypeSymbols } from '../serializable/constants';
+
+export function isTransferOut(out: Serializable): out is TransferOutput {
+  return out._type === TypeSymbols.TransferOutput;
+}
+
+export function isStakeableLockOut(out: Serializable): out is StakeableLockOut {
+  return out._type === TypeSymbols.StakeableLockOut;
+}
+
+export function isRewardsOwner(out: Serializable): out is OutputOwners {
+  return out._type === TypeSymbols.OutputOwners;
+}
+
+export function isStakeableLockIn(out: Serializable): out is StakeableLockIn {
+  return out._type === TypeSymbols.StakeableLockIn;
+}
+
+export function isTransferInput(inp: Serializable): inp is TransferInput {
+  return inp._type === TypeSymbols.TransferInput;
+}

package/src/utils/validateBurnedAmount.test.ts

@@ -0,0 +1,542 @@
+import { testAddress1, testAddress2, testEthAddress1 } from '../fixtures/vms';
+import { testContext } from '../fixtures/context';
+import { newExportTxFromBaseFee, newImportTxFromBaseFee } from '../vms/evm';
+import { Utxo } from '../serializable/avax/utxo';
+import { utxoId } from '../fixtures/avax';
+import { Address, Id } from '../serializable/fxs/common';
+import { OutputOwners, TransferOutput } from '../serializable/fxs/secp256k1';
+import { BigIntPr, Int } from '../serializable/primitives';
+import {
+  newBaseTx as avmBaseTx,
+  newExportTx as avmExportTx,
+  newImportTx as avmImportTx,
+} from '../vms/avm';
+import {
+  newBaseTx as pvmBaseTx,
+  newExportTx as pvmExportTx,
+  newImportTx as pvmImportTx,
+  newAddValidatorTx,
+  newAddDelegatorTx,
+  newCreateSubnetTx,
+  newCreateBlockchainTx,
+  newAddSubnetValidatorTx,
+  newTransformSubnetTx,
+  newAddPermissionlessValidatorTx,
+  newAddPermissionlessDelegatorTx,
+  newRemoveSubnetValidatorTx,
+  newTransferSubnetOwnershipTx,
+} from '../vms/pvm';
+import { TransferableOutput } from '../serializable';
+import { nodeId } from '../fixtures/common';
+import { validateBurnedAmount } from './validateBurnedAmount';
+import { testSubnetId } from '../fixtures/transactions';
+import { PrimaryNetworkID } from '../constants/networkIDs';
+import { blsPublicKeyBytes, blsSignatureBytes } from '../fixtures/primitives';
+
+const utxoMock = new Utxo(
+  utxoId(),
+  Id.fromString(testContext.avaxAssetID),
+  new TransferOutput(
+    new BigIntPr(1000000000000n),
+    new OutputOwners(new BigIntPr(0n), new Int(1), [
+      Address.fromBytes(testAddress1)[0],
+    ]),
+  ),
+);
+
+const outputMock = new TransferableOutput(
+  Id.fromString(testContext.avaxAssetID),
+  new TransferOutput(
+    new BigIntPr(100000000n),
+    new OutputOwners(new BigIntPr(0n), new Int(1), [
+      Address.fromBytes(testAddress2)[0],
+    ]),
+  ),
+);
+
+describe('validateBurnedAmount', () => {
+  describe('missing burned amount', () => {
+    it('calculates the burned amount', () => {
+      const unsignedTx = avmBaseTx(
+        testContext,
+        [testAddress1],
+        [utxoMock],
+        [outputMock],
+      );
+
+      const result = validateBurnedAmount({
+        unsignedTx,
+        context: testContext,
+      });
+
+      expect(result).toStrictEqual({
+        isValid: true,
+        txFee: testContext.baseTxFee,
+      });
+    });
+  });
+
+  describe('export from C', () => {
+    const unsignedTx = newExportTxFromBaseFee(
+      testContext,
+      25n,
+      1000000000n,
+      'X',
+      testEthAddress1,
+      [testAddress1],
+      1n,
+    );
+
+    it('throws if fee data is missing', () => {
+      expect(() =>
+        validateBurnedAmount({
+          unsignedTx,
+          context: testContext,
+          burnedAmount: (280750n * 75n) / 100n, // 25% lower
+        }),
+      ).toThrowError('missing evm fee data');
+
+      expect(() =>
+        validateBurnedAmount({
+          unsignedTx,
+          context: testContext,
+          burnedAmount: (280750n * 75n) / 100n, // 25% lower
+          evmBaseFee: 25n,
+        }),
+      ).toThrowError('missing evm fee data');
+    });
+
+    it('throws if evmFeeTolerance is incorrect', () => {
+      expect(() =>
+        validateBurnedAmount({
+          unsignedTx,
+          context: testContext,
+          burnedAmount: (280750n * 75n) / 100n, // 25% lower,
+          evmBaseFee: 25n,
+          evmFeeTolerance: 0.5,
+        }),
+      ).toThrowError('evmFeeTolerance must be [1,100]');
+
+      expect(() =>
+        validateBurnedAmount({
+          unsignedTx,
+          context: testContext,
+          burnedAmount: (280750n * 75n) / 100n, // 25% lower,
+          evmBaseFee: 25n,
+          evmFeeTolerance: 101,
+        }),
+      ).toThrowError('evmFeeTolerance must be [1,100]');
+    });
+
+    it('returns true if burned amount is in the tolerance range', () => {
+      const resultLower = validateBurnedAmount({
+        unsignedTx,
+        context: testContext,
+        burnedAmount: (280750n * 75n) / 100n, // 25% lower
+        evmBaseFee: 25n,
+        evmFeeTolerance: 50.9,
+      });
+
+      const resultHigher = validateBurnedAmount({
+        unsignedTx,
+        context: testContext,
+        burnedAmount: (280750n * 125n) / 100n, // 25% higher
+        evmBaseFee: 25n,
+        evmFeeTolerance: 50.9,
+      });
+
+      expect(resultLower).toStrictEqual({
+        isValid: true,
+        txFee: (280750n * 75n) / 100n,
+      });
+      expect(resultHigher).toStrictEqual({
+        isValid: true,
+        txFee: (280750n * 125n) / 100n,
+      });
+    });
+
+    it('returns false if burned amount is not in the tolerance range', () => {
+      const resultLower = validateBurnedAmount({
+        unsignedTx,
+        context: testContext,
+        burnedAmount: (280750n * 49n) / 100n, // 51% lower
+        evmBaseFee: 25n,
+        evmFeeTolerance: 50.9,
+      });
+
+      const resultHigher = validateBurnedAmount({
+        unsignedTx,
+        context: testContext,
+        burnedAmount: (280750n * 151n) / 100n, // 51% higher
+        evmBaseFee: 25n,
+        evmFeeTolerance: 50.9,
+      });
+
+      expect(resultLower).toStrictEqual({
+        isValid: false,
+        txFee: (280750n * 49n) / 100n,
+      });
+      expect(resultHigher).toStrictEqual({
+        isValid: false,
+        txFee: (280750n * 151n) / 100n,
+      });
+    });
+  });
+
+  describe('import to C', () => {
+    const unsignedTx = newImportTxFromBaseFee(
+      testContext,
+      testEthAddress1,
+      [testAddress1],
+      [utxoMock],
+      'X',
+      25n,
+    );
+
+    it('returns true if burned amount is in the tolerance range', () => {
+      const resultLower = validateBurnedAmount({
+        unsignedTx,
+        context: testContext,
+        burnedAmount: (280750n * 75n) / 100n, // 25% lower
+        evmBaseFee: 25n,
+        evmFeeTolerance: 50.9,
+      });
+
+      const resultHigher = validateBurnedAmount({
+        unsignedTx,
+        context: testContext,
+        burnedAmount: (280750n * 125n) / 100n, // 25% higher
+        evmBaseFee: 25n,
+        evmFeeTolerance: 50.9,
+      });
+
+      expect(resultLower).toStrictEqual({
+        isValid: true,
+        txFee: (280750n * 75n) / 100n,
+      });
+      expect(resultHigher).toStrictEqual({
+        isValid: true,
+        txFee: (280750n * 125n) / 100n,
+      });
+    });
+
+    it('returns false if burned amount is not in the tolerance range', () => {
+      const resultLower = validateBurnedAmount({
+        unsignedTx,
+        context: testContext,
+        burnedAmount: (280750n * 49n) / 100n, // 51% lower
+        evmBaseFee: 25n,
+        evmFeeTolerance: 50.9,
+      });
+
+      const resultHigher = validateBurnedAmount({
+        unsignedTx,
+        context: testContext,
+        burnedAmount: (280750n * 151n) / 100n, // 51% higher
+        evmBaseFee: 25n,
+        evmFeeTolerance: 50.9,
+      });
+
+      expect(resultLower).toStrictEqual({
+        isValid: false,
+        txFee: (280750n * 49n) / 100n,
+      });
+      expect(resultHigher).toStrictEqual({
+        isValid: false,
+        txFee: (280750n * 151n) / 100n,
+      });
+    });
+  });
+
+  const testData = [
+    {
+      name: 'base tx on X',
+      unsignedTx: avmBaseTx(
+        testContext,
+        [testAddress1],
+        [utxoMock],
+        [outputMock],
+      ),
+      correctBurnedAmount: testContext.baseTxFee,
+    },
+    {
+      name: 'export from X',
+      unsignedTx: avmExportTx(
+        testContext,
+        'P',
+        [testAddress1],
+        [utxoMock],
+        [outputMock],
+      ),
+      correctBurnedAmount: testContext.baseTxFee,
+    },
+    {
+      name: 'import from X',
+      unsignedTx: avmImportTx(
+        testContext,
+        'P',
+        [utxoMock],
+        [testAddress2],
+        [testAddress1],
+      ),
+      correctBurnedAmount: testContext.baseTxFee,
+    },
+    {
+      name: 'base tx on P',
+      unsignedTx: pvmBaseTx(
+        testContext,
+        [testAddress1],
+        [utxoMock],
+        [outputMock],
+      ),
+      correctBurnedAmount: testContext.baseTxFee,
+    },
+    {
+      name: 'export from P',
+      unsignedTx: pvmExportTx(
+        testContext,
+        'C',
+        [testAddress1],
+        [utxoMock],
+        [outputMock],
+      ),
+      correctBurnedAmount: testContext.baseTxFee,
+    },
+    {
+      name: 'import to P',
+      unsignedTx: pvmImportTx(
+        testContext,
+        'C',
+        [utxoMock],
+        [testAddress2],
+        [testAddress1],
+      ),
+      correctBurnedAmount: testContext.baseTxFee,
+    },
+    {
+      name: 'add validator',
+      unsignedTx: newAddValidatorTx(
+        testContext,
+        [utxoMock],
+        [testAddress1],
+        nodeId().toString(),
+        0n,
+        1n,
+        2n,
+        [testAddress1],
+        3,
+      ),
+      correctBurnedAmount: testContext.addPrimaryNetworkValidatorFee,
+    },
+    {
+      name: 'add delegator',
+      unsignedTx: newAddDelegatorTx(
+        testContext,
+        [utxoMock],
+        [testAddress1],
+        nodeId().toString(),
+        0n,
+        1n,
+        2n,
+        [testAddress1],
+      ),
+      correctBurnedAmount: testContext.addPrimaryNetworkDelegatorFee,
+    },
+    {
+      name: 'create subnet',
+      unsignedTx: newCreateSubnetTx(
+        testContext,
+        [utxoMock],
+        [testAddress1],
+        [testAddress1],
+      ),
+      correctBurnedAmount: testContext.createSubnetTxFee,
+    },
+    {
+      name: 'create blockchain',
+      unsignedTx: newCreateBlockchainTx(
+        testContext,
+        [utxoMock],
+        [testAddress1],
+        'subnet',
+        'chain',
+        'vm',
+        ['fx1', 'fx2'],
+        {},
+        [0],
+      ),
+      correctBurnedAmount: testContext.createBlockchainTxFee,
+    },
+    {
+      name: 'add subnet validator',
+      unsignedTx: newAddSubnetValidatorTx(
+        testContext,
+        [utxoMock],
+        [testAddress1],
+        nodeId().toString(),
+        0n,
+        1n,
+        2n,
+        'subnet',
+        [0],
+      ),
+      correctBurnedAmount: testContext.addSubnetValidatorFee,
+    },
+    {
+      name: 'remove subnet validator',
+      unsignedTx: newRemoveSubnetValidatorTx(
+        testContext,
+        [utxoMock],
+        [testAddress1],
+        nodeId().toString(),
+        Id.fromHex(testSubnetId).toString(),
+        [0],
+      ),
+      correctBurnedAmount: testContext.baseTxFee,
+    },
+    {
+      name: 'transform subnet',
+      unsignedTx: newTransformSubnetTx(
+        testContext,
+        [utxoMock],
+        [testAddress1],
+        Id.fromHex(testSubnetId).toString(),
+        '123456789ABC',
+        1n,
+        2n,
+        3n,
+        4n,
+        5n,
+        6n,
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        [0, 2],
+      ),
+      correctBurnedAmount: testContext.transformSubnetTxFee,
+    },
+    {
+      name: 'add permissionless validator (primary network)',
+      unsignedTx: newAddPermissionlessValidatorTx(
+        testContext,
+        [utxoMock],
+        [testAddress1],
+        nodeId().toString(),
+        PrimaryNetworkID.toString(),
+        0n,
+        120n,
+        1800000n,
+        [],
+        [],
+        1,
+        {},
+        1,
+        0n,
+        blsPublicKeyBytes(),
+        blsSignatureBytes(),
+      ),
+      correctBurnedAmount: testContext.addPrimaryNetworkValidatorFee,
+    },
+    {
+      name: 'add permissionless validator (subnet)',
+      unsignedTx: newAddPermissionlessValidatorTx(
+        testContext,
+        [utxoMock],
+        [testAddress1],
+        nodeId().toString(),
+        Id.fromHex(testSubnetId).toString(),
+        0n,
+        120n,
+        1800000n,
+        [],
+        [],
+        1,
+        {},
+        1,
+        0n,
+        blsPublicKeyBytes(),
+        blsSignatureBytes(),
+      ),
+      correctBurnedAmount: testContext.addSubnetValidatorFee,
+    },
+    {
+      name: 'add permissionless delegator (primary network)',
+      unsignedTx: newAddPermissionlessDelegatorTx(
+        testContext,
+        [utxoMock],
+        [testAddress1],
+        nodeId().toString(),
+        PrimaryNetworkID.toString(),
+        0n,
+        120n,
+        1800000n,
+        [],
+        {},
+        1,
+        0n,
+      ),
+      correctBurnedAmount: testContext.addPrimaryNetworkDelegatorFee,
+    },
+    {
+      name: 'add permissionless delegator (subnet)',
+      unsignedTx: newAddPermissionlessDelegatorTx(
+        testContext,
+        [utxoMock],
+        [testAddress1],
+        nodeId().toString(),
+        Id.fromHex(testSubnetId).toString(),
+        0n,
+        120n,
+        1800000n,
+        [],
+        {},
+        1,
+        0n,
+      ),
+      correctBurnedAmount: testContext.addSubnetDelegatorFee,
+    },
+    {
+      name: 'transfer subnet ownership',
+      unsignedTx: newTransferSubnetOwnershipTx(
+        testContext,
+        [utxoMock],
+        [testAddress1],
+        Id.fromHex(testSubnetId).toString(),
+        [0, 2],
+        [testAddress2],
+      ),
+      correctBurnedAmount: testContext.baseTxFee,
+    },
+  ];
+
+  describe.each(testData)('$name', ({ unsignedTx, correctBurnedAmount }) => {
+    it('returns true if burned amount is correct', () => {
+      const result = validateBurnedAmount({
+        unsignedTx,
+        context: testContext,
+        burnedAmount: correctBurnedAmount,
+      });
+
+      expect(result).toStrictEqual({
+        isValid: true,
+        txFee: correctBurnedAmount,
+      });
+    });
+
+    it('returns false if burned amount is not correct', () => {
+      const result = validateBurnedAmount({
+        unsignedTx,
+        context: testContext,
+        burnedAmount: correctBurnedAmount - 1n,
+      });
+
+      expect(result).toStrictEqual({
+        isValid: false,
+        txFee: correctBurnedAmount,
+      });
+    });
+  });
+});