@bitgo-forks/avalanchejs 4.1.0-alpha.1

package/src/vms/common/unsignedTx.spec.ts

@@ -0,0 +1,192 @@
+import {
+  transferableOutput,
+  transferableOutputs,
+  utxoId,
+} from '../../fixtures/avax';
+import { id } from '../../fixtures/common';
+import { bigIntPr, bytes, int } from '../../fixtures/primitives';
+import { signature, transferOutput } from '../../fixtures/secp256k1';
+import {
+  testAddress1,
+  testAddress2,
+  testPublicKey1,
+  testPrivateKey1,
+  testPrivateKey2,
+  testPublicKey2,
+} from '../../fixtures/vms';
+import { BaseTx, TransferableInput } from '../../serializable/avax';
+import { Utxo } from '../../serializable/avax/utxo';
+import { ExportTx } from '../../serializable/avm';
+import { Address } from '../../serializable/fxs/common';
+import { Input, TransferInput } from '../../serializable/fxs/secp256k1';
+import { secp256k1 } from '../../crypto';
+import { AddressMap, AddressMaps } from '../../utils/addressMap';
+import { UnsignedTx } from './unsignedTx';
+
+describe('UnsignedTx', () => {
+  let addressMaps: AddressMaps;
+  beforeEach(() => {
+    addressMaps = new AddressMaps([
+      new AddressMap([[new Address(testAddress1), 0]]),
+      new AddressMap([
+        [new Address(testAddress2), 0],
+        [new Address(testAddress1), 1],
+      ]),
+    ]);
+  });
+
+  it('hasAllSignatures', async () => {
+    const tx = new ExportTx(
+      new BaseTx(
+        int(),
+        id(),
+        [transferableOutput()],
+        [
+          new TransferableInput(
+            utxoId(),
+            id(),
+            new TransferInput(bigIntPr(), Input.fromNative([0])),
+          ),
+          new TransferableInput(
+            utxoId(),
+            id(),
+            new TransferInput(bigIntPr(), Input.fromNative([0, 1])),
+          ),
+        ],
+        bytes(),
+      ),
+      id(),
+      transferableOutputs(),
+    );
+
+    const unsignedTx = new UnsignedTx(tx, [], addressMaps);
+    const unsignedBytes = unsignedTx.toBytes();
+
+    expect(unsignedTx.hasAllSignatures()).toBeFalsy();
+
+    const sig = await secp256k1.sign(unsignedBytes, testPrivateKey1);
+    unsignedTx.addSignature(sig);
+    expect(unsignedTx.hasAllSignatures()).toBeFalsy();
+
+    const sig2 = await secp256k1.sign(unsignedBytes, testPrivateKey2);
+    unsignedTx.addSignature(sig2);
+
+    expect(unsignedTx.hasAllSignatures()).toBeTruthy();
+  });
+
+  it('serializes', () => {
+    const tx = new ExportTx(
+      new BaseTx(
+        int(),
+        id(),
+        [transferableOutput()],
+        [
+          new TransferableInput(
+            utxoId(),
+            id(),
+            new TransferInput(bigIntPr(), Input.fromNative([0])),
+          ),
+          new TransferableInput(
+            utxoId(),
+            id(),
+            new TransferInput(bigIntPr(), Input.fromNative([0, 1])),
+          ),
+        ],
+        bytes(),
+      ),
+      id(),
+      transferableOutputs(),
+    );
+
+    const unsignedTx = new UnsignedTx(
+      tx,
+      [new Utxo(utxoId(), id(), transferOutput())],
+      addressMaps,
+    );
+    unsignedTx.addSignatureAt(signature().toBytes(), 0, 0);
+    const unsignedTxJson = JSON.stringify(unsignedTx);
+
+    expect(UnsignedTx.fromJSON(unsignedTxJson)).toEqual(unsignedTx);
+  });
+
+  describe('getSigIndicesForAddress', () => {
+    it('returns the correct indices when all signature slots are present', () => {
+      const tx = new ExportTx(
+        new BaseTx(
+          int(),
+          id(),
+          [transferableOutput()],
+          [
+            new TransferableInput(
+              utxoId(),
+              id(),
+              new TransferInput(bigIntPr(), Input.fromNative([0])),
+            ),
+            new TransferableInput(
+              utxoId(),
+              id(),
+              new TransferInput(bigIntPr(), Input.fromNative([0, 1])),
+            ),
+          ],
+          bytes(),
+        ),
+        id(),
+        transferableOutputs(),
+      );
+
+      const unsignedTx = new UnsignedTx(tx, [], addressMaps);
+      const addr1SigIndices = unsignedTx.getSigIndicesForPubKey(testPublicKey1);
+      const addr2SigIndices = unsignedTx.getSigIndicesForPubKey(testPublicKey2);
+
+      expect(unsignedTx.credentials[0].toJSON()).toHaveLength(1);
+      expect(unsignedTx.credentials[1].toJSON()).toHaveLength(2);
+      expect(addr1SigIndices).toStrictEqual([
+        [0, 0],
+        [1, 1],
+      ]);
+      expect(addr2SigIndices).toStrictEqual([[1, 0]]);
+    });
+
+    it('returns the correct indices when signature slots are missing', () => {
+      const tx = new ExportTx(
+        new BaseTx(
+          int(),
+          id(),
+          [transferableOutput()],
+          [
+            new TransferableInput(
+              utxoId(),
+              id(),
+              new TransferInput(bigIntPr(), Input.fromNative([0])),
+            ),
+            new TransferableInput(
+              utxoId(),
+              id(),
+              new TransferInput(bigIntPr(), Input.fromNative([1])),
+            ),
+          ],
+          bytes(),
+        ),
+        id(),
+        transferableOutputs(),
+      );
+
+      const unsignedTx = new UnsignedTx(
+        tx,
+        [],
+        new AddressMaps([
+          new AddressMap([[new Address(testAddress1), 0]]),
+          new AddressMap([[new Address(testAddress1), 1]]), // missing signature slot at index 0
+        ]),
+      );
+      const addr1SigIndices = unsignedTx.getSigIndicesForPubKey(testPublicKey1);
+
+      expect(unsignedTx.credentials[0].toJSON()).toHaveLength(1);
+      expect(unsignedTx.credentials[1].toJSON()).toHaveLength(1);
+      expect(addr1SigIndices).toStrictEqual([
+        [0, 0],
+        [1, 0], // using re-ordered index 0 instead of 1
+      ]);
+    });
+  });
+});

package/src/vms/common/unsignedTx.ts

@@ -0,0 +1,220 @@
+import { sha256 } from '@noble/hashes/sha256';
+import { emptySignature } from '../../constants/zeroValue';
+import { SignedTx } from '../../serializable/avax';
+import { Utxo } from '../../serializable/avax/utxo';
+import type { VM } from '../../serializable/constants';
+import { ValidVMs } from '../../serializable/constants';
+import { Address } from '../../serializable/fxs/common';
+import { Credential } from '../../serializable/fxs/secp256k1';
+import { bufferToHex, hexToBuffer } from '../../utils';
+import { secp256k1 } from '../../crypto';
+import { AddressMaps } from '../../utils/addressMap';
+import { getManagerForVM, packTx } from '../../utils/packTx';
+import type { Transaction } from './transaction';
+
+type UnsingedTxSerialize = {
+  txBytes: string;
+  utxos: string[];
+  addressMaps: [string, number][][];
+  vm: string;
+  codecId: string;
+  credentials: string[][];
+};
+export class UnsignedTx {
+  credentials: Credential[];
+  constructor(
+    readonly tx: Transaction,
+    readonly utxos: Utxo[],
+    readonly addressMaps: AddressMaps,
+    credentials?: Credential[],
+  ) {
+    if (credentials) {
+      this.credentials = credentials;
+      return;
+    }
+    this.credentials = this.tx
+      .getSigIndices()
+      .map((indicies) => new Credential(indicies.map(() => emptySignature)));
+  }
+
+  toJSON() {
+    const codec = getManagerForVM(this.tx.vm).getDefaultCodec();
+    const codecId = getManagerForVM(this.tx.vm).getDefaultCodecId();
+    return {
+      codecId: codecId,
+      vm: this.tx.vm,
+      txBytes: bufferToHex(this.toBytes()),
+      utxos: this.utxos.map((utxo) => bufferToHex(utxo.toBytes(codec))),
+      addressMaps: this.addressMaps,
+      credentials: this.credentials,
+    };
+  }
+
+  static fromJSON(jsonString: string) {
+    const res = JSON.parse(jsonString) as UnsingedTxSerialize;
+
+    const fields = [
+      'txBytes',
+      'utxos',
+      'addressMaps',
+      'vm',
+      'codecId',
+      'credentials',
+    ];
+
+    fields.forEach((field) => {
+      if (!res[field]) {
+        throw new Error(
+          `invalid structure. must have ${fields.join(', ')}, missing ${field}`,
+        );
+      }
+    });
+
+    const vm = res.vm as VM;
+    if (!ValidVMs.includes(vm)) {
+      throw new Error('invalid VM');
+    }
+
+    const manager = getManagerForVM(vm);
+    const [codec, rest] = manager.getCodecFromBuffer(hexToBuffer(res.txBytes));
+    const tx = codec.UnpackPrefix<Transaction>(rest)[0];
+
+    const utxos = res.utxos.map(
+      (utxo) => Utxo.fromBytes(hexToBuffer(utxo), codec)[0],
+    );
+
+    const addressMaps = AddressMaps.fromJSON(res.addressMaps);
+
+    const credentials = res.credentials.map((credStr) =>
+      Credential.fromJSON(credStr),
+    );
+    return new UnsignedTx(tx, utxos, addressMaps, credentials);
+  }
+
+  getSigIndices() {
+    return this.tx.getSigIndices();
+  }
+
+  hasAddress(address: Address) {
+    return this.addressMaps.has(address);
+  }
+
+  hasPubkey(pubKey: Uint8Array) {
+    return this.hasAddress(new Address(this.publicKeyBytesToAddress(pubKey)));
+  }
+
+  getAddresses() {
+    return this.addressMaps.getAddresses();
+  }
+
+  getSigIndicesForAddress(address: Address) {
+    const useReorderedIndices = this.getSigIndices().some(
+      (sigIndices, credIndex) => {
+        const signaturesLength = this.credentials[credIndex].toJSON().length;
+        const maxSigIndex = Math.max(...sigIndices);
+
+        return maxSigIndex > signaturesLength - 1;
+      },
+    );
+
+    return this.addressMaps.getSigIndicesForAddress(
+      address,
+      useReorderedIndices,
+    );
+  }
+
+  getSigIndicesForPubKey(pubkey: Uint8Array) {
+    const addrAvax = this.publicKeyBytesToAddress(pubkey);
+    const addrEvm = secp256k1.publicKeyToEthAddress(pubkey);
+
+    // Check against both addresses
+    const coordinatesAvax = this.getSigIndicesForAddress(new Address(addrAvax));
+    const coordinatesEvm = this.getSigIndicesForAddress(new Address(addrEvm));
+
+    return coordinatesAvax || coordinatesEvm;
+  }
+
+  getInputUtxos() {
+    return this.utxos;
+  }
+
+  toBytes(): Uint8Array {
+    return packTx(this.tx);
+  }
+
+  getBlockchainId() {
+    return this.tx.getBlockchainId();
+  }
+
+  getTx() {
+    return this.tx;
+  }
+
+  getSignedTx() {
+    return new SignedTx(this.tx, this.credentials);
+  }
+
+  getCredentials(): Credential[] {
+    return this.credentials as Credential[];
+  }
+
+  addSignatureAt(sig: Uint8Array, index: number, subIndex: number) {
+    if (index >= this.getCredentials().length) {
+      throw new Error('index out of bounds');
+    }
+    this.getCredentials()[index].setSignature(subIndex, sig);
+  }
+
+  addSignature(sig: Uint8Array) {
+    const unsignedHash = sha256(this.toBytes());
+    const publicKey = secp256k1.recoverPublicKey(unsignedHash, sig);
+    this.addSignatureForPubKey(sig, publicKey);
+  }
+
+  private addSignatureForPubKey(sig: Uint8Array, publicKey: Uint8Array) {
+    const coordinates = this.getSigIndicesForPubKey(publicKey);
+    if (coordinates) {
+      coordinates.forEach(([index, subIndex]) => {
+        this.addSignatureAt(sig, index, subIndex);
+      });
+    }
+  }
+
+  protected publicKeyBytesToAddress(pubKey: Uint8Array) {
+    return secp256k1.publicKeyBytesToAddress(pubKey);
+  }
+
+  hasAllSignatures() {
+    const allSigsHex = this.credentials.map((cred) => cred.getSignatures());
+    const emptySignatureHex = emptySignature.toString();
+    const unsignedHash = sha256(this.toBytes());
+
+    const hasNoPlaceholders = allSigsHex.every((cred) => {
+      return cred.every((sig) => {
+        return sig !== emptySignatureHex;
+      });
+    });
+
+    if (!hasNoPlaceholders) return false;
+    let valid = true;
+
+    this.addressMaps.forEach((coordinates) => {
+      coordinates.forEach(([index, subIndex]) => {
+        const sig = allSigsHex[index]?.[subIndex];
+        if (!sig) {
+          throw new Error('error: incorrect structure for credentials');
+        }
+        const sigBytes = hexToBuffer(sig);
+        const publicKey = secp256k1.recoverPublicKey(unsignedHash, sigBytes);
+        if (!this.hasPubkey(publicKey)) {
+          valid = false;
+        }
+      });
+    }, true);
+    return valid;
+  }
+
+  getVM() {
+    return this.tx.getVM();
+  }
+}

package/src/vms/context/context.ts

@@ -0,0 +1,52 @@
+import { getHRP } from '../../constants/networkIDs';
+import { Info } from '../../info/info';
+import { AVMApi } from '../avm/api';
+import type { Context } from './model';
+
+/*
+grabs some basic info about an avm chain
+*/
+export const getContextFromURI = async (
+  baseURL?: string,
+  assetDescription = 'AVAX',
+): Promise<Context> => {
+  const xChainApi = new AVMApi(baseURL);
+  const { assetID: avaxAssetID } = await xChainApi.getAssetDescription(
+    assetDescription,
+  );
+  const info = new Info(baseURL);
+  const {
+    txFee: baseTxFee,
+    createAssetTxFee,
+    createSubnetTxFee,
+    transformSubnetTxFee,
+    createBlockchainTxFee,
+    addPrimaryNetworkValidatorFee,
+    addPrimaryNetworkDelegatorFee,
+    addSubnetValidatorFee,
+    addSubnetDelegatorFee,
+  } = await info.getTxFee();
+  const { blockchainID: xBlockchainID } = await info.getBlockchainId('X');
+  const { blockchainID: pBlockchainID } = await info.getBlockchainId('P');
+  const { blockchainID: cBlockchainID } = await info.getBlockchainId('C');
+
+  const { networkID } = await info.getNetworkId();
+
+  return Object.freeze({
+    xBlockchainID,
+    pBlockchainID,
+    cBlockchainID,
+    avaxAssetID,
+    baseTxFee,
+    createAssetTxFee,
+    createSubnetTxFee,
+    transformSubnetTxFee,
+    createBlockchainTxFee,
+    addPrimaryNetworkValidatorFee,
+    addPrimaryNetworkDelegatorFee,
+    addSubnetValidatorFee,
+    addSubnetDelegatorFee,
+    networkID,
+    hrp: getHRP(networkID),
+  });
+};

package/src/vms/context/index.ts

@@ -0,0 +1,2 @@
+export * from './context';
+export * from './model';

package/src/vms/context/model.ts

@@ -0,0 +1,17 @@
+export type Context = {
+  readonly networkID: number;
+  readonly hrp: string;
+  readonly xBlockchainID: string;
+  readonly pBlockchainID: string;
+  readonly cBlockchainID: string;
+  readonly avaxAssetID: string;
+  readonly baseTxFee: bigint;
+  readonly createAssetTxFee: bigint;
+  readonly createSubnetTxFee: bigint;
+  readonly transformSubnetTxFee: bigint;
+  readonly createBlockchainTxFee: bigint;
+  readonly addPrimaryNetworkValidatorFee: bigint;
+  readonly addPrimaryNetworkDelegatorFee: bigint;
+  readonly addSubnetValidatorFee: bigint;
+  readonly addSubnetDelegatorFee: bigint;
+};

package/src/vms/evm/api.ts

@@ -0,0 +1,62 @@
+import { SignedTx } from '../../serializable/avax';
+import { getEVMManager } from '../../serializable/evm/codec';
+import { hexToBuffer } from '../../utils';
+import { Api } from '../common/baseApi';
+import { ChainApi } from '../common/chainAPI';
+import type { GetAtomicTxParams, GetAtomicTxStatusResponse } from './model';
+import type { GetAtomicTxServerResponse } from './privateModels';
+
+export class EVMApi extends ChainApi {
+  ethAPI: EthereumAPI;
+  constructor(baseURL?: string) {
+    super(baseURL, '/ext/bc/C/avax', 'avax', getEVMManager());
+    this.ethAPI = new EthereumAPI(baseURL);
+  }
+
+  /**
+   * Returns the transaction data of a provided transaction ID by calling the node's `getAtomicTx` method.
+   *
+   * @param txID The string representation of the transaction ID
+   *
+   * @returns Returns a Promise with the signedTX unmarshalled from the bytes
+   */
+
+  getAtomicTx = async (getTxParams: GetAtomicTxParams) => {
+    const resp = await this.callRpc<GetAtomicTxServerResponse>('getAtomicTx', {
+      ...getTxParams,
+      encoding: 'hex',
+    });
+    return this.manager.unpack(hexToBuffer(resp.tx), SignedTx);
+  };
+
+  /**
+   * @returns a Promise string containing the base fee for the next block.
+   */
+  getBaseFee() {
+    return this.ethAPI.getBaseFee();
+  }
+
+  /**
+   * Returns the status of a provided atomic transaction ID by calling the node's `getAtomicTxStatus` method.
+   *
+   * @param txID The string representation of the transaction ID
+   *
+   * @returns Returns a Promise {status: string, blockHeight: string} containing the status retrieved from the node
+   */
+
+  getAtomicTxStatus(txID: string): Promise<GetAtomicTxStatusResponse> {
+    return this.callRpc<GetAtomicTxStatusResponse>('getAtomicTxStatus', {
+      txID,
+    });
+  }
+}
+
+class EthereumAPI extends Api {
+  constructor(baseURL?: string) {
+    super(baseURL, '/ext/bc/C/rpc');
+  }
+
+  async getBaseFee() {
+    return BigInt(await this.callRpc<string>('eth_baseFee'));
+  }
+}

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

@@ -0,0 +1,80 @@
+import { testContext } from '../../fixtures/context';
+import {
+  getTransferableInputForTest,
+  testAvaxAssetID,
+  testOwnerXAddress,
+  testUtxos,
+} from '../../fixtures/transactions';
+import { expectTxs } from '../../fixtures/utils/expectTx';
+import { TransferableOutput } from '../../serializable/avax';
+import { ExportTx, ImportTx, Input, Output } from '../../serializable/evm';
+import { Address, Id } from '../../serializable/fxs/common';
+import { BigIntPr, Int } from '../../serializable/primitives';
+import { hexToBuffer, isTransferOut } from '../../utils';
+import { AvaxToNAvax } from '../../utils/avaxToNAvax';
+import { newExportTxFromBaseFee, newImportTxFromBaseFee } from './builder';
+
+describe('CorethBuilder', () => {
+  const baseFee = 25n;
+  const fromAddress = testOwnerXAddress.toBytes();
+  const toAddress = hexToBuffer('0x5432112345123451234512');
+
+  it('exportTx', () => {
+    const tx = newExportTxFromBaseFee(
+      testContext,
+      baseFee,
+      AvaxToNAvax(1),
+      testContext.xBlockchainID,
+      fromAddress,
+      [toAddress],
+      3n,
+    );
+
+    const expectedTx = new ExportTx(
+      new Int(testContext.networkID),
+      Id.fromString(testContext.cBlockchainID),
+      Id.fromString(testContext.xBlockchainID),
+      [
+        new Input(
+          testOwnerXAddress,
+          new BigIntPr(1000280750n),
+          testAvaxAssetID,
+          new BigIntPr(3n),
+        ),
+      ],
+      [
+        TransferableOutput.fromNative(testContext.avaxAssetID, 1000000000n, [
+          toAddress,
+        ]),
+      ],
+    );
+    expectTxs(tx.getTx(), expectedTx);
+  });
+
+  it('importTx', () => {
+    const tx = newImportTxFromBaseFee(
+      testContext,
+      toAddress,
+      [fromAddress],
+      testUtxos().filter((utxo) => isTransferOut(utxo.output)),
+      testContext.xBlockchainID,
+      baseFee,
+    );
+
+    const expectedTx = new ImportTx(
+      new Int(testContext.networkID),
+      Id.fromString(testContext.cBlockchainID),
+      Id.fromString(testContext.xBlockchainID),
+      [getTransferableInputForTest()],
+      [
+        new Output(
+          Address.fromString('C-avax12sepzg69zg69zg69zgmpqwf3'),
+          new BigIntPr(50000000000n),
+          testAvaxAssetID,
+        ),
+      ],
+    );
+
+    expectTxs(tx.getTx(), expectedTx);
+  });
+});