@effectstream/utils 0.100.0

package/src/types/validators/cardano.ts

@@ -0,0 +1,139 @@
+import { crc32 } from "@foxglove/crc";
+import { CHECKSUM_ERROR_MSG, MALFORMED_ERROR_MSG } from "./utils.ts";
+import { MiniCborReader } from "./minicbor.ts";
+import bs58 from "bs58";
+import { bech32 } from "bech32";
+import { Buffer } from "node:buffer";
+
+const CHECKSUM_ADDRESS_ERROR_MSG = CHECKSUM_ERROR_MSG("address");
+
+export const InvalidArgumentError = Error;
+
+/**
+ * Example address:
+ * - (mainnet icarus) Ae2tdPwUPEZFRbyhz3cpfC2CumGzNkFBN2L42rcUc2yjQpEkxDbkPodpMAi
+ * - (testnet byron) 37btjrVyb4KDXBNC4haBVPCrro8AQPHwvCMp3RFhhSVWwfFmZ6wwzSK6JK1hY6wHNmtrpTf1kdbva8TCneM2YsiXT7mrzT21EacHnPpz5YyUdj64na
+ * - (mainnet byron) 82d818584283581caf335162c1ecb0a5b95342e3d1d0c9c38a246fa976b077e81dea9d9ba101581e581c2d574aa85a82a80fd6d1c51ea115c2b03b68166230a3c383c9f89ad5001ac3de014e
+ */
+export function verifyCardanoByronAddress(address: string): boolean {
+  return verifyCardanoByronAddressBytes(bs58.decode(address));
+}
+function verifyCardanoByronAddressBytes(data: Uint8Array): boolean {
+  const reader = new MiniCborReader(Buffer.from(data).toString("hex"));
+
+  reader.readStartArray();
+  reader.readTag();
+
+  const addressDataEncoded = reader.readByteString();
+
+  if (Number(reader.readInt()) !== crc32(addressDataEncoded)) {
+    throw new Error(CHECKSUM_ADDRESS_ERROR_MSG);
+  }
+
+  // skip the rest of the address verification and assume if the checksum matches the rest is okay
+
+  return true;
+}
+
+export enum AddressType {
+  BasePaymentKeyStakeKey = 0b0000,
+  BasePaymentScriptStakeKey = 0b0001,
+  BasePaymentKeyStakeScript = 0b0010,
+  BasePaymentScriptStakeScript = 0b0011,
+  PointerKey = 0b0100,
+  PointerScript = 0b0101,
+  EnterpriseKey = 0b0110,
+  EnterpriseScript = 0b0111,
+  // 0b1000 was chosen because all existing Byron addresses actually start with 0b1000,
+  // therefore we can re-use Byron addresses as-is
+  Byron = 0b1000,
+  RewardKey = 0b1110,
+  RewardScript = 0b1111,
+  // 1001-1101 are left for future formats
+}
+
+/**
+ * See: https://github.com/input-output-hk/cardano-js-sdk/blob/d1544fc9d1fb3997eb7c5b94a233789bb9e5cd9f/packages/core/src/Cardano/Address/Address.ts
+ */
+export function verifyCardanoShelleyAddress(address: string): boolean {
+  const bech32data = bech32.decode(address, Number.MAX_SAFE_INTEGER / 2);
+  const data = bech32.fromWords(bech32data.words);
+
+  // strictly speaking, you don't have to use these prefixes
+  // but it's a good sanity check
+  // see CIP5
+  if (
+    !["addr", "addr_test", "stake", "stake_test"].includes(bech32data.prefix)
+  ) {
+    return false;
+  }
+
+  const type = data[0] >> 4;
+
+  switch (type) {
+    case AddressType.BasePaymentKeyStakeKey:
+    case AddressType.BasePaymentScriptStakeKey:
+    case AddressType.BasePaymentKeyStakeScript:
+    case AddressType.BasePaymentScriptStakeScript: {
+      return data.length === 57;
+    }
+    case AddressType.PointerKey:
+    case AddressType.PointerScript: {
+      if (data.length <= 29) {
+        return false;
+      }
+      let index = 29;
+      const dataBuffer = Buffer.from(data);
+      const { bytesRead: slotBytes } = variableLengthDecode(
+        dataBuffer.subarray(index),
+      );
+
+      index += slotBytes;
+      const { bytesRead: txIndexBytes } = variableLengthDecode(
+        dataBuffer.subarray(index),
+      );
+
+      index += txIndexBytes;
+      variableLengthDecode(dataBuffer.subarray(index));
+      return true;
+    }
+    case AddressType.EnterpriseKey:
+    case AddressType.EnterpriseScript: {
+      return data.length === 47;
+    }
+    case AddressType.RewardKey:
+    case AddressType.RewardScript: {
+      return data.length === 47;
+    }
+    case AddressType.Byron: {
+      return verifyCardanoByronAddressBytes(new Uint8Array(data));
+    }
+    default:
+      throw new Error(MALFORMED_ERROR_MSG("address"));
+  }
+}
+
+/**
+ * Decodes a value previously encoded in a variable length array.
+ *
+ * @param array The encoded value.
+ * @returns the decoded value.
+ */
+const variableLengthDecode = (
+  array: Buffer,
+): { value: bigint; bytesRead: number } => {
+  let more = true;
+  let value = 0n;
+
+  let bytesRead = 0;
+  while (more && bytesRead < array.length) {
+    const b = array[bytesRead];
+    value <<= 7n;
+    value |= BigInt(b & 127);
+
+    more = (b & 128) !== 0;
+    ++bytesRead;
+  }
+
+  return { bytesRead, value };
+};

package/src/types/validators/mina.ts

@@ -0,0 +1,54 @@
+import bs58check from "bs58check";
+import { MALFORMED_ERROR_MSG } from "./utils.ts";
+
+const BLOCK_HASH_BYTE_LENGTH = 34;
+const TX_ID_BYTE_LENGTH = 34;
+const ADDRESS_BYTE_LENGTH = 36;
+
+const MALFORMED_BLOCK_HASH_ERROR_MSG = MALFORMED_ERROR_MSG("block hash");
+const MALFORMED_TX_ID_ERROR_MSG = MALFORMED_ERROR_MSG("tx id");
+const MALFORMED_ADDRESS_ERROR_MSG = MALFORMED_ERROR_MSG("address");
+
+/**
+ * Example address: B62qpLST3UC1rpVT6SHfB7wqW2iQgiopFAGfrcovPgLjgfpDUN2LLeg
+ */
+export function verifyMinaAddress(address: string): boolean {
+  const decoded = bs58check.decode(address);
+  // Sanity check
+  if (decoded.length !== ADDRESS_BYTE_LENGTH) {
+    throw new Error(
+      `${MALFORMED_ADDRESS_ERROR_MSG}: expected byte length ${ADDRESS_BYTE_LENGTH}, got ${decoded.length}`,
+    );
+  }
+  return true;
+}
+
+/**
+ * Example block hash: 3NK9ToRM1gnzyDbafWzdde7EYemjUN2cb5isjtchcCuupty2MgbC
+ */
+export function verifyMinaBlockHash(hash: string): boolean {
+  const decoded = bs58check.decode(hash);
+  // Sanity check
+  if (decoded.length !== TX_ID_BYTE_LENGTH) {
+    throw new Error(
+      `${MALFORMED_BLOCK_HASH_ERROR_MSG}: expected byte length ${BLOCK_HASH_BYTE_LENGTH}, got ${decoded.length}`,
+    );
+  }
+  return true;
+}
+
+/**
+ * See https://github.com/openmina/openmina/blob/26354df0b4165a82ba67fa9ab1f2301841f7b033/mina-p2p-messages/src/v2/hashing.rs#L89-L92
+ *
+ * Example tx hash: 5JuYVpv6njuwUjgf8WLfXhTEJGHck1pwJXt92Lpcskiwu8kBL632
+ */
+export function verifyMinaTransactionHash(hash: string): boolean {
+  const decoded = bs58check.decode(hash);
+  // Sanity check
+  if (decoded.length !== TX_ID_BYTE_LENGTH) {
+    throw new Error(
+      `${MALFORMED_TX_ID_ERROR_MSG}: expected byte length ${TX_ID_BYTE_LENGTH}, got ${decoded.length}`,
+    );
+  }
+  return true;
+}

package/src/types/validators/minicbor.ts

@@ -0,0 +1,468 @@
+/**
+ * We need CBOR to parse Cardano Byron addresses
+ *    but CBOR parsing libraries are massive
+ *    we want to avoid having to import megabytes JS code in the browser just for Cardano Byron address parsing
+ *
+ * As a middle ground, this file copies just the CBOR parsing code required for Byron checksum matching
+ * reference: https://github.com/input-output-hk/cardano-js-sdk/blob/d1544fc9d1fb3997eb7c5b94a233789bb9e5cd9f/packages/core/src/Serialization/CBOR/MiniCborReader.ts#L26
+ *
+ * This file is 3kb when compressing with gzip
+ */
+
+import { Buffer } from "node:buffer";
+
+type HexBlob = string;
+
+export const CborContentException = Error;
+export const CborInvalidOperationException = Error;
+
+export enum CborReaderState {
+  Undefined = 0,
+  UnsignedInteger,
+  NegativeInteger,
+  ByteString,
+  StartIndefiniteLengthByteString,
+  EndIndefiniteLengthByteString,
+  TextString,
+  StartIndefiniteLengthTextString,
+  EndIndefiniteLengthTextString,
+  StartArray,
+  EndArray,
+  StartMap,
+  EndMap,
+  Tag,
+  SimpleValue,
+  HalfPrecisionFloat,
+  SinglePrecisionFloat,
+  DoublePrecisionFloat,
+  Null,
+  Boolean,
+  Finished,
+}
+
+export enum CborMajorType {
+  UnsignedInteger = 0,
+  NegativeInteger = 1,
+  ByteString = 2,
+  Utf8String = 3,
+  Array = 4,
+  Map = 5,
+  Tag = 6,
+  Simple = 7,
+}
+
+type StackFrame = {
+  type: CborMajorType | null;
+  frameOffset: number;
+  definiteLength?: number;
+  itemsRead: number;
+  currentKeyOffset: number | null;
+};
+
+export enum CborTag {
+  DateTimeString = 0,
+  UnixTimeSeconds = 1,
+  UnsignedBigNum = 2,
+  NegativeBigNum = 3,
+  DecimalFraction = 4,
+  BigFloat = 5,
+  Base64UrlLaterEncoding = 21,
+  Base64StringLaterEncoding = 22,
+  Base16StringLaterEncoding = 23,
+  EncodedCborDataItem = 24,
+  RationalNumber = 30,
+  Uri = 32,
+  Base64Url = 33,
+  Base64 = 34,
+  Regex = 35,
+  MimeMessage = 36,
+  Set = 258,
+  SelfDescribeCbor = 55_799,
+}
+
+const UNEXPECTED_END_OF_BUFFER_MSG = "Unexpected end of buffer";
+
+export enum CborAdditionalInfo {
+  AdditionalFalse = 20,
+  AdditionalTrue = 21,
+  AdditionalNull = 22,
+  Additional8BitData = 24,
+  Additional16BitData = 25,
+  Additional32BitData = 26,
+  Additional64BitData = 27,
+  IndefiniteLength = 31,
+}
+
+export class CborInitialByte {
+  static readonly IndefiniteLengthBreakByte = 0xff;
+  static readonly AdditionalInformationMask = 0b0001_1111;
+
+  constructor(private initialByte: number) {}
+  CborInitialByte(
+    majorType: CborMajorType,
+    additionalInfo: CborAdditionalInfo,
+  ) {
+    this.initialByte = (majorType << 5) | additionalInfo;
+  }
+  static from(initialByte: number) {
+    const init = new CborInitialByte(initialByte);
+
+    return init;
+  }
+  getInitialByte(): number {
+    return this.initialByte;
+  }
+  getMajorType(): CborMajorType {
+    return this.initialByte >> 5;
+  }
+  getAdditionalInfo(): CborAdditionalInfo {
+    return this.initialByte & CborInitialByte.AdditionalInformationMask;
+  }
+}
+
+export class MiniCborReader {
+  readonly #data: Uint8Array;
+  #offset = 0;
+  #nestedItems: Array<StackFrame> = new Array<StackFrame>();
+  #isTagContext = false;
+  #currentFrame: StackFrame;
+  #cachedState = CborReaderState.Undefined;
+
+  constructor(data: HexBlob) {
+    this.#data = new Uint8Array(Buffer.from(data, "hex"));
+    this.#currentFrame = {
+      currentKeyOffset: null,
+      frameOffset: 0,
+      itemsRead: 0,
+      type: null,
+    };
+  }
+
+  readStartArray(): number | null {
+    const header: CborInitialByte = this.#peekInitialByte(CborMajorType.Array);
+
+    if (header.getAdditionalInfo() === CborAdditionalInfo.IndefiniteLength) {
+      this.#advanceBuffer(1);
+      this.#pushDataItem(CborMajorType.Array);
+      return null;
+    }
+
+    const buffer = this.#getRemainingBytes();
+    const { length, bytesRead } = MiniCborReader.#peekDefiniteLength(
+      header,
+      buffer,
+    );
+
+    this.#advanceBuffer(bytesRead);
+    this.#pushDataItem(CborMajorType.Array, length);
+    return length;
+  }
+
+  readTag(): CborTag {
+    const { tag, bytesRead } = this.#peekTagCore();
+
+    this.#advanceBuffer(bytesRead);
+    this.#isTagContext = true;
+    return tag;
+  }
+
+  readByteString(): Uint8Array {
+    const header = this.#peekInitialByte(CborMajorType.ByteString);
+
+    if (header.getAdditionalInfo() === CborAdditionalInfo.IndefiniteLength) {
+      const { val, encodingLength } = this
+        .#readIndefiniteLengthByteStringConcatenated(
+          CborMajorType.ByteString,
+        );
+
+      this.#advanceBuffer(encodingLength);
+      this.#advanceDataItemCounters();
+
+      return val;
+    }
+
+    const buffer = this.#getRemainingBytes();
+    const { length, bytesRead } = MiniCborReader.#peekDefiniteLength(
+      header,
+      buffer,
+    );
+
+    this.#ensureReadCapacity(bytesRead + length);
+    this.#advanceBuffer(bytesRead + length);
+    this.#advanceDataItemCounters();
+
+    return buffer.slice(bytesRead, bytesRead + length);
+  }
+
+  readInt(): bigint {
+    const value = this.#peekSignedInteger();
+    this.#advanceBuffer(value.bytesRead);
+    this.#advanceDataItemCounters();
+    return value.signedInt;
+  }
+
+  #peekSignedInteger(): { signedInt: bigint; bytesRead: number } {
+    const header: CborInitialByte = this.#peekInitialByte();
+
+    switch (header.getMajorType()) {
+      case CborMajorType.UnsignedInteger: {
+        const { unsignedInt: signedInt, bytesRead } = MiniCborReader
+          .#decodeUnsignedInteger(
+            header,
+            this.#getRemainingBytes(),
+          );
+
+        return { bytesRead, signedInt: BigInt(signedInt) };
+      }
+      case CborMajorType.NegativeInteger: {
+        const { unsignedInt, bytesRead } = MiniCborReader
+          .#decodeUnsignedInteger(
+            header,
+            this.#getRemainingBytes(),
+          );
+
+        return { bytesRead, signedInt: BigInt(-1) - unsignedInt };
+      }
+      default:
+        throw new CborInvalidOperationException(
+          `Reader type mismatch, expected ${CborMajorType.UnsignedInteger} or ${CborMajorType.NegativeInteger} but got ${header.getMajorType()}`,
+        );
+    }
+  }
+
+  #ensureReadCapacity(bytesToRead: number) {
+    if (this.#data.length - this.#offset < bytesToRead) {
+      throw new CborContentException(UNEXPECTED_END_OF_BUFFER_MSG);
+    }
+  }
+
+  #readIndefiniteLengthByteStringConcatenated(type: CborMajorType): {
+    val: Uint8Array;
+    encodingLength: number;
+  } {
+    const data = this.#getRemainingBytes();
+    let concat = Buffer.from([]);
+    let encodingLength = 0;
+
+    let i = 1; // skip the indefinite-length initial byte
+
+    let nextInitialByte = MiniCborReader.#peekNextInitialByte(
+      data.slice(i),
+      type,
+    );
+
+    while (
+      nextInitialByte.getInitialByte() !==
+        CborInitialByte.IndefiniteLengthBreakByte
+    ) {
+      const { length: chunkLength, bytesRead } = MiniCborReader
+        .#peekDefiniteLength(
+          nextInitialByte,
+          data.slice(i),
+        );
+      const payloadSize = bytesRead + Number(chunkLength);
+
+      concat = Buffer.concat([
+        concat as any, // TODO: remove `as any` once @types/node gets updated properly
+        data.slice(i + (payloadSize - chunkLength), i + payloadSize),
+      ]);
+
+      i += payloadSize;
+
+      nextInitialByte = MiniCborReader.#peekNextInitialByte(
+        data.slice(i),
+        type,
+      );
+    }
+
+    encodingLength = i + 1; // include the break byte
+
+    return { encodingLength, val: new Uint8Array(concat) };
+  }
+
+  #advanceDataItemCounters() {
+    ++this.#currentFrame.itemsRead;
+    this.#isTagContext = false;
+  }
+
+  static #peekNextInitialByte(
+    buffer: Uint8Array,
+    expectedType?: CborMajorType,
+  ): CborInitialByte {
+    MiniCborReader.ensureReadCapacityInArray(buffer, 1);
+    const header = CborInitialByte.from(buffer[0]);
+
+    if (
+      header.getInitialByte() !== CborInitialByte.IndefiniteLengthBreakByte &&
+      header.getMajorType() !== expectedType
+    ) {
+      throw new CborContentException(
+        "Indefinite length string contains invalid data item",
+      );
+    }
+
+    return header;
+  }
+
+  #peekTagCore(): { tag: CborTag; bytesRead: number } {
+    const header: CborInitialByte = this.#peekInitialByte(CborMajorType.Tag);
+    const { unsignedInt: result, bytesRead } = MiniCborReader
+      .#decodeUnsignedInteger(
+        header,
+        this.#getRemainingBytes(),
+      );
+
+    return { bytesRead, tag: Number(result) as CborTag };
+  }
+
+  static #peekDefiniteLength(
+    header: CborInitialByte,
+    data: Uint8Array,
+  ): { length: number; bytesRead: number } {
+    const { unsignedInt: length, bytesRead } = MiniCborReader
+      .#decodeUnsignedInteger(header, data);
+    return { bytesRead, length: Number(length) };
+  }
+
+  #peekInitialByte(expectedType?: CborMajorType): CborInitialByte {
+    if (
+      this.#currentFrame.definiteLength !== undefined &&
+      this.#currentFrame.definiteLength - this.#currentFrame.itemsRead === 0
+    ) {
+      throw new CborInvalidOperationException("No more data items to read");
+    }
+
+    if (this.#offset === this.#data.length) {
+      if (
+        this.#currentFrame.type === null &&
+        this.#currentFrame.definiteLength === undefined &&
+        this.#offset > 0
+      ) {
+        throw new CborInvalidOperationException(
+          "End of root-level. No more data items to read",
+        );
+      }
+
+      throw new CborContentException(UNEXPECTED_END_OF_BUFFER_MSG);
+    }
+
+    const nextByte = CborInitialByte.from(this.#data[this.#offset]);
+
+    switch (this.#currentFrame.type) {
+      case CborMajorType.ByteString:
+      case CborMajorType.Utf8String:
+        // Indefinite-length string contexts allow two possible data items:
+        // 1) Definite-length string chunks of the same major type OR
+        // 2) a break byte denoting the end of the indefinite-length string context.
+        if (
+          nextByte.getInitialByte() ===
+            CborInitialByte.IndefiniteLengthBreakByte ||
+          (nextByte.getMajorType() === this.#currentFrame.type &&
+            nextByte.getAdditionalInfo() !==
+              CborAdditionalInfo.IndefiniteLength)
+        ) {
+          break;
+        }
+
+        throw new CborContentException(
+          `Indefinite length string contains invalid data item, ${nextByte.getMajorType()}`,
+        );
+    }
+
+    if (expectedType && expectedType !== nextByte.getMajorType()) {
+      throw new CborInvalidOperationException(
+        `Major type mismatch, expected type ${expectedType} but got ${nextByte.getMajorType()}`,
+      );
+    }
+
+    return nextByte;
+  }
+
+  static #decodeUnsignedInteger(
+    header: CborInitialByte,
+    data: Uint8Array,
+  ): { unsignedInt: bigint; bytesRead: number } {
+    if (
+      (header.getInitialByte() & CborInitialByte.AdditionalInformationMask) <
+        CborAdditionalInfo.Additional8BitData
+    ) {
+      return { bytesRead: 1, unsignedInt: BigInt(header.getAdditionalInfo()) };
+    }
+
+    switch (header.getAdditionalInfo()) {
+      case CborAdditionalInfo.Additional8BitData: {
+        MiniCborReader.ensureReadCapacityInArray(data, 2);
+
+        return { bytesRead: 2, unsignedInt: BigInt(data[1]) };
+      }
+      case CborAdditionalInfo.Additional16BitData: {
+        MiniCborReader.ensureReadCapacityInArray(data, 3);
+
+        const buffer = Buffer.from(data.slice(1));
+        const val = buffer.readUInt16BE();
+
+        return { bytesRead: 3, unsignedInt: BigInt(val) };
+      }
+      case CborAdditionalInfo.Additional32BitData: {
+        MiniCborReader.ensureReadCapacityInArray(data, 5);
+
+        const buffer = Buffer.from(data.slice(1));
+        const val = buffer.readUInt32BE();
+
+        return { bytesRead: 5, unsignedInt: BigInt(val) };
+      }
+      case CborAdditionalInfo.Additional64BitData: {
+        MiniCborReader.ensureReadCapacityInArray(data, 9);
+
+        const buffer = Buffer.from(data.slice(1, 9));
+
+        let result = BigInt(0);
+
+        for (const element of buffer) {
+          result = (result << BigInt(8)) + BigInt(element);
+        }
+
+        return { bytesRead: 9, unsignedInt: result };
+      }
+      default:
+        throw new CborContentException("Invalid integer encoding");
+    }
+  }
+
+  static ensureReadCapacityInArray(data: Uint8Array, bytesToRead: number) {
+    if (data.length < bytesToRead) {
+      throw new CborContentException(UNEXPECTED_END_OF_BUFFER_MSG);
+    }
+  }
+
+  #advanceBuffer(length: number) {
+    if (this.#offset + length > this.#data.length) {
+      throw new CborContentException("Buffer offset out of bounds");
+    }
+    this.#offset += length;
+    this.#cachedState = CborReaderState.Undefined;
+  }
+
+  #pushDataItem(majorType: CborMajorType, definiteLength?: number): void {
+    const frame: StackFrame = {
+      currentKeyOffset: this.#currentFrame.currentKeyOffset,
+      definiteLength: this.#currentFrame.definiteLength,
+      frameOffset: this.#currentFrame.frameOffset,
+      itemsRead: this.#currentFrame.itemsRead,
+      type: this.#currentFrame.type,
+    };
+
+    this.#nestedItems.push(frame);
+
+    this.#currentFrame.type = majorType;
+    this.#currentFrame.definiteLength = definiteLength;
+    this.#currentFrame.itemsRead = 0;
+    this.#currentFrame.frameOffset = this.#offset;
+    this.#isTagContext = false;
+    this.#currentFrame.currentKeyOffset = null;
+  }
+
+  #getRemainingBytes(): Uint8Array {
+    return this.#data.slice(this.#offset);
+  }
+}

package/src/types/validators/mod.ts

@@ -0,0 +1,2 @@
+export * from "./algorand.ts";
+export * from "./utils.ts";

package/src/types/validators/utils.ts

@@ -0,0 +1,34 @@
+import type { HexStringNo0x, UnknownFormat } from "../nominal.ts";
+
+function hexStringToBytes(hexString: HexStringNo0x): number[] {
+  if (!/^[0-9a-fA-F]+$/.test(hexString)) {
+    throw new Error("Non-hex digits found in hex string");
+  }
+  const bytes: number[] = [];
+  if (hexString.length % 2 !== 0) {
+    hexString = "0" + hexString;
+  }
+  for (let c = 0; c < hexString.length; c += 2) {
+    const nextByte = hexString.slice(c, c + 2);
+    bytes.push(parseInt(nextByte, 16));
+  }
+  return bytes;
+}
+
+export function hexStringToUint8Array(hexString: UnknownFormat): Uint8Array {
+  return new Uint8Array(hexStringToBytes(hexString));
+}
+
+export function uint8ArrayToHexString(uint8Array: Uint8Array): HexStringNo0x {
+  // recall: slice(-2) takes two characters starting from the end of the string
+  //         so this works because we <16 numbers with '0'
+  return Array.prototype.map.call(
+    uint8Array,
+    (byte) => ("0" + byte.toString(16)).slice(-2),
+  ).join("");
+}
+
+export const MALFORMED_ERROR_MSG = (str: string): string =>
+  `${str} is malformed`;
+export const CHECKSUM_ERROR_MSG = (str: string): string =>
+  `${str} checksum is wrong`;