@bitgo-forks/avalanchejs 4.1.0-alpha.1

package/src/utils/validateBurnedAmount.ts

@@ -0,0 +1,136 @@
+import type { Context } from '../vms/context/model';
+import {
+  isAddDelegatorTx,
+  isAddPermissionlessDelegatorTx,
+  isAddPermissionlessValidatorTx,
+  isAddSubnetValidatorTx,
+  isAddValidatorTx,
+  isCreateChainTx,
+  isCreateSubnetTx,
+  isPvmBaseTx,
+  isExportTx as isPvmExportTx,
+  isImportTx as isPvmImportTx,
+  isRemoveSubnetValidatorTx,
+  isTransferSubnetOwnershipTx,
+  isTransformSubnetTx,
+} from '../serializable/pvm';
+import type { Transaction, UnsignedTx } from '../vms/common';
+import type { EVMTx } from '../serializable/evm';
+import { isImportExportTx as isEvmImportExportTx } from '../serializable/evm';
+import { costCorethTx } from './costs';
+import {
+  isAvmBaseTx,
+  isExportTx as isAvmExportTx,
+  isImportTx as isAvmImportTx,
+} from '../serializable/avm';
+import { getBurnedAmountByTx } from './getBurnedAmountByTx';
+import type { AvaxTx } from '../serializable/avax';
+import { PrimaryNetworkID } from '../constants/networkIDs';
+
+const _getBurnedAmount = (tx: Transaction, context: Context) => {
+  const burnedAmounts = getBurnedAmountByTx(tx as AvaxTx | EVMTx);
+  return burnedAmounts.get(context.avaxAssetID) ?? 0n;
+};
+
+export const validateBurnedAmount = ({
+  unsignedTx,
+  context,
+  burnedAmount,
+  evmBaseFee,
+  evmFeeTolerance,
+}: {
+  unsignedTx: UnsignedTx;
+  context: Context;
+  burnedAmount?: bigint;
+  evmBaseFee?: bigint; // fetched from the network and converted into nAvax (https://docs.avax.network/quickstart/transaction-fees#c-chain-fees)
+  evmFeeTolerance?: number; // tolerance percentage range where the burned amount is considered valid. e.g.: with evmFeeTolerance = 20% -> (evmBaseFee * 0.8 <= burnedAmount <= evmBaseFee * 1.2)
+}): { isValid: boolean; txFee: bigint } => {
+  const tx = unsignedTx.getTx();
+  const burned = burnedAmount ?? _getBurnedAmount(tx, context);
+
+  const validate = (expectedAmount: bigint) => ({
+    isValid: burned === expectedAmount,
+    txFee: expectedAmount,
+  });
+
+  if (isEvmImportExportTx(tx)) {
+    if (!evmBaseFee || !evmFeeTolerance) {
+      throw new Error('missing evm fee data');
+    }
+
+    const feeToleranceInt = Math.floor(evmFeeTolerance);
+
+    if (feeToleranceInt < 1 || feeToleranceInt > 100) {
+      throw new Error('evmFeeTolerance must be [1,100]');
+    }
+
+    const feeAmount = evmBaseFee * costCorethTx(unsignedTx);
+    const min = (feeAmount * (100n - BigInt(feeToleranceInt))) / 100n;
+    const max = (feeAmount * (100n + BigInt(feeToleranceInt))) / 100n;
+
+    return {
+      isValid: burned >= min && burned <= max,
+      txFee: burned,
+    };
+  }
+
+  if (isAddValidatorTx(tx)) {
+    return validate(context.addPrimaryNetworkValidatorFee);
+  }
+
+  if (isAddDelegatorTx(tx)) {
+    return validate(context.addPrimaryNetworkDelegatorFee);
+  }
+
+  if (isCreateSubnetTx(tx)) {
+    return validate(context.createSubnetTxFee);
+  }
+
+  if (isCreateChainTx(tx)) {
+    return validate(context.createBlockchainTxFee);
+  }
+
+  if (isAddSubnetValidatorTx(tx)) {
+    return validate(context.addSubnetValidatorFee);
+  }
+
+  if (isTransformSubnetTx(tx)) {
+    return validate(context.transformSubnetTxFee);
+  }
+
+  if (isAddPermissionlessValidatorTx(tx)) {
+    const isPrimarySubnet =
+      tx.subnetValidator.subnetId.toString() === PrimaryNetworkID.toString();
+
+    return validate(
+      isPrimarySubnet
+        ? context.addPrimaryNetworkValidatorFee
+        : context.addSubnetValidatorFee,
+    );
+  }
+
+  if (isAddPermissionlessDelegatorTx(tx)) {
+    const isPrimarySubnet =
+      tx.subnetValidator.subnetId.toString() === PrimaryNetworkID.toString();
+    return validate(
+      isPrimarySubnet
+        ? context.addPrimaryNetworkDelegatorFee
+        : context.addSubnetDelegatorFee,
+    );
+  }
+
+  if (
+    isAvmBaseTx(tx) ||
+    isPvmBaseTx(tx) ||
+    isAvmExportTx(tx) ||
+    isAvmImportTx(tx) ||
+    isPvmExportTx(tx) ||
+    isPvmImportTx(tx) ||
+    isRemoveSubnetValidatorTx(tx) ||
+    isTransferSubnetOwnershipTx(tx)
+  ) {
+    return validate(context.baseTxFee);
+  }
+
+  throw new Error(`tx type is not supported`);
+};

package/src/vms/avm/api.ts

@@ -0,0 +1,36 @@
+import { getAVMManager } from '../../serializable/avm/codec';
+import { AvaxApi } from '../common/avaxApi';
+import type {
+  BuildGenesisParams,
+  BuildGenesisResponse,
+  GetAllBalancesParams,
+  GetAllBalancesResponse,
+} from './models';
+
+export class AVMApi extends AvaxApi {
+  constructor(baseURL?: string) {
+    super(baseURL, '/ext/bc/X', 'avm', getAVMManager());
+  }
+
+  /**
+   * Given a JSON representation of this Virtual Machine’s genesis state, create the byte representation of that state.
+   *
+   * @param genesisData The blockchain's genesis data object
+   *
+   * @returns Promise of a string of bytes
+   */
+  buildGenesis = async (
+    params: BuildGenesisParams,
+  ): Promise<BuildGenesisResponse> => {
+    return await this.callRpc<BuildGenesisResponse>('buildGenesis', params);
+  };
+
+  getAllBalances(
+    getAllBalancesParams: GetAllBalancesParams,
+  ): Promise<GetAllBalancesResponse> {
+    return this.callRpc<GetAllBalancesResponse>(
+      'getAllBalances',
+      getAllBalancesParams,
+    );
+  }
+}

package/src/vms/avm/builder.spec.ts

@@ -0,0 +1,189 @@
+import { testContext } from '../../fixtures/context';
+import {
+  testAvaxAssetID,
+  testOwnerXAddress,
+  testUtxos,
+} from '../../fixtures/transactions';
+import {
+  TransferableInput,
+  TransferableOutput,
+  UTXOID,
+} from '../../serializable/avax';
+import { Utxo } from '../../serializable/avax/utxo';
+import type { BaseTx, ExportTx, ImportTx } from '../../serializable/avm';
+import { Id } from '../../serializable/fxs/common';
+import {
+  Input,
+  OutputOwners,
+  TransferInput,
+  TransferOutput,
+} from '../../serializable/fxs/secp256k1';
+import { BigIntPr, Int } from '../../serializable/primitives';
+import { hexToBuffer } from '../../utils';
+import { newExportTx, newImportTx } from '../pvm';
+import { newBaseTx } from './builder';
+
+describe('AVMBuilder', () => {
+  let utxos: Utxo[];
+  beforeEach(() => {
+    utxos = testUtxos();
+  });
+  it('importTx', async () => {
+    const toAddress = hexToBuffer('0x5432112345123451234512');
+    const tx = newImportTx(
+      testContext,
+      testContext.cBlockchainID,
+      utxos,
+      [toAddress],
+      [testOwnerXAddress.toBytes()],
+    );
+
+    const importTx = tx.getTx() as ImportTx;
+
+    expect(importTx.ins).toHaveLength(1);
+    expect(importTx.ins[0].assetId).toEqual(testAvaxAssetID);
+    expect(Number(importTx.ins[0].amount())).toEqual(50 * 1e9);
+    expect(importTx.ins[0].utxoID.ID()).toEqual(utxos[2].ID());
+  });
+
+  it('importTx Low amt', async () => {
+    const toAddress = hexToBuffer('0x5432112345123451234512');
+    utxos[2] = new Utxo(
+      new UTXOID(Id.fromHex('0x1234512345123451234516'), new Int(0)),
+      testAvaxAssetID,
+      new TransferOutput(
+        new BigIntPr(BigInt(50 * 1e5)),
+        OutputOwners.fromNative([testOwnerXAddress.toBytes()]),
+      ),
+    );
+
+    const tx = newImportTx(
+      testContext,
+      testContext.cBlockchainID,
+      utxos,
+      [toAddress],
+      [testOwnerXAddress.toBytes()],
+    );
+
+    const importTx = tx.getTx() as ImportTx;
+
+    expect(importTx.ins).toHaveLength(1);
+    expect(importTx.ins[0].assetId).toEqual(testAvaxAssetID);
+    expect(Number(importTx.ins[0].amount())).toEqual(50 * 1e5);
+    expect((importTx.baseTx.outputs as TransferableOutput[])[0].amount()).toBe(
+      BigInt(40 * 1e5),
+    );
+    expect(importTx.ins[0].utxoID.ID()).toEqual(utxos[2].ID());
+  });
+
+  it('importTx no utxos available', async () => {
+    const toAddress = hexToBuffer('0x5432112345123451234512');
+    utxos.pop();
+
+    expect(() =>
+      newImportTx(
+        testContext,
+        testContext.cBlockchainID,
+        utxos,
+        [toAddress],
+        [testOwnerXAddress.toBytes()],
+      ),
+    ).toThrow();
+  });
+
+  it('exportTx', () => {
+    const toAddress = hexToBuffer('0x5432112345123451234512');
+    const tnsOut = TransferableOutput.fromNative(
+      testAvaxAssetID.toString(),
+      BigInt(5 * 1e9),
+      [toAddress],
+    );
+    const tx = newExportTx(
+      testContext,
+      testContext.cBlockchainID,
+      [testOwnerXAddress.toBytes()],
+      utxos,
+      [tnsOut],
+    );
+    const exportTx = tx.getTx() as ExportTx;
+    expect(exportTx.outs as TransferableOutput[]).toEqual([tnsOut]);
+    expect(exportTx.baseTx.inputs as TransferableInput[]).toEqual([
+      new TransferableInput(
+        utxos[2].utxoId,
+        testAvaxAssetID,
+        new TransferInput(
+          new BigIntPr(BigInt(50 * 1e9)),
+          Input.fromNative([0]),
+        ),
+      ),
+    ]);
+
+    expect(exportTx.baseTx.outputs as TransferableOutput[]).toEqual([
+      new TransferableOutput(
+        testAvaxAssetID,
+        new TransferOutput(
+          new BigIntPr(44999000000n),
+          OutputOwners.fromNative([testOwnerXAddress.toBytes()]),
+        ),
+      ),
+    ]);
+  });
+
+  it('exportTx', () => {
+    const toAddress = hexToBuffer('0x5432112345123451234512');
+    const tnsOut = TransferableOutput.fromNative(
+      testAvaxAssetID.toString(),
+      BigInt(5 * 1e9),
+      [toAddress],
+    );
+    utxos.pop();
+    expect(() =>
+      newExportTx(
+        testContext,
+        testContext.cBlockchainID,
+        [testOwnerXAddress.toBytes()],
+        utxos,
+        [tnsOut],
+      ),
+    ).toThrow();
+  });
+
+  it('baseTx', () => {
+    const toAddress = hexToBuffer('0x5432112345123451234512');
+    const tnsOut = TransferableOutput.fromNative(
+      testAvaxAssetID.toString(),
+      BigInt(1 * 1e9),
+      [toAddress],
+    );
+    const tx = newBaseTx(testContext, [testOwnerXAddress.toBytes()], utxos, [
+      tnsOut,
+    ]);
+    const {
+      baseTx: { inputs, outputs },
+    } = tx.getTx() as BaseTx;
+
+    expect(outputs.length).toEqual(2);
+    expect(outputs as TransferableOutput[]).toEqual([
+      tnsOut,
+      new TransferableOutput(
+        testAvaxAssetID,
+        new TransferOutput(
+          new BigIntPr(48999000000n), // input - amount sent - fee
+          OutputOwners.fromNative([testOwnerXAddress.toBytes()]),
+        ),
+      ),
+    ]);
+
+    expect(inputs.length).toEqual(1);
+    expect(inputs as TransferableInput[]).toEqual([
+      new TransferableInput(
+        utxos[2].utxoId,
+        testAvaxAssetID,
+        new TransferInput(
+          new BigIntPr(BigInt(50 * 1e9)),
+          Input.fromNative([0]),
+        ),
+      ),
+    ]);
+  });
+});

package/src/vms/avm/builder.ts

@@ -0,0 +1,269 @@
+import {
+  BaseTx as AvaxBaseTx,
+  TransferableInput,
+  TransferableOutput,
+} from '../../serializable/avax';
+import type { Utxo } from '../../serializable/avax/utxo';
+import { ExportTx, ImportTx } from '../../serializable/avm';
+import { Id } from '../../serializable/fxs/common';
+import { addressesFromBytes } from '../../utils';
+import { AddressMaps } from '../../utils/addressMap';
+import { getImportedInputsFromUtxos } from '../../utils/builderUtils';
+import { compareTransferableOutputs } from '../../utils/sort';
+import { transferableAmounts } from '../../utils/transferableAmounts';
+import { defaultSpendOptions } from '../common/defaultSpendOptions';
+import type { SpendOptions } from '../common/models';
+import { UnsignedTx } from '../common/unsignedTx';
+import type { Context } from '../context/model';
+import { BaseTx } from '../../serializable/avm/baseTx';
+import type { UTXOCalculationResult } from '../utils/calculateSpend';
+import { calculateUTXOSpend } from '../utils/calculateSpend';
+import { useAvmAndCorethUTXOs } from './utxoCalculationFns';
+import { baseTxUnsafeAvm } from '../common';
+
+/**
+ *
+ * @param sourceChainId id of the chain to import from
+ * @param utxos list of utxos
+ * @param toAddresses addresses to import the tx
+ * @param fromAddressesBytes used to filter UTXOs
+ * @param options used to filter UTXOs
+ * @param threshold number of signers to put on the resulting utxo
+ * @param locktime time the resulting utxo unlocks
+ * @returns
+ */
+export function newImportTx(
+  context: Context,
+  sourceChainId: string,
+  utxos: Utxo[],
+  toAddresses: Uint8Array[],
+  fromAddressesBytes: Uint8Array[],
+  options?: SpendOptions,
+  threshold = 1,
+  locktime = 0n,
+) {
+  const fromAddresses = addressesFromBytes(fromAddressesBytes);
+  const defaultedOptions = defaultSpendOptions(fromAddressesBytes, options);
+  const { importedAmounts, importedInputs, inputUTXOs } =
+    getImportedInputsFromUtxos(
+      utxos,
+      fromAddressesBytes,
+      defaultedOptions.minIssuanceTime,
+    );
+
+  if (!importedInputs.length) {
+    throw new Error('no UTXOs available to import');
+  }
+
+  importedInputs.sort(TransferableInput.compare);
+  const addressMaps = AddressMaps.fromTransferableInputs(
+    importedInputs,
+    utxos,
+    defaultedOptions.minIssuanceTime,
+    fromAddressesBytes,
+  );
+  const importedAvax = importedAmounts[context.avaxAssetID] ?? 0n;
+
+  let inputOutputs: UTXOCalculationResult = {
+    inputs: [],
+    inputUTXOs: [],
+    stakeOutputs: [],
+    changeOutputs: [],
+    addressMaps: new AddressMaps(),
+  };
+
+  const txFee = context.baseTxFee;
+  const avaxAssetID = context.avaxAssetID;
+
+  if (importedAvax > txFee) {
+    importedAmounts[avaxAssetID] -= txFee;
+  } else {
+    if (importedAvax < txFee) {
+      const toBurn = new Map<string, bigint>([
+        [avaxAssetID, txFee - importedAvax],
+      ]);
+
+      inputOutputs = calculateUTXOSpend(
+        toBurn,
+        undefined,
+        utxos,
+        fromAddresses,
+        defaultedOptions,
+        [useAvmAndCorethUTXOs],
+      );
+    }
+    delete importedAmounts[avaxAssetID];
+  }
+
+  inputUTXOs.push(...(inputOutputs.inputUTXOs || []));
+  addressMaps.merge(inputOutputs.addressMaps || new AddressMaps());
+
+  Object.entries(importedAmounts).forEach(([assetID, amount]) => {
+    inputOutputs.changeOutputs.push(
+      TransferableOutput.fromNative(
+        assetID,
+        amount,
+        toAddresses,
+        locktime,
+        threshold,
+      ),
+    );
+  });
+
+  return new UnsignedTx(
+    new ImportTx(
+      AvaxBaseTx.fromNative(
+        context.networkID,
+        context.xBlockchainID,
+        inputOutputs.changeOutputs || [],
+        inputOutputs.inputs || [],
+        defaultedOptions.memo,
+      ),
+      Id.fromString(sourceChainId),
+      importedInputs,
+    ),
+    inputUTXOs,
+    addressMaps,
+  );
+}
+
+/**
+ * Format export Tx given a set of utxos. The priority is determined by the order of the utxo
+ * array. Fee is automatically added
+ * @param destinationChain - id of the destination chain
+ * @param fromAddresses - used for selecting which utxos are signable
+ * @param utxoSet - list of utxos to spend from
+ * @param outputs - the final desired output
+ * @param options - see SpendingOptions
+ */
+export function newExportTx(
+  context: Context,
+  destinationChain: string,
+  fromAddressesBytes: Uint8Array[],
+  utxoSet: Utxo[],
+  outputs: TransferableOutput[],
+  options?: SpendOptions,
+) {
+  const fromAddresses = addressesFromBytes(fromAddressesBytes);
+  const defaultedOptions = defaultSpendOptions(fromAddressesBytes, options);
+  const toBurn = new Map<string, bigint>([
+    [context.avaxAssetID, context.baseTxFee],
+  ]);
+
+  outputs.forEach((out) => {
+    const assetId = out.assetId.value();
+    toBurn.set(assetId, (toBurn.get(assetId) || 0n) + out.output.amount());
+  });
+
+  const { inputs, changeOutputs, inputUTXOs, addressMaps } = calculateUTXOSpend(
+    toBurn,
+    undefined,
+    utxoSet,
+    fromAddresses,
+    defaultedOptions,
+    [useAvmAndCorethUTXOs],
+  );
+  outputs.sort(compareTransferableOutputs);
+  return exportTxUnsafe(
+    context,
+    outputs,
+    changeOutputs,
+    inputs,
+    destinationChain,
+    defaultedOptions.memo,
+    inputUTXOs,
+    addressMaps,
+  );
+}
+
+/**
+ * Format base Tx given a set of utxos. The priority is determined by the order of the utxo
+ * array. Fee is automatically added
+ * @param fromAddresses - used for selecting which utxos are signable
+ * @param utxoSet - list of utxos to spend from
+ * @param outputs - the desired output (change outputs will be added to them automatically)
+ * @param options - see SpendingOptions
+ */
+export function newBaseTx(
+  context: Context,
+  fromAddressesBytes: Uint8Array[],
+  utxoSet: Utxo[],
+  outputs: TransferableOutput[],
+  options?: SpendOptions,
+) {
+  const fromAddresses = addressesFromBytes(fromAddressesBytes);
+  const defaultedOptions = defaultSpendOptions(fromAddressesBytes, options);
+  const toBurn = new Map<string, bigint>([
+    [context.avaxAssetID, context.baseTxFee],
+  ]);
+
+  outputs.forEach((out) => {
+    const assetId = out.assetId.value();
+    toBurn.set(assetId, (toBurn.get(assetId) || 0n) + out.output.amount());
+  });
+
+  const { inputs, inputUTXOs, changeOutputs, addressMaps } = calculateUTXOSpend(
+    toBurn,
+    undefined,
+    utxoSet,
+    fromAddresses,
+    defaultedOptions,
+    [useAvmAndCorethUTXOs],
+  );
+
+  const allOutputs = [...outputs, ...changeOutputs];
+  allOutputs.sort(compareTransferableOutputs);
+
+  return new UnsignedTx(
+    new BaseTx(
+      baseTxUnsafeAvm(context, allOutputs, inputs, defaultedOptions.memo),
+    ),
+    inputUTXOs,
+    addressMaps,
+  );
+}
+
+/**
+ * Format export Tx based on inputs directly. extra inputs amounts are burned
+ * @param outputs - the total output for the tx
+ * @param changeOutputs - the output representing the remaining amounts from each input
+ * @param inputs - the inputs of the tx
+ * @param destinationChain - id of the destination chain
+ * @param memo - optional memo
+ */
+const exportTxUnsafe = (
+  context: Context,
+  outputs: TransferableOutput[],
+  changeOutputs: TransferableOutput[],
+  inputs: TransferableInput[],
+  destinationChain: string,
+  memo: Uint8Array,
+  inputUtxos: Utxo[],
+  sigMappings: AddressMaps,
+) => {
+  outputs.sort(compareTransferableOutputs);
+
+  const outputAmts = transferableAmounts([...outputs, ...changeOutputs]);
+
+  const inputAmts = transferableAmounts(inputs);
+
+  // check outputs and change outputs are all covered by inputs given
+  // extra inputs are burned and is allowed
+  const allOutputsCovered = Object.entries(outputAmts).every(
+    ([assetID, amount]) => inputAmts[assetID] && inputAmts[assetID] >= amount,
+  );
+
+  if (!allOutputsCovered) {
+    throw new Error('Not enough inputs to cover the outputs');
+  }
+
+  return new UnsignedTx(
+    new ExportTx(
+      baseTxUnsafeAvm(context, changeOutputs, inputs, memo),
+      Id.fromString(destinationChain),
+      outputs,
+    ),
+    inputUtxos,
+    sigMappings,
+  );
+};

package/src/vms/avm/index.ts

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

package/src/vms/avm/models.ts

@@ -0,0 +1,37 @@
+export interface BuildGenesisParams {
+  genesisData: object;
+}
+
+export interface BuildGenesisResponse {
+  bytes: string;
+  encoding: string;
+}
+
+export interface GetAllBalancesParams {
+  address: string;
+}
+
+export interface GetAllBalancesResponse {
+  balances: { asset: string; balance: number }[];
+}
+
+export interface GetBalanceParams {
+  address: string;
+  assetID: string;
+}
+
+export interface GetBalanceResponse {
+  balance: number;
+}
+
+export interface GetAddressTxsParams {
+  address: string;
+  cursor?: bigint;
+  assetID: string;
+  pageSize?: bigint;
+}
+
+export interface GetAddressTxsResponse {
+  txIDs: string[];
+  cursor: bigint;
+}

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

@@ -0,0 +1 @@
+export * from './useAvmAndCorethUTXOs';