@bitgo-forks/avalanchejs 4.1.0-alpha.1

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

@@ -0,0 +1,85 @@
+import type { UTXOCalculationState } from '../../utils/calculateSpend';
+import {
+  TransferableInput,
+  TransferableOutput,
+} from '../../../serializable/avax';
+import {
+  OutputOwners,
+  TransferOutput,
+} from '../../../serializable/fxs/secp256k1';
+import { BigIntPr, Int } from '../../../serializable/primitives';
+import { addressesFromBytes, isTransferOut } from '../../../utils';
+import { bigIntMin } from '../../../utils/bigintMath';
+import { verifySignaturesMatch } from '../../../vms/utils/calculateSpend/utils';
+
+// UTXO Spend for coreth/AVM UTXOs
+export const useAvmAndCorethUTXOs = ({
+  amountsToBurn,
+  utxos,
+  options,
+  changeOutputs,
+  inputUTXOs,
+  fromAddresses,
+  inputs,
+  ...state
+}: UTXOCalculationState): UTXOCalculationState => {
+  const changeOwner = new OutputOwners(
+    new BigIntPr(0n),
+    new Int(options.threshold),
+    addressesFromBytes(options.changeAddresses),
+  );
+  verifySignaturesMatch(
+    utxos
+      .filter((utxo) => !!amountsToBurn.get(utxo.assetId.toString()))
+      // We only support burning [secp256k1fx.TransferOutput]s.
+      .filter((utxo) => !!isTransferOut(utxo.output as TransferOutput)),
+    (utxo) => utxo.output as TransferOutput,
+    fromAddresses,
+    options,
+  ).forEach(({ sigData, data: utxo }) => {
+    const utxoTransferout = utxo.output as TransferOutput;
+
+    const remainingAmountToBurn =
+      amountsToBurn.get(utxo.assetId.toString()) ?? 0n;
+
+    const amountToBurn = bigIntMin(
+      remainingAmountToBurn,
+      utxoTransferout.amt.value(),
+    );
+    // if nothing left to burn then lets skip the rest
+    if (!amountToBurn) return;
+
+    amountsToBurn.set(
+      utxo.assetId.toString(),
+      remainingAmountToBurn - amountToBurn,
+    );
+
+    inputs.push(
+      TransferableInput.fromUtxoAndSigindicies(utxo, sigData.sigIndicies),
+    );
+
+    inputUTXOs.push(utxo);
+
+    const remainingAmount = utxoTransferout.amt.value() - amountToBurn;
+
+    if (remainingAmount > 0) {
+      changeOutputs.push(
+        new TransferableOutput(
+          utxo.assetId,
+          new TransferOutput(new BigIntPr(remainingAmount), changeOwner),
+        ),
+      );
+    }
+  });
+
+  return {
+    utxos,
+    fromAddresses,
+    options,
+    ...state,
+    amountsToBurn,
+    inputs,
+    changeOutputs,
+    inputUTXOs,
+  };
+};

package/src/vms/common/apiModels.ts

@@ -0,0 +1,64 @@
+import type { Utxo } from '../../serializable/avax/utxo';
+
+export type GetUTXOsInput = {
+  addresses: string[];
+  limit?: number;
+  startIndex?: {
+    address: string;
+    utxo: string;
+  };
+  sourceChain?: string;
+};
+
+export type GetUTXOsApiResp = {
+  numFetched: number;
+  utxos: string[];
+  endIndex: {
+    address: string;
+    utxo: string;
+  };
+  sourceChain?: string;
+  encoding: string;
+};
+
+export type GetUTXOResponse = Omit<GetUTXOsApiResp, 'utxos'> & {
+  utxos: Utxo[];
+};
+
+export type GetAssetDescriptionResponse = {
+  assetID: string;
+  name: string;
+  symbol: string;
+  denomination: number;
+};
+
+export type AVMContext = {
+  readonly networkID: number;
+  readonly hrp: string;
+  readonly blockchainID: string;
+  readonly avaxAssetID: string;
+  readonly baseTxFee: bigint;
+  readonly createAssetTxFee: bigint;
+};
+
+export interface IssueTxParams {
+  tx: string;
+}
+
+export interface IssueTxResponse {
+  txID: string;
+}
+
+export interface GetTxParams {
+  txID: string;
+}
+
+export interface GetTxStatusParams {
+  txID: string;
+  includeReason?: boolean | true;
+}
+
+export interface GetTxStatusResponse {
+  status: string;
+  reason: string;
+}

package/src/vms/common/avaxApi.ts

@@ -0,0 +1,59 @@
+/* 
+  this class is for shared methods between avm/pvm api's
+*/
+
+import { SignedTx } from '../../serializable/avax';
+import { hexToBuffer } from '../../utils';
+import type { GetAddressTxsParams, GetAddressTxsResponse } from '../avm/models';
+import type { GetBalanceParams, GetBalanceResponse } from '../pvm';
+import type { GetTxServerResponse } from '../pvm/privateModels';
+import type {
+  GetAssetDescriptionResponse,
+  GetTxParams,
+  GetTxStatusParams,
+  GetTxStatusResponse,
+} from './apiModels';
+import { ChainApi } from './chainAPI';
+
+export class AvaxApi extends ChainApi {
+  getAssetDescription(assetID: string): Promise<GetAssetDescriptionResponse> {
+    return this.callRpc<GetAssetDescriptionResponse>('getAssetDescription', {
+      assetID,
+    });
+  }
+
+  getTx = async (getTxParams: GetTxParams) => {
+    const resp = await this.callRpc<GetTxServerResponse>('getTx', {
+      ...getTxParams,
+      encoding: 'hex',
+    });
+    return this.manager.unpack(hexToBuffer(resp.tx), SignedTx);
+  };
+
+  getTxJson = (getTxParams: GetTxParams) => {
+    return this.callRpc<GetTxServerResponse>('getTx', {
+      ...getTxParams,
+      encoding: 'json',
+    });
+  };
+
+  getTxStatus(getTxStatus: GetTxStatusParams): Promise<GetTxStatusResponse> {
+    return this.callRpc<GetTxStatusResponse>('getTxStatus', {
+      includeReason: true,
+      ...getTxStatus,
+    });
+  }
+
+  getBalance(getBalanceParams: GetBalanceParams): Promise<GetBalanceResponse> {
+    return this.callRpc<GetBalanceResponse>('getBalance', getBalanceParams);
+  }
+
+  getAddressTxs(
+    GetAddressTxsParams: GetAddressTxsParams,
+  ): Promise<GetAddressTxsResponse> {
+    return this.callRpc<GetAddressTxsResponse>(
+      'GetAddressTxs',
+      GetAddressTxsParams,
+    );
+  }
+}

package/src/vms/common/baseApi.ts

@@ -0,0 +1,40 @@
+/* 
+  this class has methods that pertain to all api sections
+*/
+
+import { AVAX_PUBLIC_URL } from '../../constants/public-urls';
+import { JrpcProvider } from './rpc';
+
+export abstract class Api {
+  protected rpcProvider: JrpcProvider;
+
+  constructor(
+    baseURL: string = AVAX_PUBLIC_URL,
+    protected path: string,
+    protected base?: string,
+    protected fetchOptions?: RequestInit,
+  ) {
+    this.rpcProvider = new JrpcProvider(baseURL + path);
+  }
+
+  setFetchOptions(options: RequestInit | undefined) {
+    this.fetchOptions = options;
+  }
+
+  protected getMethodName = (methodName: string) => {
+    if (!this.base) {
+      return methodName;
+    }
+    return `${this.base}.${methodName}`;
+  };
+
+  protected callRpc = <T>(
+    methodName: string,
+    params?: Array<Record<string, any>> | Record<string, any>,
+  ): Promise<T> =>
+    this.rpcProvider.callMethod<T>(
+      this.getMethodName(methodName),
+      params,
+      this.fetchOptions,
+    );
+}

package/src/vms/common/builder.ts

@@ -0,0 +1,45 @@
+import type { TransferableInput, TransferableOutput } from '../../serializable';
+import type { Context } from '../context/model';
+import { BaseTx as AvaxBaseTx } from '../../serializable/avax';
+
+/**
+ * format a BaseTx for xChain directly from inputs with no validation
+ * @param changeOutputs - the output representing the remaining amounts from each input
+ * @param inputs - the inputs of the tx
+ * @param memo - optional memo
+ */
+export const baseTxUnsafeAvm = (
+  context: Context,
+  changeOutputs: TransferableOutput[],
+  inputs: TransferableInput[],
+  memo: Uint8Array,
+) => {
+  return AvaxBaseTx.fromNative(
+    context.networkID,
+    context.xBlockchainID,
+    changeOutputs,
+    inputs,
+    memo,
+  );
+};
+
+/**
+ * format a BaseTx for pChain directly from inputs with no validation
+ * @param changeOutputs - the output representing the remaining amounts from each input
+ * @param inputs - the inputs of the tx
+ * @param memo - optional memo
+ */
+export const baseTxUnsafePvm = (
+  context: Context,
+  changeOutputs: TransferableOutput[],
+  inputs: TransferableInput[],
+  memo: Uint8Array,
+) => {
+  return AvaxBaseTx.fromNative(
+    context.networkID,
+    context.pBlockchainID,
+    changeOutputs,
+    inputs,
+    memo,
+  );
+};

package/src/vms/common/chainAPI.ts

@@ -0,0 +1,53 @@
+/* 
+  this class includes methods that are shared between all three chains/vms
+*/
+
+import { AVAX_PUBLIC_URL } from '../../constants/public-urls';
+import type { SignedTx } from '../../serializable/avax';
+import { Utxo } from '../../serializable/avax/utxo';
+import type { Manager } from '../../serializable/codec';
+import { addChecksum } from '../../utils';
+import { bufferToHex, hexToBuffer } from '../../utils/buffer';
+import type {
+  GetUTXOsApiResp,
+  GetUTXOsInput,
+  IssueTxParams,
+  IssueTxResponse,
+} from './apiModels';
+import { Api } from './baseApi';
+
+export abstract class ChainApi extends Api {
+  constructor(
+    baseURL: string = AVAX_PUBLIC_URL,
+    protected path: string,
+    protected base: string,
+    protected manager: Manager,
+  ) {
+    super(baseURL, path, base);
+  }
+
+  async getUTXOs(input: GetUTXOsInput) {
+    const resp = await this.callRpc<GetUTXOsApiResp>('getUTXOs', {
+      ...input,
+      encoding: 'hex',
+    });
+    const utxos = resp.utxos.map((utxoHex) =>
+      this.manager.unpack(hexToBuffer(utxoHex), Utxo),
+    );
+
+    return {
+      ...resp,
+      utxos,
+    };
+  }
+
+  issueTx(issueTxParams: IssueTxParams): Promise<IssueTxResponse> {
+    return this.callRpc<IssueTxResponse>('issueTx', issueTxParams);
+  }
+
+  issueSignedTx(tx: SignedTx): Promise<IssueTxResponse> {
+    return this.issueTx({
+      tx: bufferToHex(addChecksum(tx.toBytes())),
+    });
+  }
+}

package/src/vms/common/defaultSpendOptions.ts

@@ -0,0 +1,15 @@
+import type { SpendOptions, SpendOptionsRequired } from './models';
+
+export const defaultSpendOptions = (
+  fromAddress: Uint8Array[],
+  options?: SpendOptions,
+): SpendOptionsRequired => {
+  return {
+    minIssuanceTime: BigInt(Math.floor(new Date().getTime() / 1000)),
+    changeAddresses: fromAddress,
+    threshold: 1,
+    memo: new Uint8Array(),
+    locktime: 0n,
+    ...options,
+  };
+};

package/src/vms/common/evmUnsignedTx.test.ts

@@ -0,0 +1,47 @@
+import { signature } from '../../fixtures/secp256k1';
+import { exportTx } from '../../fixtures/evm';
+import { testEthAddress1, testPrivateKey1 } from '../../fixtures/vms';
+import { Address } from '../../serializable/fxs/common';
+import { secp256k1 } from '../../crypto';
+import { AddressMap, AddressMaps } from '../../utils/addressMap';
+import { EVMUnsignedTx } from './evmUnsignedTx';
+
+describe('EVMUnsignedTx', () => {
+  let addressMaps: AddressMaps;
+
+  beforeEach(() => {
+    addressMaps = new AddressMaps([
+      new AddressMap([[new Address(testEthAddress1), 0]]),
+    ]);
+  });
+
+  it('hasAllSignatures', async () => {
+    const tx = exportTx();
+    const unsignedTx = new EVMUnsignedTx(tx, [], addressMaps);
+    const unsignedBytes = unsignedTx.toBytes();
+
+    expect(unsignedTx.hasAllSignatures()).toBeFalsy();
+
+    const sig = await secp256k1.sign(unsignedBytes, testPrivateKey1);
+    unsignedTx.addSignature(sig);
+
+    expect(unsignedTx.hasAllSignatures()).toBeTruthy();
+  });
+
+  it('serializes', () => {
+    const tx = exportTx();
+    const unsignedTx = new EVMUnsignedTx(tx, [], addressMaps);
+
+    unsignedTx.addSignatureAt(signature().toBytes(), 0, 0);
+
+    const unsignedTxJson = JSON.stringify(unsignedTx);
+    const serializedTx = EVMUnsignedTx.fromJSON(unsignedTxJson);
+
+    // workaround until this jest bug (https://github.com/facebook/jest/issues/12377) gets fixed
+    // jest fails to parse bigints in the tx.ins, so we check the tx properties' byte representation instead
+    expect(unsignedTx.toBytes()).toStrictEqual(serializedTx.toBytes());
+    expect(unsignedTx.utxos).toStrictEqual(serializedTx.utxos);
+    expect(unsignedTx.addressMaps).toStrictEqual(serializedTx.addressMaps);
+    expect(unsignedTx.credentials).toStrictEqual(serializedTx.credentials);
+  });
+});

package/src/vms/common/evmUnsignedTx.ts

@@ -0,0 +1,17 @@
+import { secp256k1 } from '../../crypto';
+import { UnsignedTx } from './unsignedTx';
+import { Address } from '../../serializable/fxs/common';
+
+export class EVMUnsignedTx extends UnsignedTx {
+  hasPubkey(pubKey: Uint8Array): boolean {
+    const addrAvax = new Address(this.publicKeyBytesToAddress(pubKey));
+    const addrEVM = new Address(secp256k1.publicKeyToEthAddress(pubKey));
+
+    return this.hasAddress(addrAvax) || this.hasAddress(addrEVM);
+  }
+
+  static fromJSON(jsonStr: string) {
+    const tx = UnsignedTx.fromJSON(jsonStr);
+    return new EVMUnsignedTx(tx.tx, tx.utxos, tx.addressMaps, tx.credentials);
+  }
+}

package/src/vms/common/index.ts

@@ -0,0 +1,6 @@
+export * from './apiModels';
+export * from './builder';
+export * from './models';
+export { AvaxApi } from './avaxApi';
+export { UnsignedTx } from './unsignedTx';
+export { Transaction } from './transaction';

package/src/vms/common/models.ts

@@ -0,0 +1,13 @@
+export type SpendOptions = {
+  minIssuanceTime?: bigint;
+  changeAddresses?: Uint8Array[];
+  threshold?: number;
+  memo?: Uint8Array;
+  locktime?: bigint;
+};
+
+export type SpendOptionsRequired = Required<SpendOptions>;
+
+//the strign is address in hex
+export type SigMapping = Map<string, number>;
+export type SigMappings = SigMapping[];

package/src/vms/common/rpc.ts

@@ -0,0 +1,61 @@
+export type RpcCallOptions = {
+  headers?: Record<string, string>;
+};
+
+type JsonRpcSuccessResp<T> = {
+  jsonrpc: string;
+  result: T;
+  id: number;
+  error?: undefined;
+};
+
+interface JsonRpcError {
+  code: number;
+  message: string;
+  data?: any;
+}
+
+type JsonRpcErrorResp = {
+  jsonrpc: string;
+  id: number;
+  result?: undefined;
+  error: JsonRpcError;
+};
+
+export class JrpcProvider {
+  private reqId = 0;
+
+  constructor(private readonly url: string) {}
+
+  async callMethod<T>(
+    method: string,
+    parameters?: Array<Record<string, any>> | Record<string, any>,
+    fetchOptions?: RequestInit,
+  ): Promise<T> {
+    const body = {
+      jsonrpc: '2.0',
+      id: this.reqId++,
+      method,
+      params: parameters,
+    };
+    const resp = await fetch(this.url, {
+      ...fetchOptions,
+      method: 'POST',
+      body: JSON.stringify(body),
+      headers: {
+        'Content-Type': 'application/json',
+        ...fetchOptions?.headers,
+      },
+    })
+      .then(async (r) => {
+        return r.json();
+      })
+      .then((data) => data as JsonRpcSuccessResp<T> | JsonRpcErrorResp);
+
+    if (resp.error) throw new Error(resp.error.message);
+
+    return resp.result;
+  }
+
+  // TODO: Batch RPC call
+}

package/src/vms/common/transaction.ts

@@ -0,0 +1,15 @@
+import type { Codec } from '../../serializable/codec';
+import type { VM, TypeSymbols } from '../../serializable/constants';
+
+export abstract class Transaction {
+  abstract _type: TypeSymbols;
+  abstract toBytes(codec: Codec): Uint8Array;
+  abstract vm: VM;
+  abstract getBlockchainId(): string;
+
+  abstract getSigIndices(): number[][];
+
+  getVM() {
+    return this.vm;
+  }
+}

package/src/vms/common/types.ts

@@ -0,0 +1,28 @@
+import type { Codec } from '../../serializable/codec';
+import type { TypeSymbols } from '../../serializable/constants';
+
+export interface Serializable {
+  _type: TypeSymbols;
+
+  toBytes(codec: Codec): Uint8Array;
+}
+
+export interface SerializableStatic {
+  new (...args: any[]): Serializable;
+
+  fromBytes(bytes: Uint8Array, codec: Codec): [Serializable, Uint8Array];
+}
+
+export function staticImplements<T>() {
+  return <U extends T>(constructor: U) => {
+    constructor;
+  };
+}
+
+export function serializable() {
+  return staticImplements<SerializableStatic>();
+}
+
+export interface Amounter extends Serializable {
+  amount(): bigint;
+}