@bitgo-forks/avalanchejs 4.1.0-alpha.1

package/src/serializable/pvm/subnetValidator.ts

@@ -0,0 +1,44 @@
+import type { Codec } from '../codec/codec';
+import { serializable } from '../common/types';
+import { Id } from '../fxs/common';
+import { pack, unpack } from '../../utils/struct';
+import { Validator } from './validator';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see
+ */
+@serializable()
+export class SubnetValidator {
+  _type = TypeSymbols.SubnetValidator;
+
+  constructor(
+    public readonly validator: Validator,
+    public readonly subnetId: Id,
+  ) {}
+
+  static fromNative(
+    nodeId: string,
+    startTime: bigint,
+    endTime: bigint,
+    weight: bigint,
+    subnetId: Id,
+  ) {
+    return new SubnetValidator(
+      Validator.fromNative(nodeId, startTime, endTime, weight),
+      subnetId,
+    );
+  }
+
+  static fromBytes(
+    bytes: Uint8Array,
+    codec: Codec,
+  ): [SubnetValidator, Uint8Array] {
+    const [validator, subnetId, rest] = unpack(bytes, [Validator, Id], codec);
+    return [new SubnetValidator(validator, subnetId), rest];
+  }
+
+  toBytes(codec: Codec) {
+    return pack([this.validator, this.subnetId], codec);
+  }
+}

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

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

package/src/serializable/pvm/transferSubnetOwnershipTx.ts

@@ -0,0 +1,59 @@
+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 { TypeSymbols } from '../constants';
+import { Id } from '../fxs/common';
+import { concatBytes } from '../../utils/buffer';
+import { AbstractSubnetTx } from './abstractSubnetTx';
+import type { OutputOwners } from '../../serializable/fxs/secp256k1';
+
+/**
+ * @see https://github.com/avalanche-foundation/ACPs/blob/main/ACPs/31-enable-subnet-ownership-transfer.md
+ * TODO: add doc reference after D-upgrade
+ */
+@serializable()
+export class TransferSubnetOwnershipTx extends AbstractSubnetTx {
+  _type = TypeSymbols.TransferSubnetOwnershipTx;
+
+  constructor(
+    public readonly baseTx: BaseTx,
+    public readonly subnetID: Id,
+    public readonly subnetAuth: Serializable, // current owner indices
+    public readonly subnetOwners: Serializable, // new owners
+  ) {
+    super();
+  }
+
+  getSubnetID() {
+    return this.subnetID;
+  }
+
+  getSubnetOwners() {
+    return this.subnetOwners as OutputOwners;
+  }
+
+  static fromBytes(
+    bytes: Uint8Array,
+    codec: Codec,
+  ): [TransferSubnetOwnershipTx, Uint8Array] {
+    const [baseTx, subnetID, subnetAuth, subnetOwners, rest] = unpack(
+      bytes,
+      [BaseTx, Id, Codec, Codec],
+      codec,
+    );
+    return [
+      new TransferSubnetOwnershipTx(baseTx, subnetID, subnetAuth, subnetOwners),
+      rest,
+    ];
+  }
+
+  toBytes(codec: Codec) {
+    return concatBytes(
+      pack([this.baseTx, this.subnetID], codec),
+      codec.PackPrefix(this.subnetAuth),
+      codec.PackPrefix(this.subnetOwners),
+    );
+  }
+}

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

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

package/src/serializable/pvm/transformSubnetTx.ts

@@ -0,0 +1,138 @@
+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 { Int } from '../primitives';
+import { Byte } from '../primitives';
+import { BigIntPr } from '../primitives';
+import { TypeSymbols } from '../constants';
+import { Id } from '../fxs/common';
+import { AbstractSubnetTx } from './abstractSubnetTx';
+
+/**
+ * @see https://docs.avax.network/reference/avalanchego/p-chain/txn-format#unsigned-transform-subnet-tx
+ */
+@serializable()
+export class TransformSubnetTx extends AbstractSubnetTx {
+  _type = TypeSymbols.TransformSubnetTx;
+
+  constructor(
+    public readonly baseTx: BaseTx,
+    public readonly subnetID: Id,
+    public readonly assetId: Id,
+    public readonly initialSupply: BigIntPr,
+    public readonly maximumSupply: BigIntPr,
+    public readonly minConsumptionRate: BigIntPr,
+    public readonly maxConsumptionRate: BigIntPr,
+    public readonly minValidatorStake: BigIntPr,
+    public readonly maxValidatorStake: BigIntPr,
+    public readonly minStakeDuration: Int,
+    public readonly maxStakeDuration: Int,
+    public readonly minDelegationFee: Int,
+    public readonly minDelegatorStake: Int,
+    public readonly maxValidatorWeightFactor: Byte,
+    public readonly uptimeRequirement: Int,
+    public readonly subnetAuth: Serializable,
+  ) {
+    super();
+  }
+
+  getSubnetID() {
+    return this.subnetID;
+  }
+
+  static fromBytes(
+    bytes: Uint8Array,
+    codec: Codec,
+  ): [TransformSubnetTx, Uint8Array] {
+    const [
+      baseTx,
+      subnetID,
+      assetId,
+      initialSupply,
+      maximumSupply,
+      minConsumptionRate,
+      maxConsumptionRate,
+      minValidatorStake,
+      maxValidatorStake,
+      minStakeDuration,
+      maxStakeDuration,
+      minDelegationFee,
+      minDelegatorStake,
+      maxValidatorWeightFactor,
+      uptimeRequirement,
+      subnetAuth,
+      rest,
+    ] = unpack(
+      bytes,
+      [
+        BaseTx,
+        Id,
+        Id,
+        BigIntPr,
+        BigIntPr,
+        BigIntPr,
+        BigIntPr,
+        BigIntPr,
+        BigIntPr,
+        Int,
+        Int,
+        Int,
+        Int,
+        Byte,
+        Int,
+        Codec,
+      ],
+      codec,
+    );
+    return [
+      new TransformSubnetTx(
+        baseTx,
+        subnetID,
+        assetId,
+        initialSupply,
+        maximumSupply,
+        minConsumptionRate,
+        maxConsumptionRate,
+        minValidatorStake,
+        maxValidatorStake,
+        minStakeDuration,
+        maxStakeDuration,
+        minDelegationFee,
+        minDelegatorStake,
+        maxValidatorWeightFactor,
+        uptimeRequirement,
+        subnetAuth,
+      ),
+      rest,
+    ];
+  }
+
+  toBytes(codec: Codec) {
+    return concatBytes(
+      pack(
+        [
+          this.baseTx,
+          this.subnetID,
+          this.assetId,
+          this.initialSupply,
+          this.maximumSupply,
+          this.minConsumptionRate,
+          this.maxConsumptionRate,
+          this.minValidatorStake,
+          this.maxValidatorStake,
+          this.minStakeDuration,
+          this.maxStakeDuration,
+          this.minDelegationFee,
+          this.minDelegatorStake,
+          this.maxValidatorWeightFactor,
+          this.uptimeRequirement,
+        ],
+        codec,
+      ),
+      codec.PackPrefix(this.subnetAuth),
+    );
+  }
+}

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

@@ -0,0 +1,53 @@
+import { TypeSymbols } from '../constants';
+import { onlyChecksOneGuard } from '../../fixtures/utils/typeguards';
+import {
+  isImportTx,
+  isExportTx,
+  isAddSubnetValidatorTx,
+  isAddPermissionlessValidatorTx,
+  isAddValidatorTx,
+  isAddDelegatorTx,
+  isAddPermissionlessDelegatorTx,
+  isCreateSubnetTx,
+  isCreateChainTx,
+  isAdvanceTimeTx,
+  isEmptySigner,
+  isSigner,
+  isRewardValidatorTx,
+  isRemoveSubnetValidatorTx,
+  isPvmBaseTx,
+  isTransferSubnetOwnershipTx,
+  isTransformSubnetTx,
+} from './typeGuards';
+
+const cases: [any, TypeSymbols][] = [
+  [isPvmBaseTx, TypeSymbols.PvmBaseTx],
+  [isImportTx, TypeSymbols.PvmImportTx],
+  [isExportTx, TypeSymbols.PvmExportTx],
+  [isAddSubnetValidatorTx, TypeSymbols.AddSubnetValidatorTx],
+  [isAddPermissionlessValidatorTx, TypeSymbols.AddPermissionlessValidatorTx],
+  [isAddValidatorTx, TypeSymbols.AddValidatorTx],
+  [isAddDelegatorTx, TypeSymbols.AddDelegatorTx],
+  [isAddPermissionlessDelegatorTx, TypeSymbols.AddPermissionlessDelegatorTx],
+  [isCreateSubnetTx, TypeSymbols.CreateSubnetTx],
+  [isRemoveSubnetValidatorTx, TypeSymbols.RemoveSubnetValidatorTx],
+  [isCreateChainTx, TypeSymbols.CreateChainTx],
+  [isAdvanceTimeTx, TypeSymbols.AdvanceTimeTx],
+  [isEmptySigner, TypeSymbols.SignerEmpty],
+  [isSigner, TypeSymbols.Signer],
+  [isRewardValidatorTx, TypeSymbols.RewardValidatorTx],
+  [isTransferSubnetOwnershipTx, TypeSymbols.TransferSubnetOwnershipTx],
+  [isTransformSubnetTx, TypeSymbols.TransformSubnetTx],
+];
+
+const guards = cases.map((caseItem) => caseItem[0]);
+
+describe('pvm/typeGuards', function () {
+  test.each(cases)('%p to pass', (guard, type) => {
+    const object = {
+      _type: type,
+    };
+    expect(guard(object)).toBe(true);
+    expect(onlyChecksOneGuard(object, guards)).toBe(true);
+  });
+});

package/src/serializable/pvm/typeGuards.ts

@@ -0,0 +1,98 @@
+import type { Transaction } from '../../vms/common/transaction';
+import type { BaseTx } from './baseTx';
+import type { ImportTx } from './importTx';
+import type { ExportTx } from './exportTx';
+import type { AddValidatorTx } from './addValidatorTx';
+import type { AddDelegatorTx } from './addDelegatorTx';
+import type { AddSubnetValidatorTx } from './addSubnetValidatorTx';
+import type { CreateChainTx } from './createChainTx';
+import type { CreateSubnetTx } from './createSubnetTx';
+import type { RemoveSubnetValidatorTx } from './removeSubnetValidatorTx';
+import type { AddPermissionlessDelegatorTx } from './addPermissionlessDelegatorTx';
+import type { AddPermissionlessValidatorTx } from './addPermissionlessValidatorTx';
+import type { AdvanceTimeTx } from './advanceTimeTx';
+import type { RewardValidatorTx } from './rewardValidatorTx';
+import type { Signer, SignerEmpty } from './signer';
+import type { TransferSubnetOwnershipTx } from './transferSubnetOwnershipTx';
+import { TypeSymbols } from '../constants';
+import type { TransformSubnetTx } from './transformSubnetTx';
+
+export function isPvmBaseTx(tx: Transaction): tx is BaseTx {
+  return tx._type === TypeSymbols.PvmBaseTx;
+}
+
+export function isAddDelegatorTx(tx: Transaction): tx is AddDelegatorTx {
+  return tx._type === TypeSymbols.AddDelegatorTx;
+}
+
+export function isAddPermissionlessDelegatorTx(
+  tx: Transaction,
+): tx is AddPermissionlessDelegatorTx {
+  return tx._type === TypeSymbols.AddPermissionlessDelegatorTx;
+}
+
+export function isAddPermissionlessValidatorTx(
+  tx: Transaction,
+): tx is AddPermissionlessValidatorTx {
+  return tx._type === TypeSymbols.AddPermissionlessValidatorTx;
+}
+
+export function isAddSubnetValidatorTx(
+  tx: Transaction,
+): tx is AddSubnetValidatorTx {
+  return tx._type === TypeSymbols.AddSubnetValidatorTx;
+}
+
+export function isAddValidatorTx(tx: Transaction): tx is AddValidatorTx {
+  return tx._type === TypeSymbols.AddValidatorTx;
+}
+
+export function isAdvanceTimeTx(tx: Transaction): tx is AdvanceTimeTx {
+  return tx._type === TypeSymbols.AdvanceTimeTx;
+}
+
+export function isCreateChainTx(tx: Transaction): tx is CreateChainTx {
+  return tx._type === TypeSymbols.CreateChainTx;
+}
+
+export function isCreateSubnetTx(tx: Transaction): tx is CreateSubnetTx {
+  return tx._type === TypeSymbols.CreateSubnetTx;
+}
+
+export function isRemoveSubnetValidatorTx(
+  tx: Transaction,
+): tx is RemoveSubnetValidatorTx {
+  return tx._type === TypeSymbols.RemoveSubnetValidatorTx;
+}
+
+export function isTransferSubnetOwnershipTx(
+  tx: Transaction,
+): tx is TransferSubnetOwnershipTx {
+  return tx._type === TypeSymbols.TransferSubnetOwnershipTx;
+}
+
+export function isTransformSubnetTx(tx: Transaction): tx is TransformSubnetTx {
+  return tx._type === TypeSymbols.TransformSubnetTx;
+}
+
+export function isExportTx(tx: Transaction): tx is ExportTx {
+  return tx._type === TypeSymbols.PvmExportTx;
+}
+
+export function isImportTx(tx: Transaction): tx is ImportTx {
+  return tx._type === TypeSymbols.PvmImportTx;
+}
+
+export function isRewardValidatorTx(tx: Transaction): tx is RewardValidatorTx {
+  return tx._type === TypeSymbols.RewardValidatorTx;
+}
+
+export function isEmptySigner(
+  signer: Signer | SignerEmpty,
+): signer is SignerEmpty {
+  return signer._type === TypeSymbols.SignerEmpty;
+}
+
+export function isSigner(signer: Signer | SignerEmpty): signer is Signer {
+  return signer._type === TypeSymbols.Signer;
+}

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

@@ -0,0 +1,5 @@
+import { validator, validatorBytes } from '../../fixtures/pvm';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { Validator } from './validator';
+
+testSerialization('Validator', Validator, validator, validatorBytes);

package/src/serializable/pvm/validator.ts

@@ -0,0 +1,52 @@
+import { pack, unpack } from '../../utils/struct';
+import type { Codec } from '../codec/codec';
+import { serializable } from '../common/types';
+import { NodeId } from '../fxs/common/nodeId';
+import { BigIntPr } from '../primitives';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see https://docs.avax.network/specs/platform-transaction-serialization#unsigned-add-validator-tx
+ */
+@serializable()
+export class Validator {
+  _type = TypeSymbols.Validator;
+
+  constructor(
+    public readonly nodeId: NodeId,
+    public readonly startTime: BigIntPr,
+    public readonly endTime: BigIntPr,
+    public readonly weight: BigIntPr,
+  ) {}
+
+  static fromNative(
+    nodeId: string,
+    startTime: bigint,
+    endTime: bigint,
+    weight: bigint,
+  ) {
+    return new Validator(
+      NodeId.fromString(nodeId),
+      new BigIntPr(startTime),
+      new BigIntPr(endTime),
+      new BigIntPr(weight),
+    );
+  }
+
+  static fromBytes(bytes: Uint8Array, codec: Codec): [Validator, Uint8Array] {
+    const [nodeId, startTime, endTime, weight, rest] = unpack(
+      bytes,
+      [NodeId, BigIntPr, BigIntPr, BigIntPr],
+      codec,
+    );
+
+    return [new Validator(nodeId, startTime, endTime, weight), rest];
+  }
+
+  toBytes(codec: Codec) {
+    return pack(
+      [this.nodeId, this.startTime, this.endTime, this.weight],
+      codec,
+    );
+  }
+}

package/src/signer/addTxSignatures.spec.ts

@@ -0,0 +1,91 @@
+import { jest } from '@jest/globals';
+
+import { UnsignedTx } from '../vms';
+import { BaseTx as AvaxBaseTx, TransferableInput } from '../serializable/avax';
+import { bigIntPr, bytes, int } from '../fixtures/primitives';
+import { id } from '../fixtures/common';
+import { BaseTx } from '../serializable/avm';
+import { transferableOutput, utxoId } from '../fixtures/avax';
+import { Input, TransferInput } from '../serializable/fxs/secp256k1';
+import { AddressMaps, AddressMap, hexToBuffer } from '../utils';
+import { Address } from '../serializable/fxs/common';
+import {
+  testAddress1,
+  testAddress2,
+  testPrivateKey1,
+  testPrivateKey2,
+  testPublicKey1,
+  testPublicKey2,
+} from '../fixtures/vms';
+import { addTxSignatures } from './addTxSignatures';
+import { secp256k1 } from '../crypto';
+
+describe('addTxSignatures', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('adds the signatures correctly', async () => {
+    const hasPubkeySpy = jest.spyOn(UnsignedTx.prototype, 'hasPubkey');
+    const addSignatureSpy = jest.spyOn(UnsignedTx.prototype, 'addSignature');
+    const unknownPrivateKey = hexToBuffer(
+      '1d4ff8f6582d995354f5c03a28a043d22aa1bb6aa15879a632134aaf1f225cf4',
+    );
+    const unknownPublicKey = secp256k1.getPublicKey(unknownPrivateKey);
+
+    const unsignedTx = new UnsignedTx(
+      new BaseTx(
+        new AvaxBaseTx(
+          int(),
+          id(),
+          [transferableOutput()],
+          [
+            new TransferableInput(
+              utxoId(),
+              id(),
+              new TransferInput(bigIntPr(), Input.fromNative([0])),
+            ),
+            new TransferableInput(
+              utxoId(),
+              id(),
+              new TransferInput(bigIntPr(), Input.fromNative([0, 1])),
+            ),
+          ],
+          bytes(),
+        ),
+      ),
+      [],
+      new AddressMaps([
+        new AddressMap([[new Address(testAddress1), 0]]),
+        new AddressMap([
+          [new Address(testAddress2), 0],
+          [new Address(testAddress1), 1],
+        ]),
+      ]),
+    );
+
+    await addTxSignatures({
+      unsignedTx,
+      privateKeys: [testPrivateKey1, testPrivateKey2, unknownPrivateKey],
+    });
+
+    expect(hasPubkeySpy).toHaveBeenCalledTimes(3);
+    expect(hasPubkeySpy).toHaveBeenNthCalledWith(1, testPublicKey1);
+    expect(hasPubkeySpy).toHaveBeenNthCalledWith(2, testPublicKey2);
+    expect(hasPubkeySpy).toHaveBeenNthCalledWith(3, unknownPublicKey);
+
+    expect(addSignatureSpy).toHaveBeenCalledTimes(2);
+    expect(addSignatureSpy).toHaveBeenCalledWith(
+      hexToBuffer(
+        '0x7b3da43d8e4103d1078061872075cbcbb5de0108f3d897752c894757cf0e9c4113949ca2a5568483763e1fa0e74b4f4dd9b2a6e40909d0729f87c7dddfc1e70601',
+      ),
+    );
+    expect(addSignatureSpy).toHaveBeenCalledWith(
+      hexToBuffer(
+        '0x04e2072e34fd5d7cc729afb8bfe7c5865754c3c448b9b3247b16cabbf06378393edf405274048bef74c02862ae032c0b86dda7c28bebf63f4d1de4f517bd710500',
+      ),
+    );
+
+    expect(unsignedTx.hasAllSignatures()).toBe(true);
+  });
+});

package/src/signer/addTxSignatures.ts

@@ -0,0 +1,23 @@
+import type { UnsignedTx } from '../vms/common/unsignedTx';
+import { secp256k1 } from '../crypto';
+
+export const addTxSignatures = async ({
+  unsignedTx,
+  privateKeys,
+}: {
+  unsignedTx: UnsignedTx;
+  privateKeys: Uint8Array[];
+}) => {
+  const unsignedBytes = unsignedTx.toBytes();
+
+  await Promise.all(
+    privateKeys.map(async (privateKey) => {
+      const publicKey = secp256k1.getPublicKey(privateKey);
+
+      if (unsignedTx.hasPubkey(publicKey)) {
+        const signature = await secp256k1.sign(unsignedBytes, privateKey);
+        unsignedTx.addSignature(signature);
+      }
+    }),
+  );
+};

package/src/signer/index.ts

@@ -0,0 +1 @@
+export * from './addTxSignatures';

package/src/utils/UTXOSet/UTXOSet.ts

@@ -0,0 +1,75 @@
+import type { AssetDict } from './models';
+import type { Utxo } from '../../serializable/avax/utxo';
+import { isTransferOut } from '../typeGuards';
+import { filterDuplicateUTXOs } from '../removeDuplicateUTXOs';
+
+export class UtxoSet {
+  constructor(private utxos: Utxo[]) {
+    this.utxos = filterDuplicateUTXOs(utxos);
+  }
+
+  getUTXOs() {
+    return [...this.utxos];
+  }
+
+  /**
+   * Organize the UTXOs as a dictionary with assetID as the key.
+   */
+  getAssetDict() {
+    const dict = {};
+    this.utxos.forEach((utxo) => {
+      const assetId = utxo.assetId.toString();
+      const valNow = dict[assetId] || [];
+      dict[assetId] = [...valNow, utxo];
+    });
+
+    const finalDict: AssetDict = {};
+    for (const assetID in dict) {
+      finalDict[assetID] = new UtxoSet(dict[assetID]);
+    }
+    return finalDict;
+  }
+
+  /**
+   * Return asset IDs that exist in this set.
+   */
+  getAssetIDs() {
+    const ids = this.utxos.map((utxo) => utxo.assetId.toString());
+    // Filter duplicates
+    return ids.filter((id, index) => ids.indexOf(id) === index);
+  }
+
+  /**
+   * Add a UTXO to the set, and return a new set.
+   * @param utxo
+   */
+  push(utxo: Utxo) {
+    return new UtxoSet([...this.getUTXOs(), utxo]);
+  }
+
+  /**
+   * Return the UTXO ids in this set.
+   */
+  getUTXOIDs() {
+    return this.utxos.map((utxo) => utxo.ID());
+  }
+
+  /**
+   * Merge 2 UtxoSets and return a new set.
+   * @param set
+   */
+  merge(set: UtxoSet) {
+    const newUTXOs = [...this.getUTXOs(), ...set.getUTXOs()];
+    return new UtxoSet(newUTXOs);
+  }
+
+  /**
+   * Return UTXOs that have TransferOut outputs
+   */
+  getTransferOuts() {
+    const utxos = this.utxos.filter((utxo) => {
+      return isTransferOut(utxo.output);
+    });
+    return new UtxoSet(utxos);
+  }
+}

package/src/utils/UTXOSet/index.ts

@@ -0,0 +1,2 @@
+export * from './models';
+export * from './UTXOSet';

package/src/utils/UTXOSet/models.ts

@@ -0,0 +1,5 @@
+import type { UtxoSet } from './UTXOSet';
+
+export interface AssetDict {
+  [assetID: string]: UtxoSet;
+}

package/src/utils/addChecksum.ts

@@ -0,0 +1,6 @@
+import { sha256 } from '@noble/hashes/sha256';
+import { concatBytes } from './buffer';
+
+export function addChecksum(data: Uint8Array) {
+  return concatBytes(data, sha256(data).subarray(-4));
+}