@bitgo-forks/avalanchejs 4.1.0-alpha.1

package/src/serializable/evm/importTx.spec.ts

@@ -0,0 +1,6 @@
+import { testEVMCodec } from '../../fixtures/codec';
+import { importTx, importTxBytes } from '../../fixtures/evm';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { ImportTx } from './importTx';
+
+testSerialization('ImportTx', ImportTx, importTx, importTxBytes, testEVMCodec);

package/src/serializable/evm/importTx.ts

@@ -0,0 +1,56 @@
+import { toListStruct } from '../../utils/serializeList';
+import { packSwitched, unpack } from '../../utils/struct';
+import { serializable } from '../../vms/common/types';
+import { TransferableInput } from '../avax/transferableInput';
+import type { Codec } from '../codec';
+import { Id } from '../fxs/common';
+import { Int } from '../primitives';
+import { EVMTx } from './abstractTx';
+import { Output } from './output';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see
+ */
+@serializable()
+export class ImportTx extends EVMTx {
+  _type = TypeSymbols.EvmImportTx;
+
+  constructor(
+    public readonly networkId: Int,
+    public readonly blockchainId: Id,
+    public readonly sourceChain: Id,
+    public readonly importedInputs: TransferableInput[],
+    public readonly Outs: Output[],
+  ) {
+    super();
+  }
+
+  getSigIndices() {
+    return this.importedInputs.map((inp) => inp.sigIndicies());
+  }
+
+  static fromBytes(bytes: Uint8Array, codec: Codec): [ImportTx, Uint8Array] {
+    const [networkId, blockchainId, sourceChain, importedInputs, Outs, rest] =
+      unpack(
+        bytes,
+        [Int, Id, Id, toListStruct(TransferableInput), toListStruct(Output)],
+        codec,
+      );
+    return [
+      new ImportTx(networkId, blockchainId, sourceChain, importedInputs, Outs),
+      rest,
+    ];
+  }
+
+  toBytes(codec: Codec) {
+    return packSwitched(
+      codec,
+      this.networkId,
+      this.blockchainId,
+      this.sourceChain,
+      this.importedInputs,
+      this.Outs,
+    );
+  }
+}

package/src/serializable/evm/index.ts

@@ -0,0 +1,6 @@
+export { EVMTx } from './abstractTx';
+export { ExportTx } from './exportTx';
+export { ImportTx } from './importTx';
+export { Input } from './input';
+export { Output } from './output';
+export * from './typeGuards';

package/src/serializable/evm/input.spec.ts

@@ -0,0 +1,6 @@
+import { testEVMCodec } from '../../fixtures/codec';
+import { input, inputBytes } from '../../fixtures/secp256k1';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { Input } from '../fxs/secp256k1';
+
+testSerialization('Input', Input, input, inputBytes, testEVMCodec);

package/src/serializable/evm/input.ts

@@ -0,0 +1,47 @@
+import { packSwitched, unpack } from '../../utils/struct';
+import { serializable } from '../../vms/common/types';
+import type { Codec } from '../codec';
+import { Address, Id } from '../fxs/common';
+import { BigIntPr } from '../primitives';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see
+ */
+@serializable()
+export class Input {
+  _type = TypeSymbols.EvmInput;
+
+  constructor(
+    public readonly address: Address,
+    public readonly amount: BigIntPr,
+    public readonly assetId: Id,
+    public readonly nonce: BigIntPr,
+  ) {}
+
+  static fromBytes(bytes: Uint8Array, codec: Codec): [Input, Uint8Array] {
+    const [address, amount, assetId, nonce, rest] = unpack(
+      bytes,
+      [Address, BigIntPr, Id, BigIntPr],
+      codec,
+    );
+    return [new Input(address, amount, assetId, nonce), rest];
+  }
+
+  static compare = (a: Input, b: Input) => {
+    if (a.address.value() !== b.address.value()) {
+      return a.address.value().localeCompare(b.address.value());
+    }
+    return a.assetId.value().localeCompare(b.assetId.value());
+  };
+
+  toBytes(codec: Codec) {
+    return packSwitched(
+      codec,
+      this.address,
+      this.amount,
+      this.assetId,
+      this.nonce,
+    );
+  }
+}

package/src/serializable/evm/output.spec.ts

@@ -0,0 +1,6 @@
+import { testEVMCodec } from '../../fixtures/codec';
+import { output, outputBytes } from '../../fixtures/evm';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { Output } from './output';
+
+testSerialization('Output', Output, output, outputBytes, testEVMCodec);

package/src/serializable/evm/output.ts

@@ -0,0 +1,33 @@
+import { packSwitched, unpack } from '../../utils/struct';
+import { serializable } from '../../vms/common/types';
+import type { Codec } from '../codec';
+import { Address, Id } from '../fxs/common';
+import { BigIntPr } from '../primitives';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see
+ */
+@serializable()
+export class Output {
+  _type = TypeSymbols.EvmOutput;
+
+  constructor(
+    public readonly address: Address,
+    public readonly amount: BigIntPr,
+    public readonly assetId: Id,
+  ) {}
+
+  static fromBytes(bytes: Uint8Array, codec: Codec): [Output, Uint8Array] {
+    const [address, amount, assetId, rest] = unpack(
+      bytes,
+      [Address, BigIntPr, Id],
+      codec,
+    );
+    return [new Output(address, amount, assetId), rest];
+  }
+
+  toBytes(codec: Codec) {
+    return packSwitched(codec, this.address, this.amount, this.assetId);
+  }
+}

package/src/serializable/evm/typeGuards.spec.ts

@@ -0,0 +1,33 @@
+import {
+  isImportTx,
+  isExportTx,
+  isImportExportTx,
+  isEvmTx,
+} from './typeGuards';
+import { TypeSymbols } from '../constants';
+import type { Transaction } from '../../vms/common';
+import { onlyChecksOneGuard } from '../../fixtures/utils/typeguards';
+
+const guards = [isImportTx, isExportTx];
+
+describe('evm/typeGuards', function () {
+  it('isImportTx', () => {
+    const tx = {
+      _type: TypeSymbols.EvmImportTx,
+    } as Transaction;
+    expect(isImportTx(tx)).toBe(true);
+    expect(isImportExportTx(tx)).toBe(true);
+    expect(isEvmTx(tx)).toBe(true);
+    expect(onlyChecksOneGuard(tx, guards)).toBe(true);
+  });
+
+  it('isExportTx', () => {
+    const tx = {
+      _type: TypeSymbols.EvmExportTx,
+    } as Transaction;
+    expect(isExportTx(tx)).toBe(true);
+    expect(isImportExportTx(tx)).toBe(true);
+    expect(isEvmTx(tx)).toBe(true);
+    expect(onlyChecksOneGuard(tx, guards)).toBe(true);
+  });
+});

package/src/serializable/evm/typeGuards.ts

@@ -0,0 +1,24 @@
+import type { Transaction } from '../../vms/common/transaction';
+import type { EVMTx } from './abstractTx';
+import type { ExportTx } from './exportTx';
+import type { ImportTx } from './importTx';
+import { TypeSymbols } from '../constants';
+
+export function isExportTx(tx: Transaction): tx is ExportTx {
+  return tx._type == TypeSymbols.EvmExportTx;
+}
+
+export function isImportTx(tx: Transaction): tx is ImportTx {
+  return tx._type == TypeSymbols.EvmImportTx;
+}
+
+export function isEvmTx(tx: Transaction): tx is EVMTx {
+  return isImportTx(tx) || isExportTx(tx);
+}
+
+export function isImportExportTx(tx: Transaction): tx is ImportTx | ExportTx {
+  if (!(isExportTx(tx) || isImportTx(tx))) {
+    return false;
+  }
+  return true;
+}

package/src/serializable/fxs/common/address.spec.ts

@@ -0,0 +1,5 @@
+import { address, addressBytes } from '../../../fixtures/common';
+import { testSerialization } from '../../../fixtures/utils/serializable';
+import { Address } from './address';
+
+testSerialization('Address', Address, address, addressBytes);

package/src/serializable/fxs/common/address.ts

@@ -0,0 +1,51 @@
+import { customInspectSymbol } from '../../../constants/node';
+import { bech32ToBytes, formatBech32 } from '../../../utils/address';
+import { bufferToHex, hexToBuffer, padLeft } from '../../../utils/buffer';
+import { serializable } from '../../common/types';
+import { Primitives } from '../../primitives/primatives';
+import { TypeSymbols } from '../../constants';
+
+@serializable()
+export class Address extends Primitives {
+  _type = TypeSymbols.Address;
+  constructor(private readonly address: Uint8Array) {
+    super();
+  }
+
+  static fromBytes(buf: Uint8Array): [Address, Uint8Array] {
+    return [new Address(buf.slice(0, 20)), buf.slice(20)];
+  }
+
+  [customInspectSymbol](_, options: any) {
+    return options.stylize(this.toJSON(), 'string');
+  }
+
+  toJSON(hrp = 'avax') {
+    return this.toString(hrp);
+  }
+
+  //decodes from bech32 Addresses
+  static fromString(addr: string): Address {
+    return new Address(bech32ToBytes(addr));
+  }
+
+  static fromHex(hex: string): Address {
+    return new Address(hexToBuffer(hex));
+  }
+
+  toHex(): string {
+    return bufferToHex(this.address);
+  }
+
+  toBytes() {
+    return padLeft(this.address, 20);
+  }
+
+  toString(hrp = 'avax') {
+    return formatBech32(hrp, this.address);
+  }
+
+  value() {
+    return this.toString();
+  }
+}

package/src/serializable/fxs/common/id.spec.ts

@@ -0,0 +1,26 @@
+import { id, idBytes } from '../../../fixtures/common';
+import { testSerialization } from '../../../fixtures/utils/serializable';
+import { Id } from './id';
+
+testSerialization('Id', Id, id, idBytes);
+
+describe('id', function () {
+  it('works correctly', () => {
+    const id = Id.fromHex(
+      '0x6176617800000000000000000000000000000000000000000000000000000000',
+    );
+    const expectedIDStr = 'jvYiYUgxB6hG1dBobJK2JSoyuLtmFiDoXmUVxmAB7juqfbVtu';
+
+    const idStr = id.toString();
+
+    expect(idStr).toEqual(expectedIDStr);
+
+    expect(Id.fromString(expectedIDStr).toBytes()).toEqual(
+      new Uint8Array([
+        0x61, 0x76, 0x61, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      ]),
+    );
+  });
+});

package/src/serializable/fxs/common/id.ts

@@ -0,0 +1,51 @@
+import { customInspectSymbol } from '../../../constants/node';
+import { base58check } from '../../../utils/base58';
+import { hexToBuffer, padLeft } from '../../../utils/buffer';
+import { bytesCompare } from '../../../utils/bytesCompare';
+import { serializable } from '../../common/types';
+import { Primitives } from '../../primitives/primatives';
+import { TypeSymbols } from '../../constants';
+
+@serializable()
+export class Id extends Primitives {
+  _type = TypeSymbols.Id;
+  constructor(private readonly idVal: Uint8Array) {
+    super();
+  }
+
+  static fromBytes(buf: Uint8Array): [Id, Uint8Array] {
+    return [new Id(buf.slice(0, 32)), buf.slice(32)];
+  }
+
+  static compare(id1: Id, id2: Id): number {
+    return bytesCompare(id1.toBytes(), id2.toBytes());
+  }
+
+  [customInspectSymbol](_, options: any) {
+    return options.stylize(this.toString(), 'string');
+  }
+
+  toBytes() {
+    return padLeft(this.idVal, 32);
+  }
+
+  toJSON() {
+    return this.toString();
+  }
+
+  toString() {
+    return base58check.encode(this.toBytes());
+  }
+
+  static fromString(str: string) {
+    return Id.fromBytes(base58check.decode(str))[0];
+  }
+
+  static fromHex(hex: string): Id {
+    return new Id(hexToBuffer(hex));
+  }
+
+  value() {
+    return this.toString();
+  }
+}

package/src/serializable/fxs/common/index.ts

@@ -0,0 +1,5 @@
+import { Address } from './address';
+import { Id } from './id';
+import { NodeId } from './nodeId';
+
+export { Address, Id, NodeId };

package/src/serializable/fxs/common/nodeId.spec.ts

@@ -0,0 +1,6 @@
+import { testPVMCodec } from '../../../fixtures/codec';
+import { nodeId, nodeIdBytes } from '../../../fixtures/common';
+import { testSerialization } from '../../../fixtures/utils/serializable';
+import { NodeId } from './nodeId';
+
+testSerialization('NodeId', NodeId, nodeId, nodeIdBytes, testPVMCodec);

package/src/serializable/fxs/common/nodeId.ts

@@ -0,0 +1,50 @@
+import { customInspectSymbol } from '../../../constants/node';
+import { base58check } from '../../../utils/base58';
+import { hexToBuffer, padLeft } from '../../../utils/buffer';
+import { serializable } from '../../common/types';
+import { Primitives } from '../../primitives/primatives';
+import { TypeSymbols } from '../../constants';
+
+export const NodeIDPrefix = 'NodeID-';
+@serializable()
+export class NodeId extends Primitives {
+  _type = TypeSymbols.NodeId;
+  constructor(private readonly idVal: Uint8Array) {
+    super();
+  }
+
+  static fromBytes(buf: Uint8Array): [NodeId, Uint8Array] {
+    return [new NodeId(buf.slice(0, 20)), buf.slice(20)];
+  }
+
+  [customInspectSymbol](_, options: any) {
+    return options.stylize(this.toString(), 'string');
+  }
+
+  toBytes() {
+    return padLeft(this.idVal, 20);
+  }
+
+  toJSON() {
+    return this.toString();
+  }
+
+  toString() {
+    return NodeIDPrefix + base58check.encode(this.toBytes());
+  }
+
+  static fromString(str: string) {
+    if (!str.includes(NodeIDPrefix)) {
+      throw new Error('ID is missing prefix');
+    }
+    return this.fromBytes(base58check.decode(str.replace(NodeIDPrefix, '')))[0];
+  }
+
+  static fromHex(hex: string): NodeId {
+    return new NodeId(hexToBuffer(hex));
+  }
+
+  value() {
+    return this.toString();
+  }
+}

package/src/serializable/fxs/nft/credential.ts

@@ -0,0 +1,6 @@
+import { Credential as SepkCredential } from '../secp256k1/credential';
+import { TypeSymbols } from '../../constants';
+
+export class Credential extends SepkCredential {
+  _type = TypeSymbols.NftFxCredential;
+}

package/src/serializable/fxs/nft/index.ts

@@ -0,0 +1,23 @@
+import { Credential } from './credential';
+import { MintOperation } from './mintOperation';
+import { MintOutput } from './mintOutput';
+import { TransferOperation } from './transferOperation';
+import { TransferOutput } from './transferOutput';
+
+// https://github.com/ava-labs/avalanchego/blob/master/vms/nftfx/fx.go
+const TypeRegistry = Object.freeze([
+  MintOutput,
+  TransferOutput,
+  MintOperation,
+  TransferOperation,
+  Credential,
+]);
+
+export {
+  Credential,
+  MintOutput,
+  TransferOutput,
+  MintOperation,
+  TransferOperation,
+  TypeRegistry,
+};

package/src/serializable/fxs/nft/mintOperation.spec.ts

@@ -0,0 +1,10 @@
+import { mintOperation, mintOperationBytes } from '../../../fixtures/nft';
+import { testSerialization } from '../../../fixtures/utils/serializable';
+import { MintOperation } from './mintOperation';
+
+testSerialization(
+  'MintOperation',
+  MintOperation,
+  mintOperation,
+  mintOperationBytes,
+);

package/src/serializable/fxs/nft/mintOperation.ts

@@ -0,0 +1,38 @@
+import { serializable } from '../../common/types';
+import { Bytes, Int } from '../../primitives';
+import { pack, unpack } from '../../../utils/struct';
+import { Input, OutputOwnersList } from '../secp256k1';
+import { TypeSymbols } from '../../constants';
+
+/**
+ * @see https://github.com/ava-labs/avalanchego/blob/master/vms/nftfx/mint_operation.go
+ * @see https://docs.avax.network/specs/avm-transaction-serialization#nft-mint-op
+ */
+@serializable()
+export class MintOperation {
+  _type = TypeSymbols.NftFxMintOperation;
+  constructor(
+    private readonly input: Input,
+    private readonly groupId: Int,
+    private readonly payload: Bytes,
+    private readonly outputOwnerList: OutputOwnersList,
+  ) {}
+
+  static fromBytes(bytes: Uint8Array): [MintOperation, Uint8Array] {
+    const [input, groupId, payload, outputOwnerList, remaining] = unpack(
+      bytes,
+      [Input, Int, Bytes, OutputOwnersList] as const,
+    );
+    return [
+      new MintOperation(input, groupId, payload, outputOwnerList),
+      remaining,
+    ];
+  }
+
+  toBytes(codec) {
+    return pack(
+      [this.input, this.groupId, this.payload, this.outputOwnerList],
+      codec,
+    );
+  }
+}

package/src/serializable/fxs/nft/mintOutput.spec.ts

@@ -0,0 +1,5 @@
+import { MintOutput } from '.';
+import { mintOutput, mintOutputBytes } from '../../../fixtures/nft';
+import { testSerialization } from '../../../fixtures/utils/serializable';
+
+testSerialization('MintOutput', MintOutput, mintOutput, mintOutputBytes);

package/src/serializable/fxs/nft/mintOutput.ts

@@ -0,0 +1,33 @@
+import { serializable } from '../../common/types';
+import { Int } from '../../primitives';
+import { pack, unpack } from '../../../utils/struct';
+import { OutputOwners } from '../secp256k1';
+import { TypeSymbols } from '../../constants';
+
+/**
+ * @see https://github.com/ava-labs/avalanchego/blob/master/vms/nftfx/mint_output.go
+ * @see https://docs.avax.network/specs/avm-transaction-serialization/#nft-mint-output
+ */
+@serializable()
+export class MintOutput {
+  _type = TypeSymbols.NftFxMintOutput;
+
+  constructor(
+    private readonly groupId: Int,
+    private readonly outputOwners: OutputOwners,
+  ) {}
+
+  static fromBytes(bytes: Uint8Array, codec): [MintOutput, Uint8Array] {
+    const [groupId, owners, remaining] = unpack(
+      bytes,
+      [Int, OutputOwners] as const,
+      codec,
+    );
+
+    return [new MintOutput(groupId, owners), remaining];
+  }
+
+  toBytes(codec) {
+    return pack([this.groupId, this.outputOwners], codec);
+  }
+}

package/src/serializable/fxs/nft/transferOperation.spec.ts

@@ -0,0 +1,13 @@
+import {
+  transferOperation,
+  transferOperationBytes,
+} from '../../../fixtures/nft';
+import { testSerialization } from '../../../fixtures/utils/serializable';
+import { TransferOperation } from './transferOperation';
+
+testSerialization(
+  'TransferOperation',
+  TransferOperation,
+  transferOperation,
+  transferOperationBytes,
+);

package/src/serializable/fxs/nft/transferOperation.ts

@@ -0,0 +1,29 @@
+import { serializable } from '../../common/types';
+import { pack, unpack } from '../../../utils/struct';
+import { Input } from '../secp256k1';
+import { TransferOutput } from './transferOutput';
+import { TypeSymbols } from '../../constants';
+
+/**
+ * https://docs.avax.network/specs/avm-transaction-serialization#nft-transfer-op
+ *
+ */
+@serializable()
+export class TransferOperation {
+  _type = TypeSymbols.NftFxTransferOperation;
+
+  constructor(
+    private readonly input: Input,
+    private readonly output: TransferOutput,
+  ) {}
+
+  static fromBytes(bytes: Uint8Array): [TransferOperation, Uint8Array] {
+    const [input, output, remaining] = unpack(bytes, [Input, TransferOutput]);
+
+    return [new TransferOperation(input, output), remaining];
+  }
+
+  toBytes(codec) {
+    return pack([this.input, this.output], codec);
+  }
+}

package/src/serializable/fxs/nft/transferOutput.spec.ts

@@ -0,0 +1,10 @@
+import { TransferOutput } from '.';
+import { transferOutput, transferOutputBytes } from '../../../fixtures/nft';
+import { testSerialization } from '../../../fixtures/utils/serializable';
+
+testSerialization(
+  'TransferOutput',
+  TransferOutput,
+  transferOutput,
+  transferOutputBytes,
+);

package/src/serializable/fxs/nft/transferOutput.ts

@@ -0,0 +1,34 @@
+import { serializable } from '../../common/types';
+import { Bytes, Int } from '../../primitives';
+import { pack, unpack } from '../../../utils/struct';
+import { OutputOwners } from '../secp256k1';
+import { TypeSymbols } from '../../constants';
+
+/**
+ * @see https://github.com/ava-labs/avalanchego/blob/master/vms/nftfx/transfer_output.go
+ * @see https://docs.avax.network/specs/avm-transaction-serialization/#nft-transfer-output
+ */
+@serializable()
+export class TransferOutput {
+  _type = TypeSymbols.NftFxTransferOutput;
+
+  constructor(
+    public readonly groupId: Int,
+    public readonly payload: Bytes,
+    public readonly outputOwners: OutputOwners,
+  ) {}
+
+  static fromBytes(bytes: Uint8Array): [TransferOutput, Uint8Array] {
+    const [groupId, payload, outputOwners, remaining] = unpack(bytes, [
+      Int,
+      Bytes,
+      OutputOwners,
+    ] as const);
+
+    return [new TransferOutput(groupId, payload, outputOwners), remaining];
+  }
+
+  toBytes(codec) {
+    return pack([this.groupId, this.payload, this.outputOwners], codec);
+  }
+}

package/src/serializable/fxs/secp256k1/credential.spec.ts

@@ -0,0 +1,5 @@
+import { credential, credentialBytes } from '../../../fixtures/secp256k1';
+import { testSerialization } from '../../../fixtures/utils/serializable';
+import { Credential } from './credential';
+
+testSerialization('Credential', Credential, credential, credentialBytes);