@bitgo-forks/avalanchejs 4.1.0-alpha.1

package/src/serializable/primitives/short.spec.ts

@@ -0,0 +1,5 @@
+import { short, shortBytes } from '../../fixtures/primitives';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { Short } from './short';
+
+testSerialization('Short', Short, short, shortBytes);

package/src/serializable/primitives/short.ts

@@ -0,0 +1,28 @@
+import { bufferToNumber, hexToBuffer, padLeft } from '../../utils/buffer';
+import { serializable } from '../common/types';
+import { Primitives } from './primatives';
+import { TypeSymbols } from '../constants';
+
+@serializable()
+export class Short extends Primitives {
+  _type = TypeSymbols.Short;
+  constructor(private readonly short: number) {
+    super();
+  }
+
+  static fromBytes(buf: Uint8Array): [Short, Uint8Array] {
+    return [new Short(bufferToNumber(buf.slice(0, 2))), buf.slice(2)];
+  }
+
+  toJSON() {
+    return this.short.toString();
+  }
+
+  toBytes() {
+    return padLeft(hexToBuffer(this.short.toString(16)), 2);
+  }
+
+  value() {
+    return this.short;
+  }
+}

package/src/serializable/primitives/stringpr.spec.ts

@@ -0,0 +1,5 @@
+import { stringPr, stringPrBytes } from '../../fixtures/primitives';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { Stringpr } from './stringpr';
+
+testSerialization('Stringpr', Stringpr, stringPr, stringPrBytes);

package/src/serializable/primitives/stringpr.ts

@@ -0,0 +1,38 @@
+import { concatBytes, hexToBuffer, padLeft } from '../../utils/buffer';
+import { serializable } from '../common/types';
+import { Primitives } from './primatives';
+import { Short } from './short';
+import { TypeSymbols } from '../constants';
+
+@serializable()
+export class Stringpr extends Primitives {
+  _type = TypeSymbols.StringPr;
+  constructor(private readonly string: string) {
+    super();
+  }
+
+  static fromBytes(buf: Uint8Array): [Stringpr, Uint8Array] {
+    const [length, remaining] = Short.fromBytes(buf);
+    return [
+      new Stringpr(
+        new TextDecoder().decode(remaining.slice(0, length.value())),
+      ),
+      remaining.slice(length.value()),
+    ];
+  }
+
+  toJSON() {
+    return this.string;
+  }
+
+  toBytes() {
+    return concatBytes(
+      padLeft(hexToBuffer(this.string.length.toString(16)), 2),
+      new TextEncoder().encode(this.string),
+    );
+  }
+
+  value() {
+    return this.string;
+  }
+}

package/src/serializable/pvm/abstractSubnetTx.ts

@@ -0,0 +1,23 @@
+import type { Serializable } from '../common/types';
+import type { Id } from '../fxs/common';
+import type { Input } from '../fxs/secp256k1';
+import { PVMTx } from './abstractTx';
+
+export abstract class AbstractSubnetTx extends PVMTx {
+  abstract subnetAuth: Serializable;
+
+  abstract getSubnetID(): Id;
+
+  getSubnetAuth() {
+    return this.subnetAuth as Input;
+  }
+
+  getSigIndices(): number[][] {
+    return [
+      ...this.getInputs().map((input) => {
+        return input.sigIndicies();
+      }),
+      this.getSubnetAuth().values(),
+    ].filter((indicies): indicies is number[] => indicies !== undefined);
+  }
+}

package/src/serializable/pvm/abstractTx.ts

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

package/src/serializable/pvm/addDelegatorTx.spec.ts

@@ -0,0 +1,12 @@
+import { testPVMCodec } from '../../fixtures/codec';
+import { addDelegatorTx, addDelegatorTxBytes } from '../../fixtures/pvm';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { AddDelegatorTx } from './addDelegatorTx';
+
+testSerialization(
+  'AddDelegatorTx',
+  AddDelegatorTx,
+  addDelegatorTx,
+  addDelegatorTxBytes,
+  testPVMCodec,
+);

package/src/serializable/pvm/addDelegatorTx.ts

@@ -0,0 +1,54 @@
+import { concatBytes } from '../../utils/buffer';
+import { toListStruct } from '../../utils/serializeList';
+import { pack, unpack } from '../../utils/struct';
+import { BaseTx } from '../avax/baseTx';
+import { TransferableOutput } from '../avax/transferableOutput';
+import { Codec } from '../codec/codec';
+import type { Serializable } from '../common/types';
+import { serializable } from '../common/types';
+import { PVMTx } from './abstractTx';
+import { Validator } from './validator';
+import type { OutputOwners } from '../fxs/secp256k1';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @deprecated since {@link https://github.com/avalanche-foundation/ACPs/blob/main/ACPs/62-disable-addvalidatortx-and-adddelegatortx.md|Durango-upgrade}
+ * @see https://docs.avax.network/specs/platform-transaction-serialization#unsigned-add-delegator-tx
+ */
+@serializable()
+export class AddDelegatorTx extends PVMTx {
+  _type = TypeSymbols.AddDelegatorTx;
+
+  constructor(
+    public readonly baseTx: BaseTx,
+    public readonly validator: Validator,
+    public readonly stake: TransferableOutput[],
+    public readonly rewardsOwner: Serializable,
+  ) {
+    super();
+  }
+
+  getRewardsOwner() {
+    return this.rewardsOwner as OutputOwners;
+  }
+
+  static fromBytes(
+    bytes: Uint8Array,
+    codec: Codec,
+  ): [AddDelegatorTx, Uint8Array] {
+    const [baseTx, validator, stake, rewardsOwner, rest] = unpack(
+      bytes,
+      [BaseTx, Validator, toListStruct(TransferableOutput), Codec],
+      codec,
+    );
+
+    return [new AddDelegatorTx(baseTx, validator, stake, rewardsOwner), rest];
+  }
+
+  toBytes(codec: Codec) {
+    return concatBytes(
+      pack([this.baseTx, this.validator, this.stake], codec),
+      codec.PackPrefix(this.rewardsOwner),
+    );
+  }
+}

package/src/serializable/pvm/addPermissionlessDelegatorTx.spec.ts

@@ -0,0 +1,15 @@
+import { testPVMCodec } from '../../fixtures/codec';
+import {
+  addPermissionlessDelegatorTx,
+  addPermissionlessDelegatorTxBytes,
+} from '../../fixtures/pvm';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { AddPermissionlessDelegatorTx } from './addPermissionlessDelegatorTx';
+
+testSerialization(
+  'AddPermissionlessDelegatorTx',
+  AddPermissionlessDelegatorTx,
+  addPermissionlessDelegatorTx,
+  addPermissionlessDelegatorTxBytes,
+  testPVMCodec,
+);

package/src/serializable/pvm/addPermissionlessDelegatorTx.ts

@@ -0,0 +1,63 @@
+import { PVMTx } from './abstractTx';
+import { BaseTx } from '../avax/baseTx';
+import { TransferableOutput } from '../avax/transferableOutput';
+import type { Serializable } from '../common/types';
+import { serializable } from '../common/types';
+import { SubnetValidator } from './subnetValidator';
+import { Codec } from '../codec';
+import { concatBytes } from '../../utils/buffer';
+import { pack, unpack } from '../../utils/struct';
+import { packList, toListStruct } from '../../utils/serializeList';
+import type { OutputOwners } from '../fxs/secp256k1';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see https://docs.avax.network/specs/platform-transaction-serialization#unsigned-add-permissionless-delegator-tx
+ */
+@serializable()
+export class AddPermissionlessDelegatorTx extends PVMTx {
+  _type = TypeSymbols.AddPermissionlessDelegatorTx;
+
+  constructor(
+    public readonly baseTx: BaseTx,
+    public readonly subnetValidator: SubnetValidator,
+    public readonly stake: TransferableOutput[],
+    public readonly delegatorRewardsOwner: Serializable,
+  ) {
+    super();
+  }
+
+  getDelegatorRewardsOwner() {
+    return this.delegatorRewardsOwner as OutputOwners;
+  }
+
+  static fromBytes(
+    bytes: Uint8Array,
+    codec: Codec,
+  ): [AddPermissionlessDelegatorTx, Uint8Array] {
+    const [baseTx, subnetValidator, stakeOuts, delegatorRewardsOwner, rest] =
+      unpack(
+        bytes,
+        [BaseTx, SubnetValidator, toListStruct(TransferableOutput), Codec],
+        codec,
+      );
+
+    return [
+      new AddPermissionlessDelegatorTx(
+        baseTx,
+        subnetValidator,
+        stakeOuts,
+        delegatorRewardsOwner,
+      ),
+      rest,
+    ];
+  }
+
+  toBytes(codec: Codec): Uint8Array {
+    return concatBytes(
+      pack([this.baseTx, this.subnetValidator], codec),
+      packList(this.stake, codec),
+      codec.PackPrefix(this.delegatorRewardsOwner),
+    );
+  }
+}

package/src/serializable/pvm/addPermissionlessValidatorTx.spec.ts

@@ -0,0 +1,15 @@
+import { testPVMCodec } from '../../fixtures/codec';
+import {
+  addPermissionlessValidatorTx,
+  addPermissionlessValidatorTxBytes,
+} from '../../fixtures/pvm';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { AddPermissionlessValidatorTx } from './addPermissionlessValidatorTx';
+
+testSerialization(
+  'AddPermissionlessValidatorTx',
+  AddPermissionlessValidatorTx,
+  addPermissionlessValidatorTx,
+  addPermissionlessValidatorTxBytes,
+  testPVMCodec,
+);

package/src/serializable/pvm/addPermissionlessValidatorTx.ts

@@ -0,0 +1,94 @@
+import { PVMTx } from './abstractTx';
+import { BaseTx } from '../avax/baseTx';
+import { TransferableOutput } from '../avax/transferableOutput';
+import type { Serializable } from '../common/types';
+import { serializable } from '../common/types';
+import { SubnetValidator } from './subnetValidator';
+import { Codec } from '../codec';
+import { concatBytes } from '../../utils/buffer';
+import { pack, unpack } from '../../utils/struct';
+import { Int } from '../primitives';
+import { packList, toListStruct } from '../../utils/serializeList';
+import type { Signer, SignerEmpty } from './signer';
+import type { OutputOwners } from '../fxs/secp256k1';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see https://docs.avax.network/specs/platform-transaction-serialization#unsigned-add-permissionless-validator-tx
+ */
+@serializable()
+export class AddPermissionlessValidatorTx extends PVMTx {
+  _type = TypeSymbols.AddPermissionlessValidatorTx;
+
+  constructor(
+    public readonly baseTx: BaseTx,
+    public readonly subnetValidator: SubnetValidator,
+    public readonly signer: Signer | SignerEmpty,
+    public readonly stake: TransferableOutput[],
+    public readonly validatorRewardsOwner: Serializable,
+    public readonly delegatorRewardsOwner: Serializable,
+    public readonly shares: Int,
+  ) {
+    super();
+  }
+
+  getValidatorRewardsOwner() {
+    return this.validatorRewardsOwner as OutputOwners;
+  }
+
+  getDelegatorRewardsOwner() {
+    return this.delegatorRewardsOwner as OutputOwners;
+  }
+
+  static fromBytes(
+    bytes: Uint8Array,
+    codec: Codec,
+  ): [AddPermissionlessValidatorTx, Uint8Array] {
+    const [
+      baseTx,
+      subnetValidator,
+      signer,
+      stakeOuts,
+      validatorRewardsOwner,
+      delegatorRewardsOwner,
+      delegationShares,
+      rest,
+    ] = unpack(
+      bytes,
+      [
+        BaseTx,
+        SubnetValidator,
+        Codec,
+        toListStruct(TransferableOutput),
+        Codec,
+        Codec,
+        Int,
+      ],
+      codec,
+    );
+
+    return [
+      new AddPermissionlessValidatorTx(
+        baseTx,
+        subnetValidator,
+        signer,
+        stakeOuts,
+        validatorRewardsOwner,
+        delegatorRewardsOwner,
+        delegationShares,
+      ),
+      rest,
+    ];
+  }
+
+  toBytes(codec: Codec): Uint8Array {
+    return concatBytes(
+      pack([this.baseTx, this.subnetValidator], codec),
+      codec.PackPrefix(this.signer),
+      packList(this.stake, codec),
+      codec.PackPrefix(this.validatorRewardsOwner),
+      codec.PackPrefix(this.delegatorRewardsOwner),
+      this.shares.toBytes(),
+    );
+  }
+}

package/src/serializable/pvm/addSubnetValidatorTx.spec.ts

@@ -0,0 +1,15 @@
+import { testPVMCodec } from '../../fixtures/codec';
+import {
+  addSubnetValidatorTx,
+  addSubnetValidatorTxBytes,
+} from '../../fixtures/pvm';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { AddSubnetValidatorTx } from './addSubnetValidatorTx';
+
+testSerialization(
+  'AddSubnetValidatorTx',
+  AddSubnetValidatorTx,
+  addSubnetValidatorTx,
+  addSubnetValidatorTxBytes,
+  testPVMCodec,
+);

package/src/serializable/pvm/addSubnetValidatorTx.ts

@@ -0,0 +1,51 @@
+import { concatBytes } from '../../utils/buffer';
+import { pack, unpack } from '../../utils/struct';
+import { BaseTx } from '../avax/baseTx';
+import { Codec } from '../codec/codec';
+import type { Serializable } from '../common/types';
+import { serializable } from '../common/types';
+import { AbstractSubnetTx } from './abstractSubnetTx';
+import { SubnetValidator } from './subnetValidator';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see https://docs.avax.network/specs/platform-transaction-serialization#unsigned-add-subnet-validator-tx
+ */
+@serializable()
+export class AddSubnetValidatorTx extends AbstractSubnetTx {
+  _type = TypeSymbols.AddSubnetValidatorTx;
+
+  constructor(
+    public readonly baseTx: BaseTx,
+    public readonly subnetValidator: SubnetValidator,
+    public readonly subnetAuth: Serializable,
+  ) {
+    super();
+  }
+
+  getSubnetID() {
+    return this.subnetValidator.subnetId;
+  }
+
+  static fromBytes(
+    bytes: Uint8Array,
+    codec: Codec,
+  ): [AddSubnetValidatorTx, Uint8Array] {
+    const [baseTx, subnetValidator, subnetAuth, rest] = unpack(
+      bytes,
+      [BaseTx, SubnetValidator, Codec],
+      codec,
+    );
+    return [
+      new AddSubnetValidatorTx(baseTx, subnetValidator, subnetAuth),
+      rest,
+    ];
+  }
+
+  toBytes(codec: Codec) {
+    return concatBytes(
+      pack([this.baseTx, this.subnetValidator], codec),
+      codec.PackPrefix(this.subnetAuth),
+    );
+  }
+}

package/src/serializable/pvm/addValidatorTx.spec.ts

@@ -0,0 +1,12 @@
+import { testPVMCodec } from '../../fixtures/codec';
+import { addValidatorTx, addValidatorTxBytes } from '../../fixtures/pvm';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { AddValidatorTx } from './addValidatorTx';
+
+testSerialization(
+  'AddValidatorTx',
+  AddValidatorTx,
+  addValidatorTx,
+  addValidatorTxBytes,
+  testPVMCodec,
+);

package/src/serializable/pvm/addValidatorTx.ts

@@ -0,0 +1,60 @@
+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 { Codec } from '../codec/codec';
+import type { Serializable } from '../common/types';
+import { serializable } from '../common/types';
+import type { OutputOwners } from '../fxs/secp256k1';
+import { Int } from '../primitives';
+import { PVMTx } from './abstractTx';
+import { Validator } from './validator';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @deprecated since {@link https://github.com/avalanche-foundation/ACPs/blob/main/ACPs/62-disable-addvalidatortx-and-adddelegatortx.md|Durango-upgrade}
+ * @see https://docs.avax.network/specs/platform-transaction-serialization#unsigned-add-validator-tx
+ */
+@serializable()
+export class AddValidatorTx extends PVMTx {
+  _type = TypeSymbols.AddValidatorTx;
+
+  constructor(
+    public readonly baseTx: BaseTx,
+    public readonly validator: Validator,
+    public readonly stake: TransferableOutput[],
+    public readonly rewardsOwner: Serializable,
+    public readonly shares: Int,
+  ) {
+    super();
+  }
+
+  getRewardsOwner() {
+    return this.rewardsOwner as OutputOwners;
+  }
+
+  static fromBytes(
+    bytes: Uint8Array,
+    codec: Codec,
+  ): [AddValidatorTx, Uint8Array] {
+    const [baseTx, validator, stake, rewardsOwner, shares, rest] = unpack(
+      bytes,
+      [BaseTx, Validator, toListStruct(TransferableOutput), Codec, Int],
+      codec,
+    );
+    return [
+      new AddValidatorTx(baseTx, validator, stake, rewardsOwner, shares),
+      rest,
+    ];
+  }
+
+  toBytes(codec: Codec) {
+    return concatBytes(
+      pack([this.baseTx, this.validator], codec),
+      packList(this.stake, codec),
+      codec.PackPrefix(this.rewardsOwner),
+      this.shares.toBytes(),
+    );
+  }
+}

package/src/serializable/pvm/advanceTimeTx.spec.ts

@@ -0,0 +1,12 @@
+import { testPVMCodec } from '../../fixtures/codec';
+import { advanceTimeBytesTx, advanceTimeTx } from '../../fixtures/pvm';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { AdvanceTimeTx } from './advanceTimeTx';
+
+testSerialization(
+  'AdvanceTime',
+  AdvanceTimeTx,
+  advanceTimeTx,
+  advanceTimeBytesTx,
+  testPVMCodec,
+);

package/src/serializable/pvm/advanceTimeTx.ts

@@ -0,0 +1,28 @@
+import { packSwitched, unpack } from '../../utils/struct';
+import type { Codec } from '../codec/codec';
+import { serializable } from '../common/types';
+import { BigIntPr } from '../primitives';
+import { PVMTx } from './abstractTx';
+import { TypeSymbols } from '../constants';
+
+@serializable()
+export class AdvanceTimeTx extends PVMTx {
+  _type = TypeSymbols.AdvanceTimeTx;
+
+  constructor(public readonly time: BigIntPr) {
+    super();
+  }
+  baseTx = undefined;
+
+  static fromBytes(
+    bytes: Uint8Array,
+    codec: Codec,
+  ): [AdvanceTimeTx, Uint8Array] {
+    const [time, rest] = unpack(bytes, [BigIntPr], codec);
+    return [new AdvanceTimeTx(time), rest];
+  }
+
+  toBytes(codec: Codec) {
+    return packSwitched(codec, this.time);
+  }
+}

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

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

package/src/serializable/pvm/baseTx.ts

@@ -0,0 +1,28 @@
+import { unpack } from '../../utils/struct';
+import { BaseTx as AvaxBaseTx } from '../avax/baseTx';
+import type { Codec } from '../codec/codec';
+import { serializable } from '../common/types';
+import { PVMTx } from './abstractTx';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see https://github.com/avalanche-foundation/ACPs/blob/main/ACPs/23-p-chain-native-transfers.md
+ * TODO: add doc reference after D-upgrade
+ */
+@serializable()
+export class BaseTx extends PVMTx {
+  _type = TypeSymbols.PvmBaseTx;
+
+  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/pvm/codec.ts

@@ -0,0 +1,68 @@
+import { Codec, Manager } from '../codec';
+import * as Secp256k1Fx from '../fxs/secp256k1';
+import { AddDelegatorTx } from './addDelegatorTx';
+import { AddSubnetValidatorTx } from './addSubnetValidatorTx';
+import { AddValidatorTx } from './addValidatorTx';
+import { AdvanceTimeTx } from './advanceTimeTx';
+import { CreateChainTx } from './createChainTx';
+import { CreateSubnetTx } from './createSubnetTx';
+import { ExportTx } from './exportTx';
+import { ImportTx } from './importTx';
+import { RewardValidatorTx } from './rewardValidatorTx';
+import { StakeableLockIn } from './stakeableLockIn';
+import { StakeableLockOut } from './stakeableLockOut';
+import { AddPermissionlessValidatorTx } from './addPermissionlessValidatorTx';
+import { AddPermissionlessDelegatorTx } from './addPermissionlessDelegatorTx';
+import { Signer, SignerEmpty } from './signer';
+import { RemoveSubnetValidatorTx } from './removeSubnetValidatorTx';
+import { TransferSubnetOwnershipTx } from './transferSubnetOwnershipTx';
+import { TransformSubnetTx } from './transformSubnetTx';
+import { BaseTx } from './baseTx';
+
+/**
+ * @see https://github.com/ava-labs/avalanchego/blob/master/vms/platformvm/txs/codec.go#L35
+ */
+export const codec = new Codec([
+  ...new Array(5), // 0-4
+
+  ...Secp256k1Fx.TypeRegistry, // 5-9
+  Secp256k1Fx.Input, // 10
+  Secp256k1Fx.OutputOwners, //11
+
+  AddValidatorTx, // 12
+  AddSubnetValidatorTx, // 13
+  AddDelegatorTx, // 14
+
+  CreateChainTx, // 15
+  CreateSubnetTx, // 16
+
+  ImportTx, // 17
+  ExportTx, // 18
+
+  AdvanceTimeTx, //19
+  RewardValidatorTx, //20
+
+  StakeableLockIn, // 21
+  StakeableLockOut, // 22
+
+  RemoveSubnetValidatorTx, //23
+  TransformSubnetTx, // 24
+  AddPermissionlessValidatorTx, //  25
+  AddPermissionlessDelegatorTx, // 26
+
+  SignerEmpty, // 27
+  Signer, // 28
+
+  ...new Array(4), // 29-32
+
+  TransferSubnetOwnershipTx, // 33
+  BaseTx, // 34
+]);
+
+let manager: Manager;
+export const getPVMManager = () => {
+  if (manager) return manager;
+  manager = new Manager();
+  manager.RegisterCodec(0, codec);
+  return manager;
+};

package/src/serializable/pvm/createChainTx.spec.ts

@@ -0,0 +1,12 @@
+import { testPVMCodec } from '../../fixtures/codec';
+import { createChainTx, createChainTxBytes } from '../../fixtures/pvm';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { CreateChainTx } from './createChainTx';
+
+testSerialization(
+  'CreateChainTx',
+  CreateChainTx,
+  createChainTx,
+  createChainTxBytes,
+  testPVMCodec,
+);