@bitgo-forks/avalanchejs 4.1.0-alpha.1

package/src/serializable/avax/transferableInput.ts

@@ -0,0 +1,108 @@
+import { concatBytes } from '../../utils/buffer';
+import { pack, unpack } from '../../utils/struct';
+import {
+  isStakeableLockIn,
+  isTransferInput,
+  isTransferOut,
+} from '../../utils/typeGuards';
+import type { Codec } from '../codec/codec';
+import type { Amounter } from '../common/types';
+import { serializable } from '../common/types';
+import { Id } from '../fxs/common/id';
+import { Input, TransferInput } from '../fxs/secp256k1';
+import { BigIntPr, Int } from '../primitives';
+import type { Utxo } from './utxo';
+import { UTXOID } from './utxoId';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see https://github.com/ava-labs/avalanchego/blob/master/vms/components/avax/transferables.go
+ * @see https://docs.avax.network/specs/coreth-atomic-transaction-serialization#transferable-input
+ * @see https://docs.avax.network/specs/avm-transaction-serialization#transferable-input
+ * @see https://docs.avax.network/specs/platform-transaction-serialization#transferable-input
+ */
+@serializable()
+export class TransferableInput {
+  _type = TypeSymbols.TransferableInput;
+
+  constructor(
+    public readonly utxoID: UTXOID,
+    public readonly assetId: Id,
+    public readonly input: Amounter,
+  ) {}
+
+  static fromBytes(
+    bytes: Uint8Array,
+    codec: Codec,
+  ): [TransferableInput, Uint8Array] {
+    const [utxoID, assetId, remaining] = unpack(bytes, [UTXOID, Id]);
+    const [input, rest] = codec.UnpackPrefix<Amounter>(remaining);
+
+    return [new TransferableInput(utxoID, assetId, input), rest];
+  }
+
+  static fromNative(
+    utxoId: string,
+    outputIdx: number,
+    assetId: string,
+    amount: bigint,
+    sigIndices: number[],
+  ) {
+    return new TransferableInput(
+      UTXOID.fromNative(utxoId, outputIdx),
+      Id.fromString(assetId),
+      new TransferInput(
+        new BigIntPr(amount),
+        new Input(sigIndices.map((num) => new Int(num))),
+      ),
+    );
+  }
+
+  static fromUtxoAndSigindicies(utxo: Utxo, sigIndicies: number[]) {
+    const out = utxo.output;
+    if (!isTransferOut(out)) {
+      throw new Error('utxo.output must be Transferout');
+    }
+
+    return new TransferableInput(
+      utxo.utxoId,
+      utxo.assetId,
+      TransferInput.fromNative(out.amount(), sigIndicies),
+    );
+  }
+
+  sigIndicies() {
+    const input = this.input;
+
+    if (isTransferInput(input)) {
+      return input.sigIndicies();
+    }
+    if (isStakeableLockIn(input)) {
+      const lockedInput = input.transferableInput;
+
+      if (isTransferInput(lockedInput)) {
+        return lockedInput.sigIndicies();
+      }
+    }
+    throw new Error('Input must be TransferInput or StakeableLockIn');
+  }
+
+  static compare(input1: TransferableInput, input2: TransferableInput): number {
+    return UTXOID.compare(input1.utxoID, input2.utxoID);
+  }
+
+  amount() {
+    return this.input.amount();
+  }
+
+  getAssetId() {
+    return this.assetId.toString();
+  }
+
+  toBytes(codec: Codec) {
+    return concatBytes(
+      pack([this.utxoID, this.assetId], codec),
+      codec.PackPrefix(this.input),
+    );
+  }
+}

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

@@ -0,0 +1,10 @@
+import { transferableOp, transferableOpBytes } from '../../fixtures/avax';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { TransferableOp } from './transferableOp';
+
+testSerialization(
+  'TransferableOp',
+  TransferableOp,
+  transferableOp,
+  transferableOpBytes,
+);

package/src/serializable/avax/transferableOp.ts

@@ -0,0 +1,44 @@
+import { concatBytes } from '../../utils/buffer';
+import { packList, toListStruct } from '../../utils/serializeList';
+import { pack, unpack } from '../../utils/struct';
+import { Codec } from '../codec/codec';
+import type { Serializable } from '../common/types';
+import { serializable } from '../common/types';
+import { Id } from '../fxs/common/id';
+import { UTXOID } from './utxoId';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see https://docs.avax.network/specs/avm-transaction-serialization#transferable-op
+ */
+@serializable()
+export class TransferableOp {
+  _type = TypeSymbols.TransferableOp;
+
+  constructor(
+    private readonly assetId: Id,
+    private readonly UTXOId: UTXOID[],
+    private readonly transferOp: Serializable,
+  ) {}
+
+  static fromBytes(
+    bytes: Uint8Array,
+    codec: Codec,
+  ): [TransferableOp, Uint8Array] {
+    const [assetId, utxoID, transferOp, remaining] = unpack(
+      bytes,
+      [Id, toListStruct(UTXOID), Codec],
+      codec,
+    );
+
+    return [new TransferableOp(assetId, utxoID, transferOp), remaining];
+  }
+
+  toBytes(codec: Codec) {
+    return concatBytes(
+      pack([this.assetId], codec),
+      packList(this.UTXOId, codec),
+      codec.PackPrefix(this.transferOp),
+    );
+  }
+}

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

@@ -0,0 +1,13 @@
+import {
+  transferableOutput,
+  transferableOutputBytes,
+} from '../../fixtures/avax';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { TransferableOutput } from './transferableOutput';
+
+testSerialization(
+  'TransferableInput',
+  TransferableOutput,
+  transferableOutput,
+  transferableOutputBytes,
+);

package/src/serializable/avax/transferableOutput.ts

@@ -0,0 +1,62 @@
+import { concatBytes } from '../../utils/buffer';
+import { pack, unpack } from '../../utils/struct';
+import type { Codec } from '../codec/codec';
+import type { Amounter } from '../common/types';
+import { serializable } from '../common/types';
+import { Id } from '../fxs/common/id';
+import { OutputOwners, TransferOutput } from '../fxs/secp256k1';
+import { BigIntPr } from '../primitives';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see https://github.com/ava-labs/avalanchego/blob/master/vms/components/avax/transferables.go
+ * @see https://docs.avax.network/specs/coreth-atomic-transaction-serialization#transferable-output
+ * @see https://docs.avax.network/specs/avm-transaction-serialization#transferable-output
+ * @see https://docs.avax.network/specs/platform-transaction-serialization#transferable-output
+ */
+@serializable()
+export class TransferableOutput {
+  _type = TypeSymbols.TransferableOutput;
+
+  constructor(public readonly assetId: Id, public readonly output: Amounter) {}
+
+  static fromNative(
+    assetId: string,
+    amt: bigint,
+    addresses: Uint8Array[],
+    locktime?: bigint,
+    threshold?: number,
+  ) {
+    return new TransferableOutput(
+      Id.fromString(assetId),
+      new TransferOutput(
+        new BigIntPr(amt),
+        OutputOwners.fromNative(addresses, locktime, threshold),
+      ),
+    );
+  }
+
+  static fromBytes(
+    bytes: Uint8Array,
+    codec: Codec,
+  ): [TransferableOutput, Uint8Array] {
+    const [assetId, remaining] = unpack(bytes, [Id], codec);
+    const [output, rest] = codec.UnpackPrefix<Amounter>(remaining);
+    return [new TransferableOutput(assetId, output), rest];
+  }
+
+  getAssetId() {
+    return this.assetId.toString();
+  }
+
+  amount() {
+    return this.output.amount();
+  }
+
+  toBytes(codec: Codec) {
+    return concatBytes(
+      pack([this.assetId], codec),
+      codec.PackPrefix(this.output),
+    );
+  }
+}

package/src/serializable/avax/typeGuards.ts

@@ -0,0 +1,21 @@
+import type { BaseTx } from './baseTx';
+import type { Serializable } from '../common/types';
+import type { TransferableOutput } from './transferableOutput';
+import type { TransferableInput } from './transferableInput';
+import { TypeSymbols } from '../constants';
+
+export function isBaseTx(tx: Serializable): tx is BaseTx {
+  return tx._type === TypeSymbols.BaseTx;
+}
+
+export function isTransferableOutput(
+  out: Serializable,
+): out is TransferableOutput {
+  return out._type === TypeSymbols.TransferableOutput;
+}
+
+export function isTransferableInput(
+  out: Serializable,
+): out is TransferableInput {
+  return out._type === TypeSymbols.TransferableInput;
+}

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

@@ -0,0 +1,14 @@
+import { hexToBuffer } from '../../utils/buffer';
+import { getPVMManager } from '../pvm/codec';
+import { Utxo } from './utxo';
+
+// testSerialization('Utxo', Utxo, utxo, utxoBytes);
+
+describe('examples with real data', () => {
+  it('samlpe 1', () => {
+    const bytes =
+      '0x00004cc3cf2e380c03f0227193a6573d1940350a43f028123ca68c14f54e33a11dcf000000093d9bdac0ed1d761330cf680efdeb1a42159eb387d6d2950c96f7d28f61bbe2aa000000160000000063af7b800000000700000002540be40000000000000000000000000100000001e0cfe8cae22827d032805ded484e393ce51cbedb7f24bb9c';
+
+    getPVMManager().unpack(hexToBuffer(bytes), Utxo);
+  });
+});

package/src/serializable/avax/utxo.ts

@@ -0,0 +1,60 @@
+import { concatBytes } from '@noble/hashes/utils';
+import { UTXOID } from '.';
+import { isRewardsOwner, isStakeableLockOut, isTransferOut } from '../../utils';
+import { pack, unpack } from '../../utils/struct';
+import { Codec } from '../codec/codec';
+import type { Serializable } from '../common/types';
+import { serializable } from '../common/types';
+import { Id } from '../fxs/common';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see https://docs.avax.network/specs/avm-transaction-serialization#unsigned-Exporttx
+ */
+@serializable()
+export class Utxo {
+  _type = TypeSymbols.UTXO;
+
+  constructor(
+    public readonly utxoId: UTXOID,
+    public readonly assetId: Id,
+    public readonly output: Serializable,
+  ) {}
+
+  static fromBytes(bytes: Uint8Array, codec: Codec): [Utxo, Uint8Array] {
+    const [utxoId, assetId, output, remaining] = unpack(
+      bytes,
+      [UTXOID, Id, Codec],
+      codec,
+    );
+    return [new Utxo(utxoId, assetId, output), remaining];
+  }
+
+  getOutputOwners() {
+    if (isTransferOut(this.output)) {
+      return this.output.outputOwners;
+    }
+    if (isStakeableLockOut(this.output)) {
+      return this.output.getOutputOwners();
+    }
+    if (isRewardsOwner(this.output)) {
+      return this.output;
+    }
+    throw new Error('unable to get output owner');
+  }
+
+  toBytes(codec) {
+    return concatBytes(
+      pack([this.utxoId, this.assetId], codec),
+      codec.PackPrefix(this.output),
+    );
+  }
+
+  getAssetId() {
+    return this.assetId.toString();
+  }
+
+  ID() {
+    return this.utxoId.ID();
+  }
+}

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

@@ -0,0 +1,29 @@
+import { UTXOID } from './utxoId';
+import { utxoId, utxoIdBytes } from '../../fixtures/avax';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { Id } from '../fxs/common';
+import { Int } from '../primitives';
+
+testSerialization('UTXOID', UTXOID, utxoId, utxoIdBytes);
+
+describe('UTXOID', () => {
+  it('generates correct id', () => {
+    expect(
+      new UTXOID(
+        Id.fromHex(
+          '0400000000000000000000000000000000000000000000000000000000000000',
+        ),
+        new Int(0),
+      ).ID(),
+    ).toEqual('HBD3fiEVpzFy569fjPgGKa7GZayj1K1tSWcRs2QWE3ZfjNzWv');
+
+    expect(
+      new UTXOID(
+        Id.fromHex(
+          '0x0500000000000000000000000000000000000000000000000000000000000000',
+        ),
+        new Int(4),
+      ).ID(),
+    ).toEqual('ZsXUqJ1rFapUSA7mRGJqGMFPjWtx1YHdb4csN6GWL9zZZ7sGs');
+  });
+});

package/src/serializable/avax/utxoId.ts

@@ -0,0 +1,52 @@
+import { sha256 } from '@noble/hashes/sha256';
+import { base58check } from '../../utils/base58';
+import { concatBytes } from '../../utils/buffer';
+import { pack, unpack } from '../../utils/struct';
+import type { Codec } from '../codec';
+import { serializable } from '../common/types';
+import { Id } from '../fxs/common/id';
+import { BigIntPr, Int } from '../primitives';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see https://github.com/ava-labs/avalanchego/blob/master/vms/components/avax/utxo_id.go
+ */
+@serializable()
+export class UTXOID {
+  _type = TypeSymbols.UTXOID;
+
+  constructor(public readonly txID: Id, public readonly outputIdx: Int) {}
+
+  static fromBytes(bytes: Uint8Array, codec: Codec): [UTXOID, Uint8Array] {
+    const [txID, outputIdx, remaining] = unpack(bytes, [Id, Int], codec);
+
+    return [new UTXOID(txID, outputIdx), remaining];
+  }
+
+  static fromNative(txId: string, outputIdx: number) {
+    return new UTXOID(Id.fromString(txId), new Int(outputIdx));
+  }
+
+  static compare(id1: UTXOID, id2: UTXOID) {
+    const txIDRes = Id.compare(id1.txID, id2.txID);
+    if (txIDRes !== 0) {
+      return txIDRes;
+    }
+    return id1.outputIdx.value() - id2.outputIdx.value();
+  }
+
+  toBytes(codec) {
+    return pack([this.txID, this.outputIdx], codec);
+  }
+
+  ID() {
+    return base58check.encode(
+      sha256(
+        concatBytes(
+          new BigIntPr(BigInt(this.outputIdx.value())).toBytes(),
+          this.txID.toBytes(),
+        ),
+      ),
+    );
+  }
+}

package/src/serializable/avm/abstractTx.ts

@@ -0,0 +1,6 @@
+import { AvaxTx } from '../avax/avaxTx';
+import { AVM } from '../constants';
+
+export abstract class AVMTx extends AvaxTx {
+  vm = AVM;
+}

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

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

package/src/serializable/avm/baseTx.ts

@@ -0,0 +1,27 @@
+import { unpack } from '../../utils/struct';
+import { BaseTx as AvaxBaseTx } from '../avax/baseTx';
+import type { Codec } from '../codec/codec';
+import { serializable } from '../common/types';
+import { AVMTx } from './abstractTx';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see https://docs.avax.network/specs/avm-transaction-serialization#unsigned-basetx
+ */
+@serializable()
+export class BaseTx extends AVMTx {
+  _type = TypeSymbols.AvmBaseTx;
+
+  constructor(public readonly baseTx: AvaxBaseTx) {
+    super();
+  }
+
+  static fromBytes(bytes: Uint8Array, codec: Codec): [BaseTx, Uint8Array] {
+    const [baseTx, remaining] = unpack(bytes, [AvaxBaseTx], codec);
+    return [new BaseTx(baseTx), remaining];
+  }
+
+  toBytes(codec: Codec) {
+    return this.baseTx.toBytes(codec);
+  }
+}

package/src/serializable/avm/codec.ts

@@ -0,0 +1,33 @@
+import { BaseTx } from './baseTx';
+import { Codec } from '../codec/codec';
+import { Manager } from '../codec/manager';
+import * as NftFx from '../fxs/nft';
+import * as Secp256k1Fx from '../fxs/secp256k1';
+import { CreateAssetTx } from './createAssetTx';
+import { ExportTx } from './exportTx';
+import { ImportTx } from './importTx';
+import { OperationTx } from './operationTx';
+
+// https://github.com/ava-labs/avalanchego/blob/master/vms/avm/txs/parser.go
+// https://github.com/ava-labs/avalanchego/blob/master/wallet/chain/x/constants.go
+let manager: Manager;
+
+export const getAVMManager = () => {
+  if (manager) return manager;
+
+  manager = new Manager();
+  manager.RegisterCodec(
+    0,
+    new Codec([
+      BaseTx,
+      CreateAssetTx,
+      OperationTx,
+      ImportTx,
+      ExportTx,
+      ...Secp256k1Fx.TypeRegistry,
+      ...NftFx.TypeRegistry,
+      // TODO: ...PropertyFx.TypeRegistry,
+    ]),
+  );
+  return manager;
+};

package/src/serializable/avm/createAssetTx.spec.ts

@@ -0,0 +1,10 @@
+import { createAssetTx, createAssetTxBytes } from '../../fixtures/avax';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { CreateAssetTx } from './createAssetTx';
+
+testSerialization(
+  'CreateAssetTx',
+  CreateAssetTx,
+  createAssetTx,
+  createAssetTxBytes,
+);

package/src/serializable/avm/createAssetTx.ts

@@ -0,0 +1,47 @@
+import { concatBytes } from '../../utils/buffer';
+import { packList, toListStruct } from '../../utils/serializeList';
+import { pack, unpack } from '../../utils/struct';
+import { BaseTx } from '../avax/baseTx';
+import type { Codec } from '../codec/codec';
+import { serializable } from '../common/types';
+import { Byte, Stringpr } from '../primitives';
+import { InitialState } from './initialState';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see https://docs.avax.network/specs/avm-transaction-serialization#unsigned-createassettx
+ */
+@serializable()
+export class CreateAssetTx {
+  _type = TypeSymbols.CreateAssetTx;
+
+  constructor(
+    private readonly baseTx: BaseTx,
+    private readonly name: Stringpr,
+    private readonly symbol: Stringpr,
+    private readonly denomination: Byte,
+    private readonly initialStates: InitialState[],
+  ) {}
+
+  static fromBytes(
+    bytes: Uint8Array,
+    codec: Codec,
+  ): [CreateAssetTx, Uint8Array] {
+    const [baseTx, name, symbol, domination, initialStates, remaining] = unpack(
+      bytes,
+      [BaseTx, Stringpr, Stringpr, Byte, toListStruct(InitialState)],
+      codec,
+    );
+    return [
+      new CreateAssetTx(baseTx, name, symbol, domination, initialStates),
+      remaining,
+    ];
+  }
+
+  toBytes(codec: Codec) {
+    return concatBytes(
+      pack([this.baseTx, this.name, this.symbol, this.denomination], codec),
+      packList(this.initialStates, codec),
+    );
+  }
+}

package/src/serializable/avm/exportTx.spec.ts

@@ -0,0 +1,5 @@
+import { exportTx, exportTxBytes } from '../../fixtures/avax';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { ExportTx } from './exportTx';
+
+testSerialization('ExportTx', ExportTx, exportTx, exportTxBytes);

package/src/serializable/avm/exportTx.ts

@@ -0,0 +1,41 @@
+import { concatBytes } from '../../utils/buffer';
+import { packList, toListStruct } from '../../utils/serializeList';
+import { pack, unpack } from '../../utils/struct';
+import { BaseTx } from '../avax/baseTx';
+import { TransferableOutput } from '../avax/transferableOutput';
+import type { Codec } from '../codec/codec';
+import { serializable } from '../common/types';
+import { Id } from '../fxs/common';
+import { AVMTx } from './abstractTx';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see https://docs.avax.network/specs/avm-transaction-serialization#unsigned-Exporttx
+ */
+@serializable()
+export class ExportTx extends AVMTx {
+  _type = TypeSymbols.AvmExportTx;
+  constructor(
+    public readonly baseTx: BaseTx,
+    public readonly destination: Id,
+    public readonly outs: TransferableOutput[],
+  ) {
+    super();
+  }
+
+  static fromBytes(bytes: Uint8Array, codec: Codec): [ExportTx, Uint8Array] {
+    const [baseTx, sourceChain, outs, remaining] = unpack(
+      bytes,
+      [BaseTx, Id, toListStruct(TransferableOutput)],
+      codec,
+    );
+    return [new ExportTx(baseTx, sourceChain, outs), remaining];
+  }
+
+  toBytes(codec: Codec) {
+    return concatBytes(
+      pack([this.baseTx, this.destination], codec),
+      packList(this.outs, codec),
+    );
+  }
+}

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

@@ -0,0 +1,5 @@
+import { importTx, importTxBytes } from '../../fixtures/avax';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { ImportTx } from './importTx';
+
+testSerialization('ImportTx', ImportTx, importTx, importTxBytes);

package/src/serializable/avm/importTx.ts

@@ -0,0 +1,48 @@
+import { concatBytes } from '../../utils/buffer';
+import { packList, toListStruct } from '../../utils/serializeList';
+import { pack, unpack } from '../../utils/struct';
+import { BaseTx } from '../avax/baseTx';
+import { TransferableInput } from '../avax/transferableInput';
+import type { Codec } from '../codec/codec';
+import { serializable } from '../common/types';
+import { Id } from '../fxs/common';
+import { AVMTx } from './abstractTx';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see https://docs.avax.network/specs/avm-transaction-serialization#unsigned-importtx
+ */
+@serializable()
+export class ImportTx extends AVMTx {
+  _type = TypeSymbols.AvmImportTx;
+
+  constructor(
+    readonly baseTx: BaseTx,
+    readonly sourceChain: Id,
+    readonly ins: TransferableInput[],
+  ) {
+    super();
+  }
+
+  getSigIndices() {
+    return this.ins
+      .map((inp) => inp.sigIndicies())
+      .concat(super.getSigIndices());
+  }
+
+  static fromBytes(bytes: Uint8Array, codec: Codec): [ImportTx, Uint8Array] {
+    const [baseTx, sourceChain, ins, remaining] = unpack(
+      bytes,
+      [BaseTx, Id, toListStruct(TransferableInput)],
+      codec,
+    );
+    return [new ImportTx(baseTx, sourceChain, ins), remaining];
+  }
+
+  toBytes(codec: Codec) {
+    return concatBytes(
+      pack([this.baseTx, this.sourceChain], codec),
+      packList(this.ins, codec),
+    );
+  }
+}

package/src/serializable/avm/index.ts

@@ -0,0 +1,9 @@
+import { BaseTx } from './baseTx';
+import { CreateAssetTx } from './createAssetTx';
+import { ExportTx } from './exportTx';
+import { ImportTx } from './importTx';
+import { InitialState } from './initialState';
+import { OperationTx } from './operationTx';
+export { getAVMManager } from './codec';
+export * from './typeGuards';
+export { BaseTx, CreateAssetTx, ExportTx, ImportTx, InitialState, OperationTx };