@bitgo-forks/avalanchejs 4.1.0-alpha.1

package/src/serializable/pvm/createChainTx.ts

@@ -0,0 +1,76 @@
+import { concatBytes } from '@noble/hashes/utils';
+import { packList, toListStruct } from '../../utils/serializeList';
+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 { Id } from '../fxs/common';
+import { Bytes, Stringpr } from '../primitives';
+import { AbstractSubnetTx } from './abstractSubnetTx';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see
+ */
+@serializable()
+export class CreateChainTx extends AbstractSubnetTx {
+  _type = TypeSymbols.CreateChainTx;
+
+  constructor(
+    public readonly baseTx: BaseTx,
+    public readonly subnetID: Id,
+    public readonly chainName: Stringpr,
+    public readonly vmID: Id,
+    public readonly fxIds: Id[],
+    public readonly genesisData: Bytes,
+    public readonly subnetAuth: Serializable,
+  ) {
+    super();
+  }
+
+  getSubnetID() {
+    return this.subnetID;
+  }
+
+  static fromBytes(
+    bytes: Uint8Array,
+    codec: Codec,
+  ): [CreateChainTx, Uint8Array] {
+    const [
+      baseTx,
+      subnetID,
+      chainName,
+      vmID,
+      fxIds,
+      genesisData,
+      subnetAuth,
+      rest,
+    ] = unpack(
+      bytes,
+      [BaseTx, Id, Stringpr, Id, toListStruct(Id), Bytes, Codec],
+      codec,
+    );
+    return [
+      new CreateChainTx(
+        baseTx,
+        subnetID,
+        chainName,
+        vmID,
+        fxIds,
+        genesisData,
+        subnetAuth,
+      ),
+      rest,
+    ];
+  }
+
+  toBytes(codec: Codec) {
+    return concatBytes(
+      pack([this.baseTx, this.subnetID, this.chainName, this.vmID], codec),
+      packList(this.fxIds, codec),
+      this.genesisData.toBytes(),
+      codec.PackPrefix(this.subnetAuth),
+    );
+  }
+}

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

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

package/src/serializable/pvm/createSubnetTx.ts

@@ -0,0 +1,45 @@
+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 type { OutputOwners } from '../fxs/secp256k1';
+import { PVMTx } from './abstractTx';
+import { TypeSymbols } from '../constants';
+
+/**
+ * The docs for this do not match the actual code, there is no rewards owners just Owners
+ * @see https://docs.avax.network/specs/platform-transaction-serialization#unsigned-create-subnet-tx
+ * @see https://github.com/ava-labs/avalanchego/blob/535456298046b5c2fbcb95ce36702422b6980c66/vms/platformvm/txs/create_subnet_tx.go
+ */
+@serializable()
+export class CreateSubnetTx extends PVMTx {
+  _type = TypeSymbols.CreateSubnetTx;
+
+  constructor(
+    public readonly baseTx: BaseTx,
+    public readonly subnetOwners: Serializable,
+  ) {
+    super();
+  }
+
+  getSubnetOwners() {
+    return this.subnetOwners as OutputOwners;
+  }
+
+  static fromBytes(
+    bytes: Uint8Array,
+    codec: Codec,
+  ): [CreateSubnetTx, Uint8Array] {
+    const [baseTx, subnetOwners, rest] = unpack(bytes, [BaseTx, Codec], codec);
+    return [new CreateSubnetTx(baseTx, subnetOwners), rest];
+  }
+
+  toBytes(codec: Codec) {
+    return concatBytes(
+      pack([this.baseTx], codec),
+      codec.PackPrefix(this.subnetOwners),
+    );
+  }
+}

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

@@ -0,0 +1,6 @@
+import { testPVMCodec } from '../../fixtures/codec';
+import { exportTx, exportTxBytes } from '../../fixtures/pvm';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { ExportTx } from './exportTx';
+
+testSerialization('ExportTx', ExportTx, exportTx, exportTxBytes, testPVMCodec);

package/src/serializable/pvm/exportTx.ts

@@ -0,0 +1,38 @@
+import { toListStruct } from '../../utils/serializeList';
+import { packSwitched, 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 { PVMTx } from './abstractTx';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see
+ */
+@serializable()
+export class ExportTx extends PVMTx {
+  _type = TypeSymbols.PvmExportTx;
+
+  constructor(
+    public readonly baseTx: BaseTx,
+    public readonly destination: Id,
+    public readonly outs: TransferableOutput[],
+  ) {
+    super();
+  }
+
+  static fromBytes(bytes: Uint8Array, codec: Codec): [ExportTx, Uint8Array] {
+    const [baseTx, id, outs, rest] = unpack(
+      bytes,
+      [BaseTx, Id, toListStruct(TransferableOutput)],
+      codec,
+    );
+    return [new ExportTx(baseTx, id, outs), rest];
+  }
+
+  toBytes(codec: Codec) {
+    return packSwitched(codec, this.baseTx, this.destination, this.outs);
+  }
+}

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

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

package/src/serializable/pvm/importTx.ts

@@ -0,0 +1,42 @@
+import { 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 { PVMTx } from './abstractTx';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see
+ */
+@serializable()
+export class ImportTx extends PVMTx {
+  _type = TypeSymbols.PvmImportTx;
+
+  constructor(
+    public readonly baseTx: BaseTx,
+    public readonly sourceChain: Id,
+    public readonly ins: TransferableInput[],
+  ) {
+    super();
+  }
+
+  getSigIndices() {
+    return this.ins.map((inp) => inp.sigIndicies());
+  }
+
+  static fromBytes(bytes: Uint8Array, codec: Codec): [ImportTx, Uint8Array] {
+    const [baseTx, sourceChain, ins, rest] = unpack(
+      bytes,
+      [BaseTx, Id, toListStruct(TransferableInput)],
+      codec,
+    );
+    return [new ImportTx(baseTx, sourceChain, ins), rest];
+  }
+
+  toBytes(codec: Codec) {
+    return pack([this.baseTx, this.sourceChain, this.ins], codec);
+  }
+}

package/src/serializable/pvm/index.ts

@@ -0,0 +1,47 @@
+import { BaseTx } from './baseTx';
+import { RemoveSubnetValidatorTx } from './removeSubnetValidatorTx';
+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 { StakeableLockIn } from './stakeableLockIn';
+import { StakeableLockOut } from './stakeableLockOut';
+import { SubnetValidator } from './subnetValidator';
+import { Validator } from './validator';
+import { Signer, SignerEmpty } from './signer';
+import { ProofOfPossession } from './proofOfPossession';
+import { AddPermissionlessValidatorTx } from './addPermissionlessValidatorTx';
+import { AddPermissionlessDelegatorTx } from './addPermissionlessDelegatorTx';
+import { AbstractSubnetTx } from './abstractSubnetTx';
+import { TransferSubnetOwnershipTx } from './transferSubnetOwnershipTx';
+import { TransformSubnetTx } from './transformSubnetTx';
+
+export * from './typeGuards';
+export {
+  BaseTx,
+  AbstractSubnetTx,
+  AddDelegatorTx,
+  AddSubnetValidatorTx,
+  RemoveSubnetValidatorTx,
+  AddValidatorTx,
+  AdvanceTimeTx,
+  CreateChainTx,
+  CreateSubnetTx,
+  ExportTx,
+  ImportTx,
+  StakeableLockIn,
+  StakeableLockOut,
+  SubnetValidator,
+  Validator,
+  Signer,
+  SignerEmpty,
+  AddPermissionlessValidatorTx,
+  AddPermissionlessDelegatorTx,
+  ProofOfPossession,
+  TransferSubnetOwnershipTx,
+  TransformSubnetTx,
+};

package/src/serializable/pvm/proofOfPossession.test.ts

@@ -0,0 +1,48 @@
+import { ProofOfPossession } from './proofOfPossession';
+
+const publicKey = new Uint8Array([
+  0x85, 0x02, 0x5b, 0xca, 0x6a, 0x30, 0x2d, 0xc6, 0x13, 0x38, 0xff, 0x49, 0xc8,
+  0xba, 0xa5, 0x72, 0xde, 0xd3, 0xe8, 0x6f, 0x37, 0x59, 0x30, 0x4c, 0x7f, 0x61,
+  0x8a, 0x2a, 0x25, 0x93, 0xc1, 0x87, 0xe0, 0x80, 0xa3, 0xcf, 0xde, 0xc9, 0x50,
+  0x40, 0x30, 0x9a, 0xd1, 0xf1, 0x58, 0x95, 0x30, 0x67,
+]);
+
+const signature = new Uint8Array([
+  0x8b, 0x1d, 0x61, 0x33, 0xd1, 0x7e, 0x34, 0x83, 0x22, 0x0a, 0xd9, 0x60, 0xb6,
+  0xfd, 0xe1, 0x1e, 0x4e, 0x12, 0x14, 0xa8, 0xce, 0x21, 0xef, 0x61, 0x62, 0x27,
+  0xe5, 0xd5, 0xee, 0xf0, 0x70, 0xd7, 0x50, 0x0e, 0x6f, 0x7d, 0x44, 0x52, 0xc5,
+  0xa7, 0x60, 0x62, 0x0c, 0xc0, 0x67, 0x95, 0xcb, 0xe2, 0x18, 0xe0, 0x72, 0xeb,
+  0xa7, 0x6d, 0x94, 0x78, 0x8d, 0x9d, 0x01, 0x17, 0x6c, 0xe4, 0xec, 0xad, 0xfb,
+  0x96, 0xb4, 0x7f, 0x94, 0x22, 0x81, 0x89, 0x4d, 0xdf, 0xad, 0xd1, 0xc1, 0x74,
+  0x3f, 0x7f, 0x54, 0x9f, 0x1d, 0x07, 0xd5, 0x9d, 0x55, 0x65, 0x59, 0x27, 0xf7,
+  0x2b, 0xc6, 0xbf, 0x7c, 0x12,
+]);
+
+describe('proofOfPossession', function () {
+  it('can init', () => {
+    const pop = new ProofOfPossession(publicKey, signature);
+    expect(pop instanceof ProofOfPossession).toBe(true);
+  });
+
+  it('throws for invalid pubkey', () => {
+    expect(() => {
+      const popBytes = new Uint8Array([...publicKey, ...signature]);
+      popBytes[2] = 0x00;
+      ProofOfPossession.fromBytes(popBytes);
+    }).toThrow();
+  });
+
+  it('throws for invalid signature', () => {
+    expect(() => {
+      const popBytes = new Uint8Array([...publicKey, ...signature]);
+      popBytes[64] = 0x00;
+      ProofOfPossession.fromBytes(popBytes);
+    }).toThrow();
+  });
+
+  it('can call toString', () => {
+    const pop = new ProofOfPossession(publicKey, signature);
+    const expected = `0x85025bca6a302dc61338ff49c8baa572ded3e86f3759304c7f618a2a2593c187e080a3cfdec95040309ad1f1589530678b1d6133d17e3483220ad960b6fde11e4e1214a8ce21ef616227e5d5eef070d7500e6f7d4452c5a760620cc06795cbe218e072eba76d94788d9d01176ce4ecadfb96b47f942281894ddfadd1c1743f7f549f1d07d59d55655927f72bc6bf7c12`;
+    expect(pop.toString()).toEqual(expected);
+  });
+});

package/src/serializable/pvm/proofOfPossession.ts

@@ -0,0 +1,45 @@
+import { serializable } from '../common/types';
+import { bufferToHex, concatBytes } from '../../utils/buffer';
+import { bls } from '../../crypto';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see https://docs.avax.network/specs/platform-transaction-serialization#proof-of-possession-specification-1
+ */
+@serializable()
+export class ProofOfPossession {
+  _type = TypeSymbols.ProofOfPossession;
+
+  constructor(
+    public readonly publicKey: Uint8Array,
+    public readonly signature: Uint8Array,
+  ) {
+    const pk = bls.publicKeyFromBytes(publicKey);
+    const sig = bls.signatureFromBytes(signature);
+
+    pk.assertValidity();
+    sig.assertValidity();
+
+    if (!bls.verifyProofOfPossession(pk, sig, bls.publicKeyToBytes(pk))) {
+      throw new Error(`Invalid proof of possession`);
+    }
+  }
+
+  static fromBytes(bytes: Uint8Array): [ProofOfPossession, Uint8Array] {
+    const pubkey = bytes.slice(0, bls.PUBLIC_KEY_LENGTH);
+    const signature = bytes.slice(
+      bls.PUBLIC_KEY_LENGTH,
+      bls.PUBLIC_KEY_LENGTH + bls.SIGNATURE_LENGTH,
+    );
+    const rest = bytes.slice(bls.PUBLIC_KEY_LENGTH + bls.SIGNATURE_LENGTH);
+    return [new ProofOfPossession(pubkey, signature), rest];
+  }
+
+  toString() {
+    return bufferToHex(this.toBytes());
+  }
+
+  toBytes() {
+    return concatBytes(this.publicKey, this.signature);
+  }
+}

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

@@ -0,0 +1,15 @@
+import { RemoveSubnetValidatorTx } from './removeSubnetValidatorTx';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import {
+  removeSubnetValidatorTxBytes,
+  removeValidatorTx,
+} from '../../fixtures/pvm';
+import { testPVMCodec } from '../../fixtures/codec';
+
+testSerialization(
+  'RemoveSubnetValidator',
+  RemoveSubnetValidatorTx,
+  removeValidatorTx,
+  removeSubnetValidatorTxBytes,
+  testPVMCodec,
+);

package/src/serializable/pvm/removeSubnetValidatorTx.ts

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

package/src/serializable/pvm/rewardValidatorTx.ts

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

package/src/serializable/pvm/signer.ts

@@ -0,0 +1,49 @@
+import { serializable } from '../common/types';
+import { ProofOfPossession } from './proofOfPossession';
+import { pack, unpack } from '../../utils/struct';
+import type { Codec } from '../codec';
+import { TypeSymbols } from '../constants';
+
+@serializable()
+export class Signer {
+  _type = TypeSymbols.Signer;
+
+  constructor(public readonly proof: ProofOfPossession) {}
+
+  static fromBytes(bytes: Uint8Array, codec: Codec): [Signer, Uint8Array] {
+    const [proof, rest] = unpack(bytes, [ProofOfPossession], codec);
+    return [new Signer(proof), rest];
+  }
+
+  toBytes(codec: Codec) {
+    return pack([this.proof], codec);
+  }
+}
+
+@serializable()
+export class SignerEmpty {
+  _type = TypeSymbols.SignerEmpty;
+
+  static fromBytes(bytes: Uint8Array, codec: Codec): [SignerEmpty, Uint8Array] {
+    const [rest] = unpack(bytes, [], codec);
+    return [new SignerEmpty(), rest];
+  }
+
+  toBytes(codec: Codec) {
+    return pack([], codec);
+  }
+}
+
+export function createSignerOrSignerEmptyFromStrings(
+  publicKey?: Uint8Array,
+  signature?: Uint8Array,
+) {
+  return publicKey && signature
+    ? new Signer(
+        new ProofOfPossession(
+          new Uint8Array(publicKey),
+          new Uint8Array(signature),
+        ),
+      )
+    : new SignerEmpty();
+}

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

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

package/src/serializable/pvm/stakeableLockIn.ts

@@ -0,0 +1,41 @@
+import { concatBytes } from '@noble/hashes/utils';
+import { packSwitched, unpack } from '../../utils/struct';
+import type { Codec } from '../codec/codec';
+import type { Amounter } from '../common/types';
+import { serializable } from '../common/types';
+import { BigIntPr } from '../primitives';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see https://docs.avax.network/specs/platform-transaction-serialization#stakeablelockin
+ */
+@serializable()
+export class StakeableLockIn {
+  _type = TypeSymbols.StakeableLockIn;
+
+  constructor(
+    public readonly lockTime: BigIntPr,
+    public readonly transferableInput: Amounter,
+  ) {}
+
+  static fromBytes(
+    bytes: Uint8Array,
+    codec: Codec,
+  ): [StakeableLockIn, Uint8Array] {
+    const [lockTime, rest] = unpack(bytes, [BigIntPr], codec);
+
+    const [transferableInput, remaining] = codec.UnpackPrefix<Amounter>(rest);
+
+    return [new StakeableLockIn(lockTime, transferableInput), remaining];
+  }
+  amount() {
+    return this.transferableInput.amount();
+  }
+
+  toBytes(codec: Codec) {
+    return concatBytes(
+      packSwitched(codec, this.lockTime),
+      codec.PackPrefix(this.transferableInput),
+    );
+  }
+}

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

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

package/src/serializable/pvm/stakeableLockOut.ts

@@ -0,0 +1,69 @@
+import { concatBytes } from '@noble/hashes/utils';
+import { packSwitched, unpack } from '../../utils/struct';
+import { isTransferOut } from '../../utils/typeGuards';
+import { Codec } from '../codec/codec';
+import type { Amounter } from '../common/types';
+import { serializable } from '../common/types';
+import { BigIntPr } from '../primitives';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see https://docs.avax.network/specs/platform-transaction-serialization#stakeablelockin
+ */
+@serializable()
+export class StakeableLockOut implements Amounter {
+  _type = TypeSymbols.StakeableLockOut;
+
+  constructor(
+    public readonly lockTime: BigIntPr,
+    public readonly transferOut: Amounter,
+  ) {}
+
+  amount() {
+    return this.transferOut.amount();
+  }
+
+  /**
+   * Get the stakeable locktime of this output. After this date this output can be used like a TransferOut.
+   */
+  getStakeableLocktime() {
+    return this.lockTime.value();
+  }
+
+  getLocktime() {
+    return this.lockTime.value();
+  }
+
+  static fromBytes(
+    bytes: Uint8Array,
+    codec: Codec,
+  ): [StakeableLockOut, Uint8Array] {
+    const [lockTime, transferOut, rest] = unpack(
+      bytes,
+      [BigIntPr, Codec],
+      codec,
+    );
+    return [new StakeableLockOut(lockTime, transferOut as Amounter), rest];
+  }
+
+  getOwners() {
+    if (isTransferOut(this.transferOut)) {
+      return this.transferOut.getOwners();
+    }
+    throw new Error('Unable to get owners.');
+  }
+
+  getOutputOwners() {
+    if (isTransferOut(this.transferOut)) {
+      return this.transferOut.outputOwners;
+    }
+    throw new Error('Unable to get output owners.');
+  }
+
+  toBytes(codec: Codec) {
+    return concatBytes(
+      packSwitched(codec, this.lockTime),
+      codec.PackPrefix(this.transferOut),
+    );
+  }
+}

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

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