@effectstream/utils 0.100.0

package/src/types/typebox-helpers.ts

@@ -0,0 +1,446 @@
+import { FormatRegistry, type Kind, Type } from "@sinclair/typebox";
+import type {
+  NumberOptions,
+  RegExpOptions,
+  SchemaOptions,
+  Static,
+  StaticDecode,
+  TNull,
+  TObject,
+  TRegExp,
+  TSchema,
+  TString,
+  TTransform,
+  TUnion,
+  TUnsafe,
+} from "@sinclair/typebox";
+import { Value, ValueErrorType } from "@sinclair/typebox/value";
+import type { AbiEvent } from "abitype";
+import type { Mutable, Satisfies, TypeErrorMessage } from "./misc.ts";
+import type * as Nominal from "./nominal.ts";
+import * as ss58 from "@subsquid/ss58-codec";
+import bs58check from "bs58check";
+import { bech32 } from "bech32";
+import {
+  verifyAlgorandAddress,
+  verifyAlgorandBlockHash,
+  verifyAlgorandTransactionHash,
+} from "./validators/algorand.ts";
+import {
+  verifyMinaAddress,
+  verifyMinaBlockHash,
+  verifyMinaTransactionHash,
+} from "./validators/mina.ts";
+import {
+  verifyCardanoByronAddress,
+  verifyCardanoShelleyAddress,
+} from "./validators/cardano.ts";
+
+export type MaybeStaticDecode<T extends never | TSchema> = T extends TSchema
+  ? StaticDecode<T>
+  : never;
+
+// IMPORTANT
+// These types are used in the on-chain messages.
+// Do not change or reuse the numeric values.
+export enum AddressType {
+  NONE = -1,
+  EVM = 0,
+  CARDANO = 1,
+  SUBSTRATE = 2,
+  ALGORAND = 3,
+  MINA = 4,
+  MIDNIGHT = 5,
+  AVAIL = 6,
+  POLKADOT = 7,
+  NEAR = 8,
+}
+
+function tryDecode<T>(
+  val: string,
+  validator: (address: string) => T,
+  checkResult: (result: T) => boolean = () => true,
+): boolean {
+  try {
+    return checkResult(validator(val));
+  } catch (e) {
+    return false;
+  }
+}
+FormatRegistry.Set(
+  "algorand-address",
+  (val) => tryDecode(val, verifyAlgorandAddress),
+);
+FormatRegistry.Set(
+  "algorand-blockhash",
+  (val) => tryDecode(val, verifyAlgorandBlockHash),
+);
+FormatRegistry.Set(
+  "algorand-txid",
+  (val) => tryDecode(val, verifyAlgorandTransactionHash),
+);
+FormatRegistry.Set("mina-address", (val) => tryDecode(val, verifyMinaAddress));
+FormatRegistry.Set(
+  "mina-blockhash",
+  (val) => tryDecode(val, verifyMinaBlockHash),
+);
+FormatRegistry.Set(
+  "mina-txid",
+  (val) => tryDecode(val, verifyMinaTransactionHash),
+);
+FormatRegistry.Set(
+  "cardano-address",
+  (val) =>
+    tryDecode(val, verifyCardanoByronAddress) ||
+    tryDecode(val, verifyCardanoShelleyAddress),
+);
+FormatRegistry.Set("ss58", (val) => tryDecode(val, ss58.decode));
+FormatRegistry.Set("bs58check", (val) => tryDecode(val, bs58check.decode));
+FormatRegistry.Set("bech32", (val) =>
+  // note: increase max bech32 limit since some cryptocurrencies need it
+  tryDecode(val, (val) => bech32.decode(val, Number.MAX_SAFE_INTEGER / 2)));
+
+function forceLowercase<T extends TString | TRegExp>(schema: T): TTransform<T> {
+  return Type.Transform(schema)
+    .Decode((value) => (value as any).toLowerCase())
+    .Encode((value) => value.toLowerCase());
+}
+function forceUppercase<T extends TString | TRegExp>(schema: T): TTransform<T> {
+  return Type.Transform(schema)
+    .Decode((value) => (value as any).toUpperCase())
+    .Encode((value) => value.toUpperCase());
+}
+export const TypeboxHelpers = {
+  Uint256: Type.Transform(Type.BigInt({
+    maximum:
+      115792089237316195423570985008687907853269984665640564039457584007913129639935n,
+    minimum: 0n,
+  }))
+    .Decode((value) => value.toString())
+    .Encode((value) => BigInt(value)),
+  BlockNumber: (options?: NumberOptions) =>
+    Type.Unsafe<Nominal.BlockNumber>(Type.Number(options)),
+  AbsoluteSlotNumber: (options?: NumberOptions) =>
+    Type.Unsafe<Nominal.AbsoluteSlotNumber>(Type.Number(options)),
+  EpochNumber: (options?: NumberOptions) =>
+    Type.Unsafe<Nominal.EpochNumber>(Type.Number(options)),
+  Algorand: {
+    BlockHash: Type.Unsafe<Nominal.AlgorandBlockHash>(
+      Type.String({ format: "algorand-blockhash" }),
+    ),
+    TxHash: Type.Unsafe<Nominal.AlgorandTxHash>(
+      forceUppercase(Type.String({ format: "algorand-txid" })),
+    ),
+    Address: Type.Unsafe<Nominal.AlgorandAddress>(
+      forceUppercase(Type.String({ format: "algorand-address" })),
+    ),
+  },
+  Substrate: {
+    Address: Type.Unsafe<Nominal.SubstrateAddress>(
+      Type.String({ format: "ss58" }),
+    ),
+  },
+  Avail: {
+    BlockHash: Type.Unsafe<Nominal.AvailBlockHash>(
+      forceLowercase(Type.RegExp(/^0x[a-fA-F0-9]{64}$/)),
+    ),
+    Address: Type.Unsafe<Nominal.AvailAddress>(Type.String({ format: "ss58" })),
+    // recall: no good concept of tx hash on Substrate chains
+  },
+  Cardano: {
+    BlockHash: Type.Unsafe<Nominal.CardanoBlockHash>(
+      forceLowercase(Type.RegExp(/^[a-fA-F0-9]{64}$/)),
+    ),
+    TxHash: Type.Unsafe<Nominal.CardanoTxHash>(
+      forceLowercase(Type.RegExp(/^[a-fA-F0-9]{64}$/)),
+    ),
+    // TODO: this fails on Byron-era addresses
+    Address: Type.Unsafe<Nominal.CardanoAddress>(
+      Type.String({ format: "cardano-address" }),
+    ),
+    Credential: Type.Unsafe<Nominal.CardanoCredential>(
+      forceLowercase(Type.RegExp(/^[a-fA-F0-9]{64}$/)),
+    ),
+    // TODO: there are two common poolIDs. regex, and poolID bech32
+    PoolId: Type.Unsafe<Nominal.CardanoPoolId>(forceLowercase(Type.String())),
+    PolicyId: Type.Unsafe<Nominal.CardanoPolicyId>(
+      forceLowercase(Type.RegExp(/^[a-fA-F0-9]{56}$/)),
+    ),
+    AssetName: Type.Unsafe<Nominal.CardanoAssetName>(
+      forceLowercase(Type.RegExp(/^[a-fA-F0-9]{64}$/)),
+    ),
+    // TODO: bech32
+    Cip14Fingerprint: Type.Unsafe<Nominal.CardanoCip14Fingerprint>(
+      Type.String(),
+    ),
+    AmountLovelace: Type.Unsafe<Nominal.CardanoAmountLovelace>(
+      Type.RegExp(/^\d+$/),
+    ),
+  },
+  Evm: {
+    BlockHash: Type.Unsafe<Nominal.EvmBlockHash>(
+      forceLowercase(Type.RegExp(/^0x[a-fA-F0-9]{64}$/)),
+    ),
+    TxHash: Type.Unsafe<Nominal.EvmTxHash>(
+      forceLowercase(Type.RegExp(/^0x[a-fA-F0-9]{64}$/)),
+    ),
+    Address: Type.Unsafe<Nominal.EvmAddress>(
+      forceLowercase(Type.RegExp(/^0x[a-fA-F0-9]{40}$/)),
+    ),
+    Selector: Type.Unsafe<Nominal.Evm4ByteSelector>(
+      forceLowercase(Type.RegExp(/^0x[a-fA-F0-9]{8}$/)),
+    ),
+    FullSelector: Type.Unsafe<Nominal.EvmSelector>(
+      forceLowercase(Type.RegExp(/^0x[a-fA-F0-9]{64}$/)),
+    ),
+    Signature: Type.Unsafe<Nominal.Signature>(
+      Type.RegExp(/^0x[a-fA-F0-9]{130}$/),
+    ),
+    PrivateKey: Type.Unsafe<Nominal.EvmPrivateKey>(
+      Type.RegExp(/^0x[a-fA-F0-9]{64}$/),
+    ),
+  },
+  Midnight: {
+    BlockHash: Type.Unsafe<Nominal.MidnightBlockHash>(
+      forceLowercase(Type.RegExp(/^0x[a-fA-F0-9]{64}$/)),
+    ),
+    TxHash: Type.Unsafe<Nominal.MidnightTxHash>(
+      forceLowercase(Type.RegExp(/^0x[a-fA-F0-9]{64}$/)),
+    ),
+    // TODO Temporal placeholder for midnight address
+    Address: Type.Unsafe<Nominal.MidnightAddress>(
+      forceLowercase(Type.RegExp(/^mn_(shield-addr|addr|dust-addr|shield-esk|shield-cpk)_(test|dev|undeployed)[a-zA-Z0-9]+$/)),
+    ),
+    // TODO Temporal placeholder for midnight signature
+    Signature: Type.Unsafe<Nominal.MidnightSignature>(
+      Type.RegExp(/^.*$/),
+    ),
+  },
+  Mina: {
+    BlockHash: Type.Unsafe<Nominal.MinaBlockHash>(
+      Type.String({ format: "mina-blockhash" }),
+    ),
+    TxHash: Type.Unsafe<Nominal.MinaTxHash>(
+      Type.String({ format: "mina-txid" }),
+    ),
+    Address: Type.Unsafe<Nominal.MinaAddress>(
+      Type.String({ format: "mina-address" }),
+    ),
+  },
+  // TODO: PLACEHOLDER TYPES FOR POLKADOT
+  Polkadot: {
+    BlockHash: Type.Unsafe<Nominal.PolkadotBlockHash>(
+      Type.String({ format: "polkadot-blockhash" }),
+    ),
+    TxHash: Type.Unsafe<Nominal.PolkadotTxHash>(
+      Type.String({ format: "polkadot-txid" }),
+    ),
+    Address: Type.Unsafe<Nominal.PolkadotAddress>(Type.String({ format: "ss58" })),
+  },
+  Near: {
+    // NEAR account IDs: named (a-z0-9._-) up to 64 chars, or implicit (64 hex chars)
+    Address: Type.Unsafe<Nominal.NearAddress>(Type.String()),
+  },
+  Caip2: Type.Unsafe<Nominal.Caip2>(Type.String()),
+  WalletAddress: () =>
+    Type.Union(AddressTypebox as Mutable<typeof AddressTypebox>),
+  IntervalMs: (options?: NumberOptions) =>
+    Type.Unsafe<Nominal.IntervalMs>(Type.Number(options)),
+  IntervalSec: (options?: NumberOptions) =>
+    Type.Unsafe<Nominal.IntervalSec>(Type.Number(options)),
+  TimestampMs: (options?: NumberOptions) =>
+    Type.Unsafe<Nominal.TimestampMs>(Type.Number(options)),
+  TimestampMsStr: Type.Unsafe<Nominal.TimestampMsStr>(Type.RegExp(/^\d+$/)),
+  HexString0x: (options?: RegExpOptions) =>
+    Type.Unsafe<Nominal.HexString0x>(Type.RegExp(/^0x[a-fA-F0-9]+$/, options)),
+  HexStringNo0x: (options?: RegExpOptions) =>
+    Type.Unsafe<Nominal.HexStringNo0x>(Type.RegExp(/^[a-fA-F0-9]+$/, options)),
+  UnknownFormat: Type.Unsafe<Nominal.UnknownFormat>(Type.String()),
+  Lowercase: forceLowercase(Type.String()),
+  TrueOrFalse: Type.Transform(
+    Type.Union([Type.Literal("T"), Type.Literal("F")]),
+  )
+    .Decode((value) => value === "T")
+    .Encode((value) => (value ? "T" : "F")),
+  Nullable: <T extends TSchema>(
+    schema: T,
+    options?: SchemaOptions,
+  ): TUnion<[T, TNull]> => Type.Union([schema, Type.Null()], options),
+  SerializeObjAsJson: <
+    T,
+    StringSchema extends TSchema & { [Kind]: string } = TString,
+  >(): TTransform<TUnsafe<T>, Static<StringSchema>> =>
+    Type.Transform(Type.Unsafe<T>(Type.Any()))
+      .Decode((x) => JSON.stringify(x) as Static<StringSchema>)
+      .Encode((x) => JSON.parse(x as string) as T),
+  SerializeJsonAsObj: <
+    T,
+    StringSchema extends TSchema & { [Kind]: string } = TString,
+  >(
+    schema: StringSchema,
+  ): TTransform<StringSchema, T> =>
+    Type.Transform(schema)
+      .Decode((x) => JSON.parse(x as string) as T)
+      .Encode((x: T) => JSON.stringify(x) as Static<StringSchema>),
+  // TODO: maybe improve with a typebox-specific EVM ABI wrapper
+  //       abitype library comes with a ZOD verifier, and that can be ported to typebox
+  EvmAbiEvent: Type.Unsafe<AbiEvent>(Type.Any()),
+};
+
+export const AddressValidator = {
+  [AddressType.NONE]: Type.Literal("0x0"),
+  [AddressType.EVM]: TypeboxHelpers.Evm.Address,
+  [AddressType.CARDANO]: TypeboxHelpers.Cardano.Address,
+  [AddressType.SUBSTRATE]: TypeboxHelpers.Substrate.Address,
+  [AddressType.AVAIL]: TypeboxHelpers.Avail.Address,
+  [AddressType.ALGORAND]: TypeboxHelpers.Algorand.Address,
+  [AddressType.MINA]: TypeboxHelpers.Mina.Address,
+  [AddressType.MIDNIGHT]: TypeboxHelpers.Midnight.Address,
+  [AddressType.POLKADOT]: TypeboxHelpers.Polkadot.Address,
+  [AddressType.NEAR]: TypeboxHelpers.Near.Address,
+} as const satisfies Record<AddressType, TSchema>;
+
+export const AddressTypebox = [
+  Type.Object({
+    type: Type.Literal(AddressType.NONE),
+    address: Type.Literal("0x0"),
+  }),
+  Type.Object({
+    type: Type.Literal(AddressType.EVM),
+    address: TypeboxHelpers.Evm.Address,
+  }),
+  Type.Object({
+    type: Type.Literal(AddressType.CARDANO),
+    address: TypeboxHelpers.Cardano.Address,
+  }),
+  Type.Object({
+    type: Type.Literal(AddressType.SUBSTRATE),
+    address: TypeboxHelpers.Substrate.Address,
+  }),
+  Type.Object({
+    type: Type.Literal(AddressType.AVAIL),
+    address: TypeboxHelpers.Avail.Address,
+  }),
+  Type.Object({
+    type: Type.Literal(AddressType.ALGORAND),
+    address: TypeboxHelpers.Algorand.Address,
+  }),
+  Type.Object({
+    type: Type.Literal(AddressType.MINA),
+    address: TypeboxHelpers.Mina.Address,
+  }),
+  Type.Object({
+    type: Type.Literal(AddressType.MIDNIGHT),
+    address: TypeboxHelpers.Midnight.Address,
+  }),
+  Type.Object({
+    type: Type.Literal(AddressType.POLKADOT),
+    address: TypeboxHelpers.Polkadot.Address,
+  }),
+  Type.Object({
+    type: Type.Literal(AddressType.NEAR),
+    address: TypeboxHelpers.Near.Address,
+  }),
+] as const;
+true satisfies Satisfies<
+  [(typeof AddressTypebox)[number]["static"]["type"]],
+  [AddressType]
+>;
+
+type AddressTypeMap = {
+  [K in keyof typeof AddressValidator]: StaticDecode<
+    (typeof AddressValidator)[K]
+  >;
+};
+export type AddressAndType = {
+  [K in keyof AddressTypeMap]: {
+    type: K;
+    address: AddressTypeMap[K];
+  };
+}[keyof AddressTypeMap];
+
+export function checkOrError<T extends TSchema>(
+  name: string | undefined,
+  structure: T,
+  config: unknown,
+): StaticDecode<T> {
+  // 1) Check if there are any errors since Value.Decode doesn't give error messages
+  {
+    const errors = Array.from(Value.Errors(structure, config)).filter(
+      // there are many useless errors in this library
+      // ex: 1st error: "foo" should be "bar" in struct Foo
+      //     2nd error: struct Foo is invalid inside struct Config
+      //     in this case, the 2nd error is useless as we only care about the 1st error
+      // However, we always want to show the error if for some reason it's the only error
+      (error) =>
+        error.type !== ValueErrorType.Intersect &&
+        error.type !== ValueErrorType.Union,
+    );
+
+    for (const error of errors) {
+      console.error({
+        name: name ?? "Schema root",
+        path: error.path,
+        valueProvided: error.value,
+        message: error.message,
+      });
+    }
+    if (errors.length > 1) {
+      throw new Error(`Schema field missing or invalid. See above for error.`);
+    }
+  }
+
+  const decoded = Value.Decode(structure, config);
+  return decoded;
+}
+
+type TObjectToTuple<
+  Obj extends TObject<any>,
+  Keys extends (keyof Obj["properties"])[],
+> = {
+  [K in keyof Keys]: [
+    Keys[K],
+    Obj extends TObject<Record<Keys[K] & string, infer V extends TSchema>> ? V
+      : never,
+  ];
+};
+export function pick<const Keys extends string[]>(
+  keys: Keys,
+): {
+  from: <Obj extends TObject<Record<Keys[number], any>>>(
+    obj: Obj,
+  ) => TObjectToTuple<Obj, Keys>;
+} {
+  return {
+    from: (obj) => {
+      const result = [];
+      for (const key of keys) {
+        result.push([key, (obj.properties as any)[key]]);
+      }
+      return result as any;
+    },
+  };
+}
+
+type HasAllProperties<
+  T extends TObject<any>,
+  K extends string[],
+> = keyof T["properties"] extends K[number] ? T
+  : TypeErrorMessage<
+    `Missing properties: ${string & Exclude<keyof T["properties"], K[number]>}`
+  >;
+
+/**
+ * Same as `pick`, but requires that you include ALL properties and not just a subset of them
+ */
+export function pickAll<const Keys extends string[]>(
+  keys: Keys,
+): {
+  from: <Obj extends TObject<Record<Keys[number], any>>>(
+    obj: HasAllProperties<Obj, Keys>,
+  ) => TObjectToTuple<Obj, Keys>;
+} {
+  return {
+    from: (obj) => pick(keys).from(obj as any),
+  };
+}

package/src/types/utils.ts

@@ -0,0 +1,60 @@
+import type { HexString0x, HexStringNo0x } from "./nominal.ts";
+
+export type Json = null | boolean | number | string | Json[] | {
+  [key: string]: Json;
+};
+
+/**
+ * This is a patch for a limitation in Typescript
+ * When writing functions with return types that are conditional (ex: (): T extends ... ? Foo : Bar
+ * It can't easily know type narrowing in function body leads to satisfying return type constraints
+ *
+ * Typically, this is solved by using an `as` when using `return`:
+ * ```
+ * function foo<T>(foo: T): Result<T> {
+ *     if (foo === ...) {
+ *         return { ... } as Result<T>;  // we have to cast (`as`) to make it work
+ *     }
+ * }
+ * ```
+ * but this loses some type safety (in hides any error in the `{ ... }`
+ *
+ * To solve this, this function checks that
+ *     the input is valid for *some* instance of the generic
+ *     and then casts it to a more general instance
+ *
+ * TODO: we can probably delete this once Typescript 5.8 is released
+ *       https://github.com/microsoft/TypeScript/pull/56941
+ */
+export function narrowResult<
+  const General,
+  const Input extends General,
+  const Output extends General,
+>(result: Input): Output {
+  return result as unknown as Output;
+}
+
+export function strip0x(str: string): HexStringNo0x {
+  if (str.startsWith("0x")) {
+    return str.substring(2);
+  }
+  return str;
+}
+export function add0x(str: string): HexString0x {
+  if (str.startsWith("0x")) {
+    return str as `0x{string}`;
+  }
+  return `0x${str}`;
+}
+
+/**
+ * Typed version of Object.keys()
+ *
+ * careful: this is dangerous.
+ *          Only use when you're sure there are no other key types added dynamically
+ */
+export function keysOf<Key extends number | string>(
+  obj: Record<Key, unknown>,
+): Key[] {
+  return Object.keys(obj) as Key[];
+}

package/src/types/validators/algorand.ts

@@ -0,0 +1,120 @@
+import base32 from "hi-base32";
+import sha512 from "js-sha512";
+import { Base64 } from "js-base64";
+import { CHECKSUM_ERROR_MSG, MALFORMED_ERROR_MSG } from "./utils.ts";
+
+const BLOCK_HASH_BYTE_LENGTH = 32;
+const TX_ID_BYTE_LENGTH = 32;
+const ADDRESS_BYTE_LENGTH = 36;
+const CHECKSUM_BYTE_LENGTH = 4;
+const ADDRESS_LENGTH = 58;
+const HASH_BYTES_LENGTH = 32;
+const PUBLIC_KEY_LENGTH = 32;
+
+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");
+const CHECKSUM_ADDRESS_ERROR_MSG = CHECKSUM_ERROR_MSG("address");
+
+function checksumFromPublicKey(pk: Uint8Array): Uint8Array {
+  return Uint8Array.from(
+    sha512.sha512_256.array(pk).slice(
+      HASH_BYTES_LENGTH - CHECKSUM_BYTE_LENGTH,
+      HASH_BYTES_LENGTH,
+    ),
+  );
+}
+
+/**
+ * Taken from https://github.com/algorand/js-algorand-sdk/blob/6973ff583b243ddb0632e91f4c0383021430a789/src/encoding/address.ts#L88
+ *
+ * For regular addresses,
+ *     base32 encoding of a 32-byte ed25519 public key and a 4-byte checksum (the last 4 bytes of the SHA-512/256 hash of the public key)
+ * For multisig addresses,
+ *     instead of a 32-byte public key, it’s the hash of some fields that specify the details of the multisig account.
+ *     more specifically, it’s the SHA-512/256 hash of (a version byte, a threshold, and the public keys of all possible signers).
+ *     The checksum is computed the same way as for regular addresses.
+ *
+ * Example address: JY2FRXQP7Q6SYH7QE2HF2XWNE644V6KUH3PYC4SYWPUSEATTDJSNUHMHR4
+ */
+export function verifyAlgorandAddress(address: string): boolean {
+  if (typeof address !== "string") {
+    throw new Error(
+      `${MALFORMED_ADDRESS_ERROR_MSG}: expected string, got ${typeof address}, ${address}`,
+    );
+  }
+  if (address.length !== ADDRESS_LENGTH) {
+    throw new Error(
+      `${MALFORMED_ADDRESS_ERROR_MSG}: expected length ${ADDRESS_LENGTH}, got ${address.length}: ${address}`,
+    );
+  }
+
+  // try to decode
+  const decoded = base32.decode.asBytes(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}`,
+    );
+  }
+
+  // Find publickey and checksum
+  const pk = new Uint8Array(
+    decoded.slice(0, ADDRESS_BYTE_LENGTH - CHECKSUM_BYTE_LENGTH),
+  );
+  const cs = new Uint8Array(
+    decoded.slice(PUBLIC_KEY_LENGTH, ADDRESS_BYTE_LENGTH),
+  );
+  const checksum = checksumFromPublicKey(pk);
+  // Check if the checksum and the address are equal
+  if (!arrayEqual(checksum, cs)) throw new Error(CHECKSUM_ADDRESS_ERROR_MSG);
+
+  return true;
+}
+
+/**
+ * Note: strangely, there are 3 common ways to encode Algorand block hashes
+ * 1. (rpc) base64
+ * 2. (algokit json) blk-${base32} (stripping padding)
+ * 3. (msgpck) base32 (unsure about padding)
+ *
+ * Example block hash: 3KYSrPgi16Cl3iLu3r+GaeZkBBrgNFbMB60jsrJtTdI=
+ */
+export function verifyAlgorandBlockHash(hash: string): boolean {
+  // TODO: length check?
+  const decoded = Base64.toUint8Array(
+    "3KYSrPgi16Cl3iLu3r+GaeZkBBrgNFbMB60jsrJtTdI=",
+  );
+  // 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;
+}
+
+/**
+ * Taken from https://github.com/algorand/js-algorand-sdk/blob/6973ff583b243ddb0632e91f4c0383021430a789/src/transaction.ts#L1102
+ *
+ * base32 string encoding (stripping padding) of a "rawTxId" (SHA512/256 digest)
+ *
+ * Example tx hash: IJFAHCDFJ25GBPPNXXZ67KR2IQMZ5XGMAFWCKXIETKY6WV4OR6YQ
+ */
+export function verifyAlgorandTransactionHash(hash: string): boolean {
+  const decoded = base32.decode.asBytes(hash);
+  // Sanity check
+  if (decoded.length !== BLOCK_HASH_BYTE_LENGTH) {
+    throw new Error(
+      `${MALFORMED_BLOCK_HASH_ERROR_MSG}: expected byte length ${MALFORMED_BLOCK_HASH_ERROR_MSG}, got ${decoded.length}`,
+    );
+  }
+  return true;
+}
+
+function arrayEqual<T>(a: ArrayLike<T>, b: ArrayLike<T>): boolean {
+  if (a.length !== b.length) {
+    return false;
+  }
+  return Array.from(a).every((val, i) => val === b[i]);
+}