@bitgo-forks/avalanchejs 4.1.0-alpha.1

package/src/vms/pvm/builder.spec.ts

@@ -0,0 +1,827 @@
+import { testContext } from '../../fixtures/context';
+import {
+  fromAddressBytes,
+  getBaseTxForTest,
+  getStakeableLockedTransferableInputForTest,
+  getStakeableLockedTransferableOutForTest,
+  getTransferableInputForTest,
+  getTransferableOutForTest,
+  getValidUtxo,
+  testAvaxAssetID,
+  testGenesisData,
+  testOwnerXAddress,
+  testSubnetId,
+  testUTXOID1,
+  testUtxos,
+  testVMId,
+} from '../../fixtures/transactions';
+import { expectTxs } from '../../fixtures/utils/expectTx';
+import { testAddress1 } from '../../fixtures/vms';
+import {
+  BaseTx as AvaxBaseTx,
+  TransferableInput,
+  TransferableOutput,
+  UTXOID,
+} from '../../serializable/avax';
+import { Utxo } from '../../serializable/avax/utxo';
+import { Id } from '../../serializable/fxs/common';
+import {
+  Input,
+  OutputOwners,
+  TransferInput,
+  TransferOutput,
+} from '../../serializable/fxs/secp256k1';
+import {
+  BigIntPr,
+  Byte,
+  Bytes,
+  Int,
+  Stringpr,
+} from '../../serializable/primitives';
+import type { BaseTx } from '../../serializable/pvm';
+import {
+  AddDelegatorTx,
+  AddPermissionlessDelegatorTx,
+  AddPermissionlessValidatorTx,
+  AddSubnetValidatorTx,
+  AddValidatorTx,
+  CreateChainTx,
+  CreateSubnetTx,
+  ExportTx,
+  ImportTx,
+  Signer,
+  StakeableLockOut,
+  SubnetValidator,
+  TransferSubnetOwnershipTx,
+  TransformSubnetTx,
+  Validator,
+} from '../../serializable/pvm';
+import { hexToBuffer } from '../../utils';
+import {
+  newAddDelegatorTx,
+  newAddPermissionlessValidatorTx,
+  newAddSubnetValidatorTx,
+  newAddValidatorTx,
+  newCreateBlockchainTx,
+  newCreateSubnetTx,
+  newExportTx,
+  newImportTx,
+  newRemoveSubnetValidatorTx,
+  newAddPermissionlessDelegatorTx,
+  newBaseTx,
+  newTransferSubnetOwnershipTx,
+  newTransformSubnetTx,
+} from './builder';
+import { RemoveSubnetValidatorTx } from '../../serializable/pvm/removeSubnetValidatorTx';
+import { NodeId } from '../../serializable/fxs/common/nodeId';
+import { proofOfPossession } from '../../fixtures/pvm';
+import {
+  blsPublicKeyBytes,
+  blsSignatureBytes,
+} from '../../fixtures/primitives';
+import { AvaxToNAvax } from '../../utils/avaxToNAvax';
+import { PrimaryNetworkID } from '../../constants/networkIDs';
+
+describe('pvmBuilder', () => {
+  const nodeID = 'NodeID-2m38qc95mhHXtrhjyGbe7r2NhniqHHJRB';
+  const toAddress = hexToBuffer('0x5432112345123451234512');
+
+  const getRewardsOwners = () => OutputOwners.fromNative([toAddress]);
+
+  it('baseTx', () => {
+    const utxos = testUtxos();
+    const toAddress = hexToBuffer('0x5432112345123451234512');
+    const tnsOut = TransferableOutput.fromNative(
+      testAvaxAssetID.toString(),
+      BigInt(1 * 1e9),
+      [toAddress],
+    );
+    const tx = newBaseTx(testContext, [testOwnerXAddress.toBytes()], utxos, [
+      tnsOut,
+    ]);
+    const {
+      baseTx: { inputs, outputs },
+    } = tx.getTx() as BaseTx;
+
+    expect(outputs.length).toEqual(2);
+    expect(outputs as TransferableOutput[]).toEqual([
+      tnsOut,
+      new TransferableOutput(
+        testAvaxAssetID,
+        new TransferOutput(
+          new BigIntPr(48999000000n), // input - amount sent - fee
+          OutputOwners.fromNative([testOwnerXAddress.toBytes()]),
+        ),
+      ),
+    ]);
+
+    expect(inputs.length).toEqual(1);
+    expect(inputs as TransferableInput[]).toEqual([
+      new TransferableInput(
+        utxos[2].utxoId,
+        testAvaxAssetID,
+        new TransferInput(
+          new BigIntPr(BigInt(50 * 1e9)),
+          Input.fromNative([0]),
+        ),
+      ),
+    ]);
+  });
+
+  it('importTx', () => {
+    const utxos = testUtxos();
+    const tx = newImportTx(
+      testContext,
+      testContext.cBlockchainID,
+      utxos,
+      [testAddress1],
+      fromAddressBytes,
+    );
+    const importTx = tx.getTx() as ImportTx;
+
+    const expectedTx = new ImportTx(
+      AvaxBaseTx.fromNative(
+        testContext.networkID,
+        testContext.pBlockchainID,
+        [
+          TransferableOutput.fromNative(testContext.avaxAssetID, 49999000000n, [
+            testAddress1,
+          ]),
+        ],
+        [],
+        new Uint8Array([]),
+      ),
+      Id.fromString(testContext.cBlockchainID),
+      [TransferableInput.fromUtxoAndSigindicies(utxos[2], [0])],
+    );
+
+    expect(JSON.stringify(importTx, null, 2)).toEqual(
+      JSON.stringify(expectedTx, null, 2),
+    );
+  });
+
+  it('exportTx', () => {
+    const tnsOut = TransferableOutput.fromNative(
+      testContext.avaxAssetID,
+      BigInt(5 * 1e9),
+      [toAddress],
+    );
+    const unsignedTx = newExportTx(
+      testContext,
+      testContext.cBlockchainID,
+      fromAddressBytes,
+      testUtxos(),
+      [tnsOut],
+    );
+
+    const expectedTx = new ExportTx(
+      AvaxBaseTx.fromNative(
+        testContext.networkID,
+        testContext.pBlockchainID,
+        [
+          TransferableOutput.fromNative(
+            testContext.avaxAssetID,
+            44999000000n,
+            fromAddressBytes,
+          ),
+        ],
+        [getTransferableInputForTest()],
+        new Uint8Array(),
+      ),
+      Id.fromString(testContext.cBlockchainID),
+      [tnsOut],
+    );
+
+    expectTxs(unsignedTx.getTx(), expectedTx);
+  });
+
+  it('AddValidatorTx', () => {
+    const unsignedTx = newAddValidatorTx(
+      testContext,
+      testUtxos(),
+      fromAddressBytes,
+      nodeID,
+      100n,
+      200n,
+      BigInt(1e9),
+      [toAddress],
+      30 * 10000,
+    );
+
+    const expectedTx = new AddValidatorTx(
+      getBaseTxForTest(49000000000n, testContext.pBlockchainID),
+      Validator.fromNative(nodeID, 100n, 200n, BigInt(1e9)),
+      [getTransferableOutForTest(1000000000n)],
+      getRewardsOwners(),
+      new Int(30 * 10000),
+    );
+
+    expectTxs(unsignedTx.getTx(), expectedTx);
+  });
+
+  it('AddValidatorTx - stakeable locked', () => {
+    const utxos = testUtxos();
+    const lockTime = BigInt(Math.floor(new Date().getTime() / 1000)) + 10000n;
+    const lockedUtxo = new Utxo(
+      new UTXOID(testUTXOID1, new Int(0)),
+      testAvaxAssetID,
+      new StakeableLockOut(
+        new BigIntPr(lockTime),
+        new TransferOutput(
+          new BigIntPr(BigInt(50 * 1e9)),
+          OutputOwners.fromNative([testOwnerXAddress.toBytes()]),
+        ),
+      ),
+    );
+
+    utxos.push(lockedUtxo);
+    const unsignedTx = newAddValidatorTx(
+      testContext,
+      utxos,
+      fromAddressBytes,
+      nodeID,
+      100n,
+      200n,
+      BigInt(1e9),
+      [toAddress],
+      30 * 10000,
+    );
+
+    const expectedTx = new AddValidatorTx(
+      AvaxBaseTx.fromNative(
+        testContext.networkID,
+        testContext.pBlockchainID,
+        [getStakeableLockedTransferableOutForTest(49000000000n, lockTime)],
+        [getStakeableLockedTransferableInputForTest(50000000000n, lockTime)],
+        new Uint8Array(),
+      ),
+      Validator.fromNative(nodeID, 100n, 200n, BigInt(1e9)),
+      [getStakeableLockedTransferableOutForTest(1000000000n, lockTime)],
+      getRewardsOwners(),
+      new Int(30 * 10000),
+    );
+
+    expectTxs(unsignedTx.getTx(), expectedTx);
+  });
+
+  it('AddDelegatorTx', () => {
+    const utxos = testUtxos();
+    const lockTime = BigInt(Math.floor(new Date().getTime() / 1000)) + 10000n;
+    const lockedUtxo = new Utxo(
+      new UTXOID(testUTXOID1, new Int(0)),
+      testAvaxAssetID,
+      new StakeableLockOut(
+        new BigIntPr(lockTime),
+        new TransferOutput(
+          new BigIntPr(BigInt(50 * 1e9)),
+          OutputOwners.fromNative([testOwnerXAddress.toBytes()]),
+        ),
+      ),
+    );
+
+    utxos.push(lockedUtxo);
+
+    const unsignedTx = newAddDelegatorTx(
+      testContext,
+      utxos,
+      fromAddressBytes,
+      nodeID,
+      100n,
+      200n,
+      BigInt(1e9),
+      [toAddress],
+    );
+
+    const expectedTx = new AddDelegatorTx(
+      AvaxBaseTx.fromNative(
+        testContext.networkID,
+        testContext.pBlockchainID,
+        [getStakeableLockedTransferableOutForTest(49000000000n, lockTime)],
+        [getStakeableLockedTransferableInputForTest(50000000000n, lockTime)],
+        new Uint8Array(),
+      ),
+      Validator.fromNative(nodeID, 100n, 200n, BigInt(1e9)),
+      [getStakeableLockedTransferableOutForTest(1000000000n, lockTime)],
+      getRewardsOwners(),
+    );
+
+    expectTxs(unsignedTx.getTx(), expectedTx);
+  });
+
+  it('AddDelegatorTx - stakeable locked', () => {
+    const unsignedTx = newAddDelegatorTx(
+      testContext,
+      testUtxos(),
+      fromAddressBytes,
+      nodeID,
+      100n,
+      200n,
+      BigInt(1e9),
+      [toAddress],
+    );
+
+    const expectedTx = new AddDelegatorTx(
+      getBaseTxForTest(49000000000n, testContext.pBlockchainID),
+      Validator.fromNative(nodeID, 100n, 200n, BigInt(1e9)),
+      [getTransferableOutForTest(1000000000n)],
+      getRewardsOwners(),
+    );
+
+    expectTxs(unsignedTx.getTx(), expectedTx);
+  });
+
+  it('newCreateSubnetTx', () => {
+    const utxoInputAmt = BigInt(2 * 1e9);
+    const unsignedTx = newCreateSubnetTx(
+      testContext,
+      [getValidUtxo(new BigIntPr(utxoInputAmt))],
+      fromAddressBytes,
+      [toAddress],
+    );
+
+    const expectedTx = new CreateSubnetTx(
+      AvaxBaseTx.fromNative(
+        testContext.networkID,
+        testContext.pBlockchainID,
+        [
+          getTransferableOutForTest(
+            utxoInputAmt - testContext.createSubnetTxFee,
+          ),
+        ],
+        [getTransferableInputForTest(utxoInputAmt)],
+        new Uint8Array(),
+      ),
+      getRewardsOwners(),
+    );
+
+    expectTxs(unsignedTx.getTx(), expectedTx);
+  });
+
+  it('newCreateBlockchainTx', () => {
+    const utxoInputAmt = BigInt(2 * 1e9);
+    const unsignedTx = newCreateBlockchainTx(
+      testContext,
+      [getValidUtxo(new BigIntPr(utxoInputAmt))],
+      fromAddressBytes,
+      Id.fromHex(testSubnetId).toString(),
+      'Random Chain Name',
+      Id.fromHex(testVMId).toString(),
+      [],
+      testGenesisData,
+      [0],
+    );
+
+    const expectedTx = new CreateChainTx(
+      AvaxBaseTx.fromNative(
+        testContext.networkID,
+        testContext.pBlockchainID,
+        [
+          getTransferableOutForTest(
+            utxoInputAmt - testContext.createBlockchainTxFee,
+          ),
+        ],
+        [getTransferableInputForTest(utxoInputAmt)],
+        new Uint8Array(),
+      ),
+      Id.fromHex(testSubnetId),
+      new Stringpr('Random Chain Name'),
+      Id.fromHex(testVMId),
+      [],
+      new Bytes(new TextEncoder().encode(JSON.stringify(testGenesisData))),
+      Input.fromNative([0]),
+    );
+
+    expectTxs(unsignedTx.getTx(), expectedTx);
+  });
+
+  it('newCreateSubnetValidatorTx', () => {
+    const utxoInputAmt = BigInt(2 * 1e9);
+    const unsignedTx = newAddSubnetValidatorTx(
+      testContext,
+      [getValidUtxo(new BigIntPr(utxoInputAmt))],
+      fromAddressBytes,
+      nodeID,
+      100n,
+      190000000n,
+      1800000n,
+      Id.fromHex(testSubnetId).toString(),
+      [0],
+    );
+
+    const expectedTx = new AddSubnetValidatorTx(
+      AvaxBaseTx.fromNative(
+        testContext.networkID,
+        testContext.pBlockchainID,
+        [getTransferableOutForTest(utxoInputAmt - testContext.baseTxFee)],
+        [getTransferableInputForTest(utxoInputAmt)],
+        new Uint8Array(),
+      ),
+      SubnetValidator.fromNative(
+        nodeID,
+        100n,
+        190000000n,
+        1800000n,
+        Id.fromHex(testSubnetId),
+      ),
+      Input.fromNative([0]),
+    );
+
+    expectTxs(unsignedTx.getTx(), expectedTx);
+  });
+
+  it('newRemoveSubnetValidatorTx', () => {
+    const utxoInputAmt = BigInt(2 * 1e9);
+    const unsignedTx = newRemoveSubnetValidatorTx(
+      testContext,
+      [getValidUtxo(new BigIntPr(utxoInputAmt))],
+      fromAddressBytes,
+      nodeID,
+      Id.fromHex(testSubnetId).toString(),
+      [0],
+    );
+
+    const expectedTx = new RemoveSubnetValidatorTx(
+      AvaxBaseTx.fromNative(
+        testContext.networkID,
+        testContext.pBlockchainID,
+        [getTransferableOutForTest(utxoInputAmt - testContext.baseTxFee)],
+        [getTransferableInputForTest(utxoInputAmt)],
+        new Uint8Array(),
+      ),
+      NodeId.fromString(nodeID),
+      Id.fromHex(testSubnetId),
+      Input.fromNative([0]),
+    );
+
+    expectTxs(unsignedTx.getTx(), expectedTx);
+  });
+
+  it('newAddPermissionlessValidatorTx - primary network', () => {
+    const utxoInputAmt = AvaxToNAvax(2);
+
+    const unsignedTx = newAddPermissionlessValidatorTx(
+      testContext,
+      [getValidUtxo(new BigIntPr(utxoInputAmt))],
+      fromAddressBytes,
+      nodeID,
+      PrimaryNetworkID.toString(),
+      0n, // startTime
+      120n, //end time
+      1800000n, // weight
+      [], // rewards owners
+      [], // delegatorRewardsOwner
+      1,
+      {},
+      1,
+      0n,
+      blsPublicKeyBytes(),
+      blsSignatureBytes(),
+    );
+
+    const expectedTx = new AddPermissionlessValidatorTx(
+      AvaxBaseTx.fromNative(
+        testContext.networkID,
+        testContext.pBlockchainID,
+        [
+          getTransferableOutForTest(
+            utxoInputAmt - 1800000n - testContext.addPrimaryNetworkValidatorFee,
+          ),
+        ],
+        [getTransferableInputForTest(utxoInputAmt)],
+        new Uint8Array(),
+      ),
+      SubnetValidator.fromNative(
+        NodeId.fromString(nodeID).toString(),
+        0n,
+        120n,
+        1800000n,
+        PrimaryNetworkID,
+      ),
+      new Signer(proofOfPossession()),
+      [getTransferableOutForTest(1800000n)], //stake
+      OutputOwners.fromNative([], 0n, 1),
+      OutputOwners.fromNative([], 0n, 1),
+      new Int(1),
+    );
+
+    expectTxs(unsignedTx.getTx(), expectedTx);
+  });
+
+  it('newAddPermissionlessValidatorTx - subnet', () => {
+    const utxoInputAmt = AvaxToNAvax(2);
+
+    const unsignedTx = newAddPermissionlessValidatorTx(
+      testContext,
+      [getValidUtxo(new BigIntPr(utxoInputAmt))],
+      fromAddressBytes,
+      nodeID,
+      Id.fromHex(testSubnetId).toString(),
+      0n, // startTime
+      120n, //end time
+      1800000n, // weight
+      [], // rewards owners
+      [], // delegatorRewardsOwner
+      1,
+      {},
+      1,
+      0n,
+      blsPublicKeyBytes(),
+      blsSignatureBytes(),
+    );
+
+    const expectedTx = new AddPermissionlessValidatorTx(
+      AvaxBaseTx.fromNative(
+        testContext.networkID,
+        testContext.pBlockchainID,
+        [
+          getTransferableOutForTest(
+            utxoInputAmt - 1800000n - testContext.addSubnetValidatorFee,
+          ),
+        ],
+        [getTransferableInputForTest(utxoInputAmt)],
+        new Uint8Array(),
+      ),
+      SubnetValidator.fromNative(
+        NodeId.fromString(nodeID).toString(),
+        0n,
+        120n,
+        1800000n,
+        Id.fromHex(testSubnetId),
+      ),
+      new Signer(proofOfPossession()),
+      [getTransferableOutForTest(1800000n)], //stake
+      OutputOwners.fromNative([], 0n, 1),
+      OutputOwners.fromNative([], 0n, 1),
+      new Int(1),
+    );
+
+    expectTxs(unsignedTx.getTx(), expectedTx);
+  });
+
+  it('newAddPermissionlessValidatorTx - subnet with non avax staking token', () => {
+    const utxoInputAmt = AvaxToNAvax(2);
+    const stakingAssetId = Id.fromHex('0102');
+    const stakeAmount = 1_000_000n;
+
+    const unsignedTx = newAddPermissionlessValidatorTx(
+      testContext,
+      [
+        getValidUtxo(new BigIntPr(utxoInputAmt)),
+        getValidUtxo(new BigIntPr(2n * stakeAmount), stakingAssetId),
+      ],
+      fromAddressBytes,
+      nodeID,
+      Id.fromHex(testSubnetId).toString(),
+      0n, // startTime
+      120n, //end time
+      stakeAmount, // weight
+      [], // rewards owners
+      [], // delegatorRewardsOwner
+      1,
+      {},
+      1,
+      0n,
+      blsPublicKeyBytes(),
+      blsSignatureBytes(),
+      stakingAssetId.toString(),
+    );
+
+    const baseOuts = (unsignedTx.getTx() as AddPermissionlessValidatorTx).baseTx
+      .outputs;
+    const stakeUtxos = (unsignedTx.getTx() as AddPermissionlessValidatorTx)
+      .stake;
+    expect(stakeUtxos.length).toEqual(1);
+    // Expect correct stake out
+    expect(stakeUtxos[0].assetId.toString()).toEqual(stakingAssetId.toString());
+    expect(stakeUtxos[0].amount()).toEqual(stakeAmount);
+    // Expect correct change utxos
+    expect(baseOuts.length).toEqual(2);
+    // Stake token change
+    expect(baseOuts[0].assetId.toString()).toEqual(stakingAssetId.toString());
+    expect(baseOuts[0].amount()).toEqual(stakeAmount);
+    // AVAX Change
+    expect(baseOuts[1].assetId.toString()).toEqual(testContext.avaxAssetID);
+    expect(baseOuts[1].amount().toString()).toEqual(
+      (utxoInputAmt - testContext.addSubnetValidatorFee).toString(),
+    );
+  });
+
+  it('newAddPermissionlessDelegatorTx - primary network', () => {
+    const utxoInputAmt = AvaxToNAvax(2);
+
+    const unsignedTx = newAddPermissionlessDelegatorTx(
+      testContext,
+      [getValidUtxo(new BigIntPr(utxoInputAmt))],
+      fromAddressBytes,
+      nodeID,
+      PrimaryNetworkID.toString(),
+      0n, // startTime
+      120n, //end time
+      1800000n, // weight
+      [], // rewards owners
+      {},
+      1,
+      0n,
+    );
+
+    const expectedTx = new AddPermissionlessDelegatorTx(
+      AvaxBaseTx.fromNative(
+        testContext.networkID,
+        testContext.pBlockchainID,
+        [
+          getTransferableOutForTest(
+            utxoInputAmt - 1800000n - testContext.addPrimaryNetworkDelegatorFee,
+          ),
+        ],
+        [getTransferableInputForTest(utxoInputAmt)],
+        new Uint8Array(),
+      ),
+      SubnetValidator.fromNative(
+        NodeId.fromString(nodeID).toString(),
+        0n,
+        120n,
+        1800000n,
+        PrimaryNetworkID,
+      ),
+      [getTransferableOutForTest(1800000n)], //stake
+      OutputOwners.fromNative([], 0n, 1),
+    );
+
+    expectTxs(unsignedTx.getTx(), expectedTx);
+  });
+
+  it('newAddPermissionlessDelegatorTx - subnet', () => {
+    const utxoInputAmt = AvaxToNAvax(2);
+
+    const unsignedTx = newAddPermissionlessDelegatorTx(
+      testContext,
+      [getValidUtxo(new BigIntPr(utxoInputAmt))],
+      fromAddressBytes,
+      nodeID,
+      Id.fromHex(testSubnetId).toString(),
+      0n, // startTime
+      120n, //end time
+      1800000n, // weight
+      [], // rewards owners
+      {},
+      1,
+      0n,
+    );
+
+    const expectedTx = new AddPermissionlessDelegatorTx(
+      AvaxBaseTx.fromNative(
+        testContext.networkID,
+        testContext.pBlockchainID,
+        [
+          getTransferableOutForTest(
+            utxoInputAmt - 1800000n - testContext.addSubnetDelegatorFee,
+          ),
+        ],
+        [getTransferableInputForTest(utxoInputAmt)],
+        new Uint8Array(),
+      ),
+      SubnetValidator.fromNative(
+        NodeId.fromString(nodeID).toString(),
+        0n,
+        120n,
+        1800000n,
+        Id.fromHex(testSubnetId),
+      ),
+      [getTransferableOutForTest(1800000n)], //stake
+      OutputOwners.fromNative([], 0n, 1),
+    );
+
+    expectTxs(unsignedTx.getTx(), expectedTx);
+  });
+
+  it('newAddPermissionlessDelegatorTx - subnet with non avax staking token', () => {
+    const utxoInputAmt = AvaxToNAvax(2);
+    const stakingAssetId = Id.fromHex('0102');
+    const stakeAmount = 1_000_000n;
+
+    const unsignedTx = newAddPermissionlessDelegatorTx(
+      testContext,
+      [
+        getValidUtxo(new BigIntPr(utxoInputAmt)),
+        getValidUtxo(new BigIntPr(2n * stakeAmount), stakingAssetId),
+      ],
+      fromAddressBytes,
+      nodeID,
+      Id.fromHex(testSubnetId).toString(),
+      0n, // startTime
+      120n, //end time
+      stakeAmount, // weight
+      [], // rewards owners
+      {},
+      1,
+      0n,
+      stakingAssetId.toString(),
+    );
+
+    const baseOuts = (unsignedTx.getTx() as AddPermissionlessDelegatorTx).baseTx
+      .outputs;
+    const stakeUtxos = (unsignedTx.getTx() as AddPermissionlessDelegatorTx)
+      .stake;
+
+    expect(stakeUtxos.length).toEqual(1);
+    // Expect correct stake out
+    expect(stakeUtxos[0].assetId.toString()).toEqual(stakingAssetId.toString());
+    expect(stakeUtxos[0].amount()).toEqual(stakeAmount);
+    // Expect correct change utxos
+    expect(baseOuts.length).toEqual(2);
+    // Stake token change
+    expect(baseOuts[0].assetId.toString()).toEqual(stakingAssetId.toString());
+    expect(baseOuts[0].amount()).toEqual(stakeAmount);
+    // AVAX Change
+    expect(baseOuts[1].assetId.toString()).toEqual(testContext.avaxAssetID);
+    expect(baseOuts[1].amount().toString()).toEqual(
+      (utxoInputAmt - testContext.addSubnetDelegatorFee).toString(),
+    );
+  });
+
+  it('newTransferSubnetOwnershipTx', () => {
+    const utxoInputAmt = BigInt(2 * 1e9);
+    const subnetAuth = [0, 1];
+    const unsignedTx = newTransferSubnetOwnershipTx(
+      testContext,
+      [getValidUtxo(new BigIntPr(utxoInputAmt))],
+      fromAddressBytes,
+      Id.fromHex(testSubnetId).toString(),
+      subnetAuth,
+      [toAddress],
+    );
+
+    const expectedTx = new TransferSubnetOwnershipTx(
+      AvaxBaseTx.fromNative(
+        testContext.networkID,
+        testContext.pBlockchainID,
+        [getTransferableOutForTest(utxoInputAmt - testContext.baseTxFee)],
+        [getTransferableInputForTest(utxoInputAmt)],
+        new Uint8Array(),
+      ),
+      Id.fromHex(testSubnetId),
+      Input.fromNative(subnetAuth),
+      getRewardsOwners(),
+    );
+
+    expectTxs(unsignedTx.getTx(), expectedTx);
+  });
+
+  it('newTransformSubnetTx', () => {
+    const utxoInputAmt = BigInt(2 * 1e12);
+    const stakingAssetId = Id.fromHex('0102');
+    const subnetAuth = [0, 1];
+
+    const unsignedTx = newTransformSubnetTx(
+      testContext,
+      [getValidUtxo(new BigIntPr(utxoInputAmt))],
+      fromAddressBytes,
+      Id.fromHex(testSubnetId).toString(),
+      stakingAssetId.toString(),
+      1n,
+      2n,
+      3n,
+      4n,
+      5n,
+      6n,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      subnetAuth,
+    );
+
+    const expectedTx = new TransformSubnetTx(
+      AvaxBaseTx.fromNative(
+        testContext.networkID,
+        testContext.pBlockchainID,
+        [
+          getTransferableOutForTest(
+            utxoInputAmt - testContext.transformSubnetTxFee,
+          ),
+        ],
+        [getTransferableInputForTest(utxoInputAmt)],
+        new Uint8Array(),
+      ),
+      Id.fromHex(testSubnetId),
+      stakingAssetId,
+      new BigIntPr(1n),
+      new BigIntPr(2n),
+      new BigIntPr(3n),
+      new BigIntPr(4n),
+      new BigIntPr(5n),
+      new BigIntPr(6n),
+      new Int(1),
+      new Int(2),
+      new Int(3),
+      new Int(4),
+      new Byte(hexToBuffer('0x5')),
+      new Int(6),
+      Input.fromNative(subnetAuth),
+    );
+
+    expectTxs(unsignedTx.getTx(), expectedTx);
+  });
+});