@bitgo-forks/avalanchejs 4.1.0-alpha.1

package/src/vms/pvm/index.ts

@@ -0,0 +1,3 @@
+export * from './builder';
+export * from './models';
+export * from './api';

package/src/vms/pvm/models.ts

@@ -0,0 +1,251 @@
+import type { TransferableOutput } from '../../serializable/avax';
+import type { Utxo } from '../../serializable/avax/utxo';
+
+export type GetAssetDescriptionResponse = {
+  assetId: string;
+  name: string;
+  symbol: string;
+  denomination: number;
+};
+
+export type GetCurrentValidatorsResponse = {
+  validators: {
+    accruedDelegateeReward: string;
+    txID: string;
+    startTime: string;
+    endTime: string;
+    stakeAmount: string;
+    nodeID: string;
+    weight: string;
+    validationRewardOwner: {
+      locktime: string;
+      threshold: string;
+      addresses: string[];
+    };
+    delegatorCount: string;
+    delegatorWeight: string;
+    potentialReward: string;
+    delegationFee: string;
+    uptime: string;
+    connected: boolean;
+    delegators: {
+      txID: string;
+      startTime: string;
+      endTime: string;
+      stakeAmount: string;
+      nodeID: string;
+      delegationRewardOwner: {
+        locktime: string;
+        threshold: string;
+        addresses: string[];
+      };
+      potentialReward: string;
+    }[];
+  }[];
+};
+
+export type GetPendingValidatorsParams = {
+  subnetID?: string;
+  nodeIDs?: string[];
+};
+
+export type GetPendingValidatorsResponse = {
+  validators: {
+    txID: string;
+    startTime: string;
+    endTime: string;
+    stakeAmount: string;
+    nodeID: string;
+    delegationFee: string;
+    connected: boolean;
+    weight: string;
+  }[];
+  delegators: {
+    txID: string;
+    startTime: string;
+    endTime: string;
+    stakeAmount: string;
+    nodeID: string;
+  }[];
+};
+
+export interface GetRewardUTXOsParams {
+  txID: string;
+}
+
+export interface GetRewardUTXOsResponse {
+  numFetched: number;
+  utxos: Utxo[];
+}
+
+export interface GetStakeParams {
+  addresses: string[];
+}
+
+export interface GetStakeResponse {
+  staked: bigint;
+  stakedOutputs: TransferableOutput[];
+}
+
+export interface GetRewardUTXOsParams {
+  txID: string;
+}
+
+export interface GetRewardUTXOsResponse {
+  numFetched: number;
+  utxos: Utxo[];
+}
+
+export interface GetValidatorsAtParams {
+  height: number;
+  subnetID?: string;
+}
+
+export interface GetValidatorsAtResponse {
+  validators: object;
+}
+
+export interface GetCurrentValidatorsParams {
+  subnetID?: Buffer | string;
+  nodeIDs?: string[];
+}
+
+export interface SampleValidatorsParams {
+  size: number;
+  subnetID?: string;
+}
+
+export interface SampleValidatorsResponse {
+  validators: string[];
+}
+
+export interface GetBalanceParams {
+  addresses: string[];
+}
+
+export interface GetBalanceResponse {
+  balance: bigint;
+  unlocked: bigint;
+  lockedStakeable: bigint;
+  lockedNotStakeable: bigint;
+  utxoIDs: {
+    txID: string;
+    outputIndex: number;
+  }[];
+}
+
+export interface StartIndex {
+  address: string;
+  utxo: string;
+}
+
+export interface Subnet {
+  ids: string;
+  controlKeys: string[];
+  threshold: number;
+}
+
+export interface Blockchain {
+  id: string;
+  name: string;
+  subnetID: string;
+  vmID: string;
+}
+
+export interface GetMinStakeResponse {
+  minValidatorStake: bigint;
+  minDelegatorStake: bigint;
+}
+
+export interface GetMaxStakeAmountParams {
+  subnetID?: string;
+  nodeID: string;
+  startTime: bigint;
+  endTime: bigint;
+}
+
+export interface GetTxStatusParams {
+  txID: string;
+  includeReason?: boolean;
+}
+
+export interface GetTxStatusResponse {
+  status: string;
+  reason: string;
+}
+
+export interface GetCurrentSupplyResponse {
+  supply: bigint;
+}
+
+export interface GetBalanceResponse {
+  balance: bigint;
+  unlocked: bigint;
+  lockedStakeable: bigint;
+  lockedNotStakeable: bigint;
+  utxoIDs: {
+    txID: string;
+    outputIndex: number;
+  }[];
+}
+
+export interface GetBlockchainsResponse {
+  blockchains: {
+    id: string;
+    name: string;
+    subnetID: string;
+    vmID: string;
+  }[];
+}
+
+export interface GetBlockchainStatusResponse {
+  status: string;
+}
+
+export interface GetHeightResponse {
+  height: number;
+}
+
+export interface GetStakingAssetIDParams {
+  subnetID: string;
+}
+
+export interface GetStakingAssetIDResponse {
+  assetID: string;
+}
+
+export interface GetSubnetsParams {
+  ids: string[];
+}
+
+export interface GetSubnetsResponse {
+  subnets: {
+    id: string;
+    controlKeys: string[];
+    threshold: string;
+  }[];
+}
+
+export interface GetTimestampResponse {
+  timestamp: string;
+}
+
+export interface GetTotalStakeResponse {
+  weight: string;
+}
+
+export interface ValidatedByParams {
+  blockchainID: string;
+}
+
+export interface ValidatedByResponse {
+  subnetID: string;
+}
+
+export interface ValidatesParams {
+  subnetID: string;
+}
+
+export interface ValidatesResponse {
+  blockchainIDs: string[];
+}

package/src/vms/pvm/privateModels.ts

@@ -0,0 +1,17 @@
+/* 
+  models in this file are intermediate and not meant to be exported externally
+*/
+
+export interface GetRewardUTXOsServerResponse {
+  numFetched: number;
+  utxos: string[];
+}
+
+export interface GetStakeServerResponse {
+  staked: bigint;
+  stakedOutputs: string[];
+}
+
+export interface GetTxServerResponse {
+  tx: any;
+}

package/src/vms/pvm/utxoCalculationFns/index.ts

@@ -0,0 +1,3 @@
+export * from './useSpendableLockedUTXOs';
+export * from './useUnlockedUTXOs';
+export * from './useConsolidateOutputs';

package/src/vms/pvm/utxoCalculationFns/useConsolidateOutputs.ts

@@ -0,0 +1,17 @@
+import { consolidateOutputs } from '../../utils/consolidateOutputs';
+import type { UTXOCalculationState } from '../../utils/calculateSpend';
+
+export function useConsolidateOutputs({
+  changeOutputs,
+  stakeOutputs,
+  ...state
+}: UTXOCalculationState): UTXOCalculationState {
+  const consolidatedChangeOutputs = consolidateOutputs(changeOutputs);
+  const consolidatedStakeOutputs = consolidateOutputs(stakeOutputs);
+
+  return {
+    ...state,
+    changeOutputs: consolidatedChangeOutputs,
+    stakeOutputs: consolidatedStakeOutputs,
+  };
+}

package/src/vms/pvm/utxoCalculationFns/useSpendableLockedUTXOs.spec.ts

@@ -0,0 +1,139 @@
+import { Id } from '../../../serializable/fxs/common';
+import { testContext } from '../../../fixtures/context';
+import {
+  fromAddressBytes,
+  testUTXOID1,
+  getStakeableLockoutOutput,
+  testUTXOID2,
+} from '../../../fixtures/transactions';
+import { addressesFromBytes } from '../../../utils';
+import { useSpendableLockedUTXOs } from './useSpendableLockedUTXOs';
+import { defaultSpendResult } from '../../utils/calculateSpend';
+import type { StakeableLockOut } from '../../../serializable/pvm';
+
+describe('src/vms/pvm/spend/useSpendableLockedUTXOs.spec.ts', () => {
+  it('Should do nothing if stakeable output is not locked anymore', () => {
+    const stakeableUtxoAmt1 = 600000000n;
+    const stakeableUtxoAmt2 = 700000000n;
+    const amountRemainingToStake = 500000000n;
+    const lockTime = 1n;
+
+    const { amountsToStake, changeOutputs, inputs } = useSpendableLockedUTXOs({
+      amountsToBurn: new Map(),
+      ...defaultSpendResult(),
+      utxos: [
+        getStakeableLockoutOutput(testUTXOID1, stakeableUtxoAmt1, lockTime),
+        getStakeableLockoutOutput(testUTXOID2, stakeableUtxoAmt2, lockTime),
+      ],
+      fromAddresses: addressesFromBytes(fromAddressBytes),
+      amountsToStake: new Map([
+        [testContext.avaxAssetID, amountRemainingToStake],
+      ]), // amount remaining to stake
+      options: { minIssuanceTime: lockTime * 2n } as any,
+    });
+
+    expect(changeOutputs.length).toEqual(0);
+    expect(inputs.length).toEqual(0);
+    expect(amountsToStake.get(testContext.avaxAssetID)).toEqual(
+      amountRemainingToStake,
+    );
+  });
+
+  it('Should have a remaining stakeable amount and has no change', () => {
+    const stakeableUtxoAmt1 = 200000000n;
+    const stakeableUtxoAmt2 = 100000000n;
+    const amountRemainingToStake = 500000000n;
+
+    const { amountsToStake, changeOutputs } = useSpendableLockedUTXOs({
+      amountsToBurn: new Map(),
+      ...defaultSpendResult(),
+      utxos: [
+        getStakeableLockoutOutput(testUTXOID1, stakeableUtxoAmt1),
+        getStakeableLockoutOutput(testUTXOID2, stakeableUtxoAmt2),
+      ],
+      fromAddresses: addressesFromBytes(fromAddressBytes),
+      amountsToStake: new Map([
+        [testContext.avaxAssetID, amountRemainingToStake],
+      ]), // amount remaining to stake
+      options: { minIssuanceTime: 0n } as any,
+    });
+
+    expect(changeOutputs.length).toEqual(0);
+    expect(amountsToStake.get(testContext.avaxAssetID)).toEqual(
+      amountRemainingToStake - stakeableUtxoAmt1 - stakeableUtxoAmt2,
+    );
+  });
+
+  it('Should have no remaining stakeable amount and change', () => {
+    const stakeableUtxoAmt1 = 200000000n;
+    const stakeableUtxoAmt2 = 400000000n;
+    const amountRemainingToStake = 500000000n;
+
+    const { amountsToStake, changeOutputs, inputs, inputUTXOs } =
+      useSpendableLockedUTXOs({
+        amountsToBurn: new Map(),
+        ...defaultSpendResult(),
+        utxos: [
+          getStakeableLockoutOutput(testUTXOID1, stakeableUtxoAmt1),
+          getStakeableLockoutOutput(testUTXOID2, stakeableUtxoAmt2),
+        ],
+        fromAddresses: addressesFromBytes(fromAddressBytes),
+        amountsToStake: new Map([
+          [testContext.avaxAssetID, amountRemainingToStake],
+        ]), // amount remaining to stake
+        options: { minIssuanceTime: 0 } as any,
+      });
+
+    expect(changeOutputs.length).toEqual(1);
+    expect(changeOutputs[0].amount()).toEqual(
+      stakeableUtxoAmt1 + stakeableUtxoAmt2 - amountRemainingToStake,
+    );
+    expect(amountsToStake.get(testContext.avaxAssetID)).toEqual(0n);
+
+    expect(inputs).toHaveLength(2);
+    expect(inputs[0].utxoID.txID).toEqual(testUTXOID1);
+    expect(inputs[0].amount()).toEqual(stakeableUtxoAmt1);
+    expect(inputs[1].utxoID.txID).toEqual(testUTXOID2);
+    expect(inputs[1].amount()).toEqual(stakeableUtxoAmt2);
+
+    expect(inputUTXOs).toHaveLength(2);
+    expect(inputUTXOs[0].utxoId.txID).toEqual(testUTXOID1);
+    expect(
+      (inputUTXOs[0].output as StakeableLockOut).transferOut.amount(),
+    ).toEqual(stakeableUtxoAmt1);
+    expect(inputUTXOs[1].utxoId.txID).toEqual(testUTXOID2);
+    expect(
+      (inputUTXOs[1].output as StakeableLockOut).transferOut.amount(),
+    ).toEqual(stakeableUtxoAmt2);
+  });
+
+  it('Should not be affected by assets with different asset id', () => {
+    const stakeableUtxoAmt1 = 200000000n;
+    const stakeableUtxoAmt2 = 400000000n;
+    const amountRemainingToStake = 500000000n;
+
+    const { amountsToStake, changeOutputs } = useSpendableLockedUTXOs({
+      amountsToBurn: new Map(),
+      ...defaultSpendResult(),
+      utxos: [
+        getStakeableLockoutOutput(testUTXOID1, stakeableUtxoAmt1),
+        getStakeableLockoutOutput(
+          testUTXOID1,
+          stakeableUtxoAmt2,
+          undefined,
+          Id.fromString('1'),
+        ),
+      ],
+      fromAddresses: addressesFromBytes(fromAddressBytes),
+      amountsToStake: new Map([
+        [testContext.avaxAssetID, amountRemainingToStake],
+      ]), // amount remaining to stake
+      options: { minIssuanceTime: 0 } as any,
+    });
+
+    expect(changeOutputs.length).toEqual(0);
+    expect(amountsToStake.get(testContext.avaxAssetID)).toEqual(
+      amountRemainingToStake - stakeableUtxoAmt1,
+    );
+  });
+});

package/src/vms/pvm/utxoCalculationFns/useSpendableLockedUTXOs.ts

@@ -0,0 +1,119 @@
+import { verifySignaturesMatch } from '../../../vms/utils/calculateSpend/utils';
+import {
+  TransferableOutput,
+  TransferOutput,
+  TransferableInput,
+  TransferInput,
+} from '../../../serializable';
+import { BigIntPr } from '../../../serializable/primitives';
+import { StakeableLockOut, StakeableLockIn } from '../../../serializable/pvm';
+import { isStakeableLockOut } from '../../../utils';
+import { bigIntMin } from '../../../utils/bigintMath';
+import type { UTXOCalculationState } from '../../utils/calculateSpend';
+
+function createTransferableInput(utxo, lockedOutput, out, sigData) {
+  return new TransferableInput(
+    utxo.utxoId,
+    utxo.assetId,
+    new StakeableLockIn(
+      lockedOutput.lockTime,
+      TransferInput.fromNative(out.amount(), sigData.sigIndicies),
+    ),
+  );
+}
+
+function createTransferableOutput(utxo, lockedOutput, out, amt) {
+  return new TransferableOutput(
+    utxo.assetId,
+    new StakeableLockOut(
+      lockedOutput.lockTime,
+      new TransferOutput(new BigIntPr(amt), out.outputOwners),
+    ),
+  );
+}
+
+export function useSpendableLockedUTXOs({
+  amountsToBurn,
+  utxos,
+  fromAddresses,
+  amountsToStake,
+  options,
+  changeOutputs,
+  inputUTXOs,
+  inputs,
+  stakeOutputs,
+  ...state
+}: UTXOCalculationState): UTXOCalculationState {
+  const usableUTXOs = utxos
+    .filter((utxo) => {
+      const out = utxo.output;
+      if (!isStakeableLockOut(out)) {
+        return false;
+      }
+      return options.minIssuanceTime < out.getLocktime();
+    })
+    .map((utxo) => {
+      const assetId = utxo.assetId.value();
+      // If this is 0n then either we are not staking any of this asset or the amount left to stak is zero
+      const remainingAmountToStake = amountsToStake.get(assetId) ?? 0n;
+      const lockedOutput = utxo.output as StakeableLockOut;
+      return { utxo, assetId, remainingAmountToStake, lockedOutput };
+    })
+    .filter(({ remainingAmountToStake }) => {
+      return !!remainingAmountToStake;
+    })
+    .filter(({ lockedOutput }) => {
+      if (!(lockedOutput.transferOut instanceof TransferOutput)) {
+        throw new Error('unknown output type');
+      }
+
+      return options.minIssuanceTime < lockedOutput.lockTime.value();
+    });
+  verifySignaturesMatch(
+    usableUTXOs,
+    ({ lockedOutput }) => {
+      return lockedOutput.transferOut as TransferOutput;
+    },
+    fromAddresses,
+    options,
+  ).forEach(({ sigData, data: { utxo, assetId, lockedOutput } }) => {
+    const out = lockedOutput.transferOut as TransferOutput;
+    const remainingAmountToStake = amountsToStake.get(assetId) ?? 0n;
+
+    // if we have already reached the stake amount then there is nothing left to run beyond here
+    if (!remainingAmountToStake) return;
+
+    inputs.push(createTransferableInput(utxo, lockedOutput, out, sigData));
+
+    inputUTXOs.push(utxo);
+
+    // check if this UTXO value is greater than the amount left to stake
+    const amountToStake = bigIntMin(remainingAmountToStake, out.amt.value());
+
+    stakeOutputs.push(
+      createTransferableOutput(utxo, lockedOutput, out, amountToStake),
+    );
+    // update the remaining stake amount minus this UTXOs value
+    amountsToStake.set(assetId, remainingAmountToStake - amountToStake);
+    const remainingAmount = out.amount() - amountToStake;
+
+    if (remainingAmount > 0n) {
+      changeOutputs.push(
+        createTransferableOutput(utxo, lockedOutput, out, remainingAmount),
+      );
+    }
+  });
+
+  return {
+    ...state,
+    amountsToBurn,
+    utxos,
+    fromAddresses,
+    amountsToStake,
+    options,
+    changeOutputs,
+    inputUTXOs,
+    inputs,
+    stakeOutputs,
+  };
+}

package/src/vms/pvm/utxoCalculationFns/useUnlockedUTXOs.spec.ts

@@ -0,0 +1,26 @@
+import { fromAddressBytes, getValidUtxo } from '../../../fixtures/transactions';
+import { addressesFromBytes } from '../../../utils';
+import { testContext } from '../../../fixtures/context';
+import { useUnlockedUTXOs } from './useUnlockedUTXOs';
+import { BigIntPr } from '../../../serializable/primitives';
+import { defaultSpendResult } from '../../utils/calculateSpend';
+
+describe('src/vms/pvm/spend/useUnlockedUTXOs.spec.ts', () => {
+  it('Should pay gas and stake amount plus have some change', () => {
+    const { changeOutputs, stakeOutputs, amountsToBurn } = useUnlockedUTXOs({
+      ...defaultSpendResult(),
+      amountsToBurn: new Map([[testContext.avaxAssetID, 4900n]]),
+      utxos: [getValidUtxo(new BigIntPr(10000n))],
+      fromAddresses: addressesFromBytes(fromAddressBytes),
+      amountsToStake: new Map([[testContext.avaxAssetID, 4900n]]),
+      options: { changeAddresses: fromAddressBytes } as any,
+    });
+    expect(changeOutputs.length).toEqual(1);
+    expect(BigInt(changeOutputs[0].output.amount())).toEqual(BigInt(200n));
+
+    expect(stakeOutputs.length).toEqual(1);
+    expect(BigInt(stakeOutputs[0].output.amount())).toEqual(BigInt(4900n));
+
+    expect(amountsToBurn.get(testContext.avaxAssetID)).toEqual(0n);
+  });
+});