@bitgo-forks/avalanchejs 4.1.0-alpha.1

package/src/fixtures/utils/serializable.ts

@@ -0,0 +1,28 @@
+import type { Codec } from '../../serializable/codec';
+import type {
+  Serializable,
+  SerializableStatic,
+} from '../../serializable/common/types';
+import { testCodec } from '../codec';
+
+export const testSerialization = (
+  name: string,
+  entity: SerializableStatic,
+  entityFixture: () => Serializable,
+  bytesFixture: () => Uint8Array,
+  codec: () => Codec = testCodec,
+) => {
+  describe(name, () => {
+    it('deserializes correctly', () => {
+      const [output, remainder] = entity.fromBytes(bytesFixture(), codec());
+      expect(JSON.stringify(output)).toBe(JSON.stringify(entityFixture()));
+      expect(remainder).toStrictEqual(new Uint8Array());
+    });
+  });
+
+  describe(name, () => {
+    it('serializes correctly', () => {
+      expect(entityFixture().toBytes(codec())).toStrictEqual(bytesFixture());
+    });
+  });
+};

package/src/fixtures/utils/typeguards.ts

@@ -0,0 +1,13 @@
+export type TypeChecker = (object: any) => boolean;
+
+export function checkAllGuards(object: any, guards: TypeChecker[]) {
+  return guards.map((checker) => checker(object));
+}
+
+export function countGuardPasses(object: any, guards: TypeChecker[]) {
+  return checkAllGuards(object, guards).filter((val) => val).length;
+}
+
+export function onlyChecksOneGuard(object: any, guards: TypeChecker[]) {
+  return countGuardPasses(object, guards) === 1;
+}

package/src/fixtures/vms.ts

@@ -0,0 +1,16 @@
+import { secp256k1 } from '../crypto';
+import { hexToBuffer } from '../utils';
+
+export const testPrivateKey1 = hexToBuffer(
+  '9c0523e7611e62f5dca291ad335e950db076c5ee31c4107355abde0d357bbd29',
+);
+export const testPublicKey1 = secp256k1.getPublicKey(testPrivateKey1);
+export const testAddress1 = secp256k1.publicKeyBytesToAddress(testPublicKey1);
+export const testEthAddress1 = secp256k1.publicKeyToEthAddress(testPublicKey1);
+
+export const testPrivateKey2 = hexToBuffer(
+  'd11e7aa633eb15682bc2456d399c2a9861c82e0a308dbfd4d3a51ffa972f2b62',
+);
+export const testPublicKey2 = secp256k1.getPublicKey(testPrivateKey2);
+export const testAddress2 = secp256k1.publicKeyBytesToAddress(testPublicKey2);
+export const testEthAddress2 = secp256k1.publicKeyToEthAddress(testPublicKey2);

package/src/index.ts

@@ -0,0 +1,8 @@
+export * as networkIDs from './constants/networkIDs';
+export * from './serializable';
+export { Utxo } from './serializable/avax/utxo';
+export * from './signer';
+export * as utils from './utils';
+export * from './vms';
+export { Info } from './info/info';
+export * from './crypto';

package/src/info/info.ts

@@ -0,0 +1,78 @@
+import { AVAX_PUBLIC_URL } from '../constants/public-urls';
+import { Api } from '../vms/common/baseApi';
+import type {
+  GetBlockchainIDResponse,
+  GetNetworkIdResponse,
+  GetNetworkNameResponse,
+  GetNodeIdResponse,
+  GetNodeIpResponse,
+  GetNodeVersionReply,
+  GetPeersResponse,
+  GetTxFeeResponse,
+  isBootstrapped,
+  UptimeResponse,
+} from './model';
+
+export class Info extends Api {
+  constructor(private readonly baseURL: string = AVAX_PUBLIC_URL) {
+    super(baseURL, '/ext/info', 'info');
+  }
+
+  getNodeVersion(): Promise<GetNodeVersionReply> {
+    return this.callRpc<GetNodeVersionReply>('getNodeVersion');
+  }
+
+  async getNodeId(): Promise<GetNodeIdResponse> {
+    return this.callRpc<GetNodeIdResponse>('getNodeID');
+  }
+
+  getNodeIp(): Promise<GetNodeIpResponse> {
+    return this.callRpc<GetNodeIpResponse>('getNodeIP');
+  }
+
+  getNetworkId(): Promise<GetNetworkIdResponse> {
+    return this.callRpc<GetNetworkIdResponse>('getNetworkID');
+  }
+
+  getNetworkName(): Promise<GetNetworkNameResponse> {
+    return this.callRpc<GetNetworkNameResponse>('getNetworkName');
+  }
+
+  getBlockchainId(alias: string): Promise<GetBlockchainIDResponse> {
+    return this.callRpc<GetBlockchainIDResponse>('getBlockchainID', { alias });
+  }
+
+  peers(nodeIDs?: string[]): Promise<GetPeersResponse> {
+    return this.callRpc<GetPeersResponse>('peers', { nodeIDs });
+  }
+
+  isBootstrapped(chain: string): Promise<isBootstrapped> {
+    return this.callRpc<isBootstrapped>('peers', { chain });
+  }
+  /**
+   * @link https://docs.avax.network/apis/avalanchego/apis/info#infogettxfee
+   */
+  async getTxFee(): Promise<GetTxFeeResponse> {
+    const resp = await this.callRpc<GetTxFeeResponse>('getTxFee');
+
+    return {
+      txFee: BigInt(resp.txFee),
+      createAssetTxFee: BigInt(resp.createAssetTxFee),
+      createSubnetTxFee: BigInt(resp.createSubnetTxFee),
+      transformSubnetTxFee: BigInt(resp.transformSubnetTxFee),
+      createBlockchainTxFee: BigInt(resp.createBlockchainTxFee),
+      addPrimaryNetworkValidatorFee: BigInt(resp.addPrimaryNetworkValidatorFee),
+      addPrimaryNetworkDelegatorFee: BigInt(resp.addPrimaryNetworkDelegatorFee),
+      addSubnetValidatorFee: BigInt(resp.addSubnetValidatorFee),
+      addSubnetDelegatorFee: BigInt(resp.addSubnetDelegatorFee),
+    };
+  }
+
+  uptime(): Promise<UptimeResponse> {
+    return this.callRpc<UptimeResponse>('uptime');
+  }
+
+  getVMs(): Promise<Map<string, string[]>> {
+    return this.callRpc<Map<string, string[]>>('getVMs');
+  }
+}

package/src/info/model.ts

@@ -0,0 +1,71 @@
+export type GetNodeVersionReply = {
+  version: string;
+  databaseVersion: string;
+  gitCommit: string;
+  vmVersions: Map<string, string>;
+};
+
+export type Peer = {
+  ip: string;
+  publicIp: string;
+  nodeID: string;
+  version: string;
+  lastSent: string;
+  lastReceived: string;
+  observedUptime: number;
+  benched: string[];
+};
+
+export type GetPeersResponse = {
+  numPeers: number;
+  peers: Peer[];
+};
+
+export type GetTxFeeApiResponse = {
+  txFee: string;
+  creationTxFee: string;
+  createAssetTxFee: string;
+  createSubnetTxFee: string;
+  createBlockchainTxFee: string;
+};
+
+export type GetTxFeeResponse = {
+  txFee: bigint;
+  createAssetTxFee: bigint;
+  createSubnetTxFee: bigint;
+  transformSubnetTxFee: bigint;
+  createBlockchainTxFee: bigint;
+  addPrimaryNetworkValidatorFee: bigint;
+  addPrimaryNetworkDelegatorFee: bigint;
+  addSubnetValidatorFee: bigint;
+  addSubnetDelegatorFee: bigint;
+};
+
+export type UptimeResponse = {
+  rewardingStakePercentage: string;
+  weightedAveragePercentage: string;
+};
+
+export type GetNodeIdResponse = {
+  nodeID: string;
+};
+
+export type GetNodeIpResponse = {
+  ip: string;
+};
+
+export type GetNetworkIdResponse = {
+  networkID: number;
+};
+
+export type GetNetworkNameResponse = {
+  networkName: string;
+};
+
+export type GetBlockchainIDResponse = {
+  blockchainID: string;
+};
+
+export type isBootstrapped = {
+  isBootstrapped: boolean;
+};

package/src/serializable/avax/avaxTx.ts

@@ -0,0 +1,22 @@
+import { Transaction } from '../../vms/common/transaction';
+import type { BaseTx } from './baseTx';
+import type { TransferableInput } from './transferableInput';
+
+export abstract class AvaxTx extends Transaction {
+  abstract baseTx?: BaseTx;
+
+  getInputs(): TransferableInput[] {
+    return this.baseTx?.inputs ?? [];
+  }
+  getBlockchainId() {
+    return this.baseTx?.BlockchainId.toString() ?? '';
+  }
+
+  getSigIndices(): number[][] {
+    return this.getInputs()
+      .map((input) => {
+        return input.sigIndicies();
+      })
+      .filter((indicies): indicies is number[] => indicies !== undefined);
+  }
+}

package/src/serializable/avax/baseTx.spec.ts

@@ -0,0 +1,5 @@
+import { baseTx, baseTxbytes } from '../../fixtures/avax';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { BaseTx } from './baseTx';
+
+testSerialization('BaseTx', BaseTx, baseTx, baseTxbytes);

package/src/serializable/avax/baseTx.ts

@@ -0,0 +1,69 @@
+import { concatBytes } from '../../utils/buffer';
+import { packList, toListStruct } from '../../utils/serializeList';
+import { pack, unpack } from '../../utils/struct';
+import type { Codec } from '../codec/codec';
+import { serializable } from '../common/types';
+import { Id } from '../fxs/common/id';
+import { Bytes, Int } from '../primitives';
+import { TransferableInput } from './transferableInput';
+import { TransferableOutput } from './transferableOutput';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see https://docs.avax.network/specs/avm-transaction-serialization#unsigned-basetx
+ */
+@serializable()
+export class BaseTx {
+  _type = TypeSymbols.BaseTx;
+
+  constructor(
+    public readonly NetworkId: Int,
+    public readonly BlockchainId: Id,
+    public readonly outputs: TransferableOutput[],
+    public readonly inputs: TransferableInput[],
+    public readonly memo: Bytes,
+  ) {}
+
+  static fromBytes(bytes: Uint8Array, codec: Codec): [BaseTx, Uint8Array] {
+    const [networkId, blockchainId, outputs, inputs, memo, remaining] = unpack(
+      bytes,
+      [
+        Int,
+        Id,
+        toListStruct(TransferableOutput),
+        toListStruct(TransferableInput),
+        Bytes,
+      ],
+      codec,
+    );
+    return [
+      new BaseTx(networkId, blockchainId, outputs, inputs, memo),
+      remaining,
+    ];
+  }
+
+  static fromNative(
+    networkId: number,
+    blockchainId: string,
+    outputs: TransferableOutput[],
+    inputs: TransferableInput[],
+    memo: Uint8Array,
+  ) {
+    return new BaseTx(
+      new Int(networkId),
+      Id.fromString(blockchainId),
+      outputs,
+      inputs,
+      new Bytes(memo),
+    );
+  }
+
+  toBytes(codec) {
+    return concatBytes(
+      pack([this.NetworkId, this.BlockchainId], codec),
+      packList(this.outputs, codec),
+      packList(this.inputs, codec),
+      this.memo.toBytes(),
+    );
+  }
+}

package/src/serializable/avax/index.ts

@@ -0,0 +1,7 @@
+export { AvaxTx } from './avaxTx';
+export { BaseTx } from './baseTx';
+export * from './signedTx';
+export { TransferableInput } from './transferableInput';
+export { TransferableOutput } from './transferableOutput';
+export * from './typeGuards';
+export { UTXOID } from './utxoId';

package/src/serializable/avax/signedTx.spec.ts

@@ -0,0 +1,16 @@
+import { signedTx, signedTxBytes } from '../../fixtures/avax';
+import { getAVMManager } from '../avm/codec';
+import { SignedTx } from './signedTx';
+
+describe('SignedTx', () => {
+  it('deserializes correctly', () => {
+    const output = getAVMManager().unpack(signedTxBytes(), SignedTx);
+    expect(JSON.stringify(output)).toBe(JSON.stringify(signedTx()));
+  });
+});
+
+describe('SignedTx', () => {
+  it('serializes correctly', () => {
+    expect(signedTx().toBytes()).toStrictEqual(signedTxBytes());
+  });
+});

package/src/serializable/avax/signedTx.ts

@@ -0,0 +1,51 @@
+import { concatBytes } from '@noble/hashes/utils';
+import { DEFAULT_CODEC_VERSION } from '../../constants/codec';
+import { getDefaultCodecFromTx } from '../../utils/packTx';
+import { toListStruct } from '../../utils/serializeList';
+import { unpack } from '../../utils/struct';
+import type { Transaction } from '../../vms/common/transaction';
+import { Codec } from '../codec/codec';
+import type { Serializable } from '../common/types';
+import { serializable } from '../common/types';
+import type { Credential } from '../fxs/secp256k1';
+import { Short } from '../primitives';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see https://docs.avax.network/specs/avm-transaction-serialization#unsigned-Exporttx
+ */
+@serializable()
+export class SignedTx {
+  _type = TypeSymbols.AvmSignedTx;
+
+  constructor(
+    public readonly unsignedTx: Transaction,
+    public readonly credentials: Serializable[],
+  ) {}
+
+  static fromBytes(bytes: Uint8Array, codec: Codec): [SignedTx, Uint8Array] {
+    const [unsignedTx, outs, remaining] = unpack(
+      bytes,
+      [Codec, toListStruct(Codec)],
+      codec,
+    );
+    return [new SignedTx(unsignedTx as Transaction, outs), remaining];
+  }
+
+  getCredentials(): Credential[] {
+    return this.credentials as Credential[];
+  }
+
+  getAllSignatures() {
+    return this.getCredentials().flatMap((cred) => cred.getSignatures());
+  }
+
+  toBytes() {
+    const codec = getDefaultCodecFromTx(this.unsignedTx);
+    return concatBytes(
+      new Short(DEFAULT_CODEC_VERSION).toBytes(),
+      codec.PackPrefix(this.unsignedTx),
+      codec.PackPrefixList(this.credentials),
+    );
+  }
+}

package/src/serializable/avax/transferableInput.spec.ts

@@ -0,0 +1,196 @@
+import { TransferableInput } from '.';
+import {
+  transferableInput,
+  transferableInputBytes,
+  utxoId,
+} from '../../fixtures/avax';
+import { id } from '../../fixtures/common';
+import { bigIntPr } from '../../fixtures/primitives';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { Input, TransferInput } from '../fxs/secp256k1';
+import { StakeableLockIn } from '../pvm';
+
+testSerialization(
+  'TransferableInput',
+  TransferableInput,
+  transferableInput,
+  transferableInputBytes,
+);
+
+describe('TransferableInput sorting', () => {
+  it('sorts correctly', () => {
+    const inputs = [
+      {
+        utxoID: {
+          txID: '2iCGnbjjeZQhqq5jcjqJg4ZxgAbYy92HZtUyPY7abXGwiMvxSg',
+          outputIdx: 0,
+        },
+        assetId: 'FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z',
+        input: {
+          amt: {
+            bigint: '2000000000',
+          },
+          input: {
+            sigIndices: [0],
+          },
+        },
+      },
+      {
+        utxoID: {
+          txID: '2MpCHQEVzMS5AhyXLJxmLT5SoiTV1GxVFBhVxkPXbuoHEKva9Z',
+          outputIdx: 0,
+        },
+        assetId: 'FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z',
+        input: {
+          amt: {
+            bigint: '10000000',
+          },
+          input: {
+            sigIndices: [0],
+          },
+        },
+      },
+      {
+        utxoID: {
+          txID: '2p2cZ6pnszaQjrCYVisq432aQZFnhXsMdtSn3L5azUUAXw4ZRE',
+          outputIdx: 0,
+        },
+        assetId: 'FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z',
+        input: {
+          amt: {
+            bigint: '97000000',
+          },
+          input: {
+            sigIndices: [0],
+          },
+        },
+      },
+      {
+        utxoID: {
+          txID: 'nrZ6vSw6fU8K6WTPeBJBXoTU8rcbViVbPi45ZW4yLtD6v3K6y',
+          outputIdx: 0,
+        },
+        assetId: 'FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z',
+        input: {
+          amt: {
+            bigint: '1971075188',
+          },
+          input: {
+            sigIndices: [0],
+          },
+        },
+      },
+    ];
+    const inputTransferableInputs = inputs.map((inp) =>
+      TransferableInput.fromNative(
+        inp.utxoID.txID,
+        inp.utxoID.outputIdx,
+        inp.assetId,
+        BigInt(inp.input.amt.bigint),
+        inp.input.input.sigIndices,
+      ),
+    );
+
+    const expected = [
+      {
+        utxoID: {
+          txID: 'nrZ6vSw6fU8K6WTPeBJBXoTU8rcbViVbPi45ZW4yLtD6v3K6y',
+          outputIdx: 0,
+        },
+        assetId: 'FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z',
+        input: {
+          amt: {
+            bigint: '1971075188',
+          },
+          input: {
+            sigIndices: [0],
+          },
+        },
+      },
+      {
+        utxoID: {
+          txID: '2MpCHQEVzMS5AhyXLJxmLT5SoiTV1GxVFBhVxkPXbuoHEKva9Z',
+          outputIdx: 0,
+        },
+        assetId: 'FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z',
+        input: {
+          amt: {
+            bigint: '10000000',
+          },
+          input: {
+            sigIndices: [0],
+          },
+        },
+      },
+      {
+        utxoID: {
+          txID: '2iCGnbjjeZQhqq5jcjqJg4ZxgAbYy92HZtUyPY7abXGwiMvxSg',
+          outputIdx: 0,
+        },
+        assetId: 'FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z',
+        input: {
+          amt: {
+            bigint: '2000000000',
+          },
+          input: {
+            sigIndices: [0],
+          },
+        },
+      },
+      {
+        utxoID: {
+          txID: '2p2cZ6pnszaQjrCYVisq432aQZFnhXsMdtSn3L5azUUAXw4ZRE',
+          outputIdx: 0,
+        },
+        assetId: 'FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z',
+        input: {
+          amt: {
+            bigint: '97000000',
+          },
+          input: {
+            sigIndices: [0],
+          },
+        },
+      },
+    ];
+
+    const expectedTransferableInputs = expected.map((inp) =>
+      TransferableInput.fromNative(
+        inp.utxoID.txID,
+        inp.utxoID.outputIdx,
+        inp.assetId,
+        BigInt(inp.input.amt.bigint),
+        inp.input.input.sigIndices,
+      ),
+    );
+
+    inputTransferableInputs.sort(TransferableInput.compare);
+
+    expect(inputTransferableInputs).toStrictEqual(expectedTransferableInputs);
+  });
+});
+
+describe('sigindicies', () => {
+  it('gets sigindicies for transferinput', () => {
+    const transferableInputWithTransferInput = new TransferableInput(
+      utxoId(),
+      id(),
+      new TransferInput(bigIntPr(), Input.fromNative([0, 1])),
+    );
+
+    expect(transferableInputWithTransferInput.sigIndicies()).toEqual([0, 1]);
+  });
+
+  it('gets sigindicies for stakeableLockIn', () => {
+    const transferableInputWithTransferInput = new TransferableInput(
+      utxoId(),
+      id(),
+      new StakeableLockIn(
+        bigIntPr(),
+        new TransferInput(bigIntPr(), Input.fromNative([0, 1])),
+      ),
+    );
+
+    expect(transferableInputWithTransferInput.sigIndicies()).toEqual([0, 1]);
+  });
+});