@paimaexample/wallets 0.3.117

package/esm/utils/src/types/typebox-helpers.js

@@ -0,0 +1,235 @@
+import { FormatRegistry, Type } from "@sinclair/typebox";
+import { Value, ValueErrorType } from "@sinclair/typebox/value";
+import * as ss58 from "@subsquid/ss58-codec";
+import bs58check from "bs58check";
+import { bech32 } from "bech32";
+import { verifyAlgorandAddress, verifyAlgorandBlockHash, verifyAlgorandTransactionHash, } from "./validators/algorand.js";
+import { verifyMinaAddress, verifyMinaBlockHash, verifyMinaTransactionHash, } from "./validators/mina.js";
+import { verifyCardanoByronAddress, verifyCardanoShelleyAddress, } from "./validators/cardano.js";
+// IMPORTANT
+// These types are used in the on-chain messages.
+// Do not change or reuse the numeric values.
+export var AddressType;
+(function (AddressType) {
+    AddressType[AddressType["NONE"] = -1] = "NONE";
+    AddressType[AddressType["EVM"] = 0] = "EVM";
+    AddressType[AddressType["CARDANO"] = 1] = "CARDANO";
+    AddressType[AddressType["SUBSTRATE"] = 2] = "SUBSTRATE";
+    AddressType[AddressType["ALGORAND"] = 3] = "ALGORAND";
+    AddressType[AddressType["MINA"] = 4] = "MINA";
+    AddressType[AddressType["MIDNIGHT"] = 5] = "MIDNIGHT";
+    AddressType[AddressType["AVAIL"] = 6] = "AVAIL";
+    AddressType[AddressType["POLKADOT"] = 7] = "POLKADOT";
+})(AddressType || (AddressType = {}));
+function tryDecode(val, validator, checkResult = () => true) {
+    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(schema) {
+    return Type.Transform(schema)
+        .Decode((value) => value.toLowerCase())
+        .Encode((value) => value.toLowerCase());
+}
+function forceUppercase(schema) {
+    return Type.Transform(schema)
+        .Decode((value) => value.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) => Type.Unsafe(Type.Number(options)),
+    AbsoluteSlotNumber: (options) => Type.Unsafe(Type.Number(options)),
+    EpochNumber: (options) => Type.Unsafe(Type.Number(options)),
+    Algorand: {
+        BlockHash: Type.Unsafe(Type.String({ format: "algorand-blockhash" })),
+        TxHash: Type.Unsafe(forceUppercase(Type.String({ format: "algorand-txid" }))),
+        Address: Type.Unsafe(forceUppercase(Type.String({ format: "algorand-address" }))),
+    },
+    Substrate: {
+        Address: Type.Unsafe(Type.String({ format: "ss58" })),
+    },
+    Avail: {
+        BlockHash: Type.Unsafe(forceLowercase(Type.RegExp(/^0x[a-fA-F0-9]{64}$/))),
+        Address: Type.Unsafe(Type.String({ format: "ss58" })),
+        // recall: no good concept of tx hash on Substrate chains
+    },
+    Cardano: {
+        BlockHash: Type.Unsafe(forceLowercase(Type.RegExp(/^[a-fA-F0-9]{64}$/))),
+        TxHash: Type.Unsafe(forceLowercase(Type.RegExp(/^[a-fA-F0-9]{64}$/))),
+        // TODO: this fails on Byron-era addresses
+        Address: Type.Unsafe(Type.String({ format: "cardano-address" })),
+        Credential: Type.Unsafe(forceLowercase(Type.RegExp(/^[a-fA-F0-9]{64}$/))),
+        // TODO: there are two common poolIDs. regex, and poolID bech32
+        PoolId: Type.Unsafe(forceLowercase(Type.String())),
+        PolicyId: Type.Unsafe(forceLowercase(Type.RegExp(/^[a-fA-F0-9]{56}$/))),
+        AssetName: Type.Unsafe(forceLowercase(Type.RegExp(/^[a-fA-F0-9]{64}$/))),
+        // TODO: bech32
+        Cip14Fingerprint: Type.Unsafe(Type.String()),
+        AmountLovelace: Type.Unsafe(Type.RegExp(/^\d+$/)),
+    },
+    Evm: {
+        BlockHash: Type.Unsafe(forceLowercase(Type.RegExp(/^0x[a-fA-F0-9]{64}$/))),
+        TxHash: Type.Unsafe(forceLowercase(Type.RegExp(/^0x[a-fA-F0-9]{64}$/))),
+        Address: Type.Unsafe(forceLowercase(Type.RegExp(/^0x[a-fA-F0-9]{40}$/))),
+        Selector: Type.Unsafe(forceLowercase(Type.RegExp(/^0x[a-fA-F0-9]{8}$/))),
+        FullSelector: Type.Unsafe(forceLowercase(Type.RegExp(/^0x[a-fA-F0-9]{64}$/))),
+        Signature: Type.Unsafe(Type.RegExp(/^0x[a-fA-F0-9]{130}$/)),
+        PrivateKey: Type.Unsafe(Type.RegExp(/^0x[a-fA-F0-9]{64}$/)),
+    },
+    Midnight: {
+        BlockHash: Type.Unsafe(forceLowercase(Type.RegExp(/^0x[a-fA-F0-9]{64}$/))),
+        TxHash: Type.Unsafe(forceLowercase(Type.RegExp(/^0x[a-fA-F0-9]{64}$/))),
+        Address: Type.Unsafe(forceLowercase(Type.RegExp(/^[a-fA-F0-9]{181}$/))),
+    },
+    Mina: {
+        BlockHash: Type.Unsafe(Type.String({ format: "mina-blockhash" })),
+        TxHash: Type.Unsafe(Type.String({ format: "mina-txid" })),
+        Address: Type.Unsafe(Type.String({ format: "mina-address" })),
+    },
+    // TODO THIS IS WRONG TYPE - ONLY A PLACEHOLDER
+    Polkadot: {
+        BlockHash: Type.Unsafe(Type.String({ format: "mina-blockhash" })),
+        TxHash: Type.Unsafe(Type.String({ format: "mina-txid" })),
+        Address: Type.Unsafe(Type.String({ format: "mina-address" })),
+    },
+    Caip2: Type.Unsafe(Type.String()),
+    WalletAddress: () => Type.Union(AddressTypebox),
+    IntervalMs: (options) => Type.Unsafe(Type.Number(options)),
+    IntervalSec: (options) => Type.Unsafe(Type.Number(options)),
+    TimestampMs: (options) => Type.Unsafe(Type.Number(options)),
+    TimestampMsStr: Type.Unsafe(Type.RegExp(/^\d+$/)),
+    HexString0x: (options) => Type.Unsafe(Type.RegExp(/^0x[a-fA-F0-9]+$/, options)),
+    HexStringNo0x: (options) => Type.Unsafe(Type.RegExp(/^[a-fA-F0-9]+$/, options)),
+    UnknownFormat: Type.Unsafe(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: (schema, options) => Type.Union([schema, Type.Null()], options),
+    SerializeObjAsJson: () => Type.Transform(Type.Unsafe(Type.Any()))
+        .Decode((x) => JSON.stringify(x))
+        .Encode((x) => JSON.parse(x)),
+    SerializeJsonAsObj: (schema) => Type.Transform(schema)
+        .Decode((x) => JSON.parse(x))
+        .Encode((x) => JSON.stringify(x)),
+    // 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(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,
+};
+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,
+    }),
+];
+true;
+export function checkOrError(name, structure, config) {
+    // 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;
+}
+export function pick(keys) {
+    return {
+        from: (obj) => {
+            const result = [];
+            for (const key of keys) {
+                result.push([key, obj.properties[key]]);
+            }
+            return result;
+        },
+    };
+}
+/**
+ * Same as `pick`, but requires that you include ALL properties and not just a subset of them
+ */
+export function pickAll(keys) {
+    return {
+        from: (obj) => pick(keys).from(obj),
+    };
+}

package/esm/utils/src/types/utils.d.ts

@@ -0,0 +1,37 @@
+import type { HexString0x, HexStringNo0x } from "./nominal.js";
+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 declare function narrowResult<const General, const Input extends General, const Output extends General>(result: Input): Output;
+export declare function strip0x(str: string): HexStringNo0x;
+export declare function add0x(str: string): HexString0x;
+/**
+ * Typed version of Object.keys()
+ *
+ * careful: this is dangerous.
+ *          Only use when you're sure there are no other key types added dynamically
+ */
+export declare function keysOf<Key extends number | string>(obj: Record<Key, unknown>): Key[];
+//# sourceMappingURL=utils.d.ts.map

package/esm/utils/src/types/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/utils/src/types/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE/D,MAAM,MAAM,IAAI,GAAG,IAAI,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,EAAE,GAAG;IAC7D,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CACrB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,YAAY,CAC1B,KAAK,CAAC,OAAO,EACb,KAAK,CAAC,KAAK,SAAS,OAAO,EAC3B,KAAK,CAAC,MAAM,SAAS,OAAO,EAC5B,MAAM,EAAE,KAAK,GAAG,MAAM,CAEvB;AAED,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,CAKlD;AACD,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAK9C;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,GAAG,SAAS,MAAM,GAAG,MAAM,EAChD,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,OAAO,CAAC,GACxB,GAAG,EAAE,CAEP"}

package/esm/utils/src/types/utils.js

@@ -0,0 +1,46 @@
+/**
+ * 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(result) {
+    return result;
+}
+export function strip0x(str) {
+    if (str.startsWith("0x")) {
+        return str.substring(2);
+    }
+    return str;
+}
+export function add0x(str) {
+    if (str.startsWith("0x")) {
+        return str;
+    }
+    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(obj) {
+    return Object.keys(obj);
+}

package/esm/utils/src/types/validators/algorand.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 declare function verifyAlgorandAddress(address: string): boolean;
+/**
+ * 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 declare function verifyAlgorandBlockHash(hash: string): boolean;
+/**
+ * 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 declare function verifyAlgorandTransactionHash(hash: string): boolean;
+//# sourceMappingURL=algorand.d.ts.map

package/esm/utils/src/types/validators/algorand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"algorand.d.ts","sourceRoot":"","sources":["../../../../../src/utils/src/types/validators/algorand.ts"],"names":[],"mappings":"AA2BA;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAiC9D;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAY7D;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CASnE"}

package/esm/utils/src/types/validators/algorand.js

@@ -0,0 +1,90 @@
+import base32 from "hi-base32";
+import sha512 from "js-sha512";
+import { Base64 } from "js-base64";
+import { CHECKSUM_ERROR_MSG, MALFORMED_ERROR_MSG } from "./utils.js";
+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) {
+    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) {
+    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) {
+    // 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) {
+    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(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    return Array.from(a).every((val, i) => val === b[i]);
+}

package/esm/utils/src/types/validators/cardano.d.ts

@@ -0,0 +1,26 @@
+export declare const InvalidArgumentError: ErrorConstructor;
+/**
+ * Example address:
+ * - (mainnet icarus) Ae2tdPwUPEZFRbyhz3cpfC2CumGzNkFBN2L42rcUc2yjQpEkxDbkPodpMAi
+ * - (testnet byron) 37btjrVyb4KDXBNC4haBVPCrro8AQPHwvCMp3RFhhSVWwfFmZ6wwzSK6JK1hY6wHNmtrpTf1kdbva8TCneM2YsiXT7mrzT21EacHnPpz5YyUdj64na
+ * - (mainnet byron) 82d818584283581caf335162c1ecb0a5b95342e3d1d0c9c38a246fa976b077e81dea9d9ba101581e581c2d574aa85a82a80fd6d1c51ea115c2b03b68166230a3c383c9f89ad5001ac3de014e
+ */
+export declare function verifyCardanoByronAddress(address: string): boolean;
+export declare enum AddressType {
+    BasePaymentKeyStakeKey = 0,
+    BasePaymentScriptStakeKey = 1,
+    BasePaymentKeyStakeScript = 2,
+    BasePaymentScriptStakeScript = 3,
+    PointerKey = 4,
+    PointerScript = 5,
+    EnterpriseKey = 6,
+    EnterpriseScript = 7,
+    Byron = 8,
+    RewardKey = 14,
+    RewardScript = 15
+}
+/**
+ * See: https://github.com/input-output-hk/cardano-js-sdk/blob/d1544fc9d1fb3997eb7c5b94a233789bb9e5cd9f/packages/core/src/Cardano/Address/Address.ts
+ */
+export declare function verifyCardanoShelleyAddress(address: string): boolean;
+//# sourceMappingURL=cardano.d.ts.map

package/esm/utils/src/types/validators/cardano.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cardano.d.ts","sourceRoot":"","sources":["../../../../../src/utils/src/types/validators/cardano.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,oBAAoB,kBAAQ,CAAC;AAE1C;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAElE;AAkBD,oBAAY,WAAW;IACrB,sBAAsB,IAAS;IAC/B,yBAAyB,IAAS;IAClC,yBAAyB,IAAS;IAClC,4BAA4B,IAAS;IACrC,UAAU,IAAS;IACnB,aAAa,IAAS;IACtB,aAAa,IAAS;IACtB,gBAAgB,IAAS;IAGzB,KAAK,IAAS;IACd,SAAS,KAAS;IAClB,YAAY,KAAS;CAEtB;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAwDpE"}

package/esm/utils/src/types/validators/cardano.js

@@ -0,0 +1,113 @@
+import { crc32 } from "@foxglove/crc";
+import { CHECKSUM_ERROR_MSG, MALFORMED_ERROR_MSG } from "./utils.js";
+import { MiniCborReader } from "./minicbor.js";
+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) {
+    return verifyCardanoByronAddressBytes(bs58.decode(address));
+}
+function verifyCardanoByronAddressBytes(data) {
+    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 var AddressType;
+(function (AddressType) {
+    AddressType[AddressType["BasePaymentKeyStakeKey"] = 0] = "BasePaymentKeyStakeKey";
+    AddressType[AddressType["BasePaymentScriptStakeKey"] = 1] = "BasePaymentScriptStakeKey";
+    AddressType[AddressType["BasePaymentKeyStakeScript"] = 2] = "BasePaymentKeyStakeScript";
+    AddressType[AddressType["BasePaymentScriptStakeScript"] = 3] = "BasePaymentScriptStakeScript";
+    AddressType[AddressType["PointerKey"] = 4] = "PointerKey";
+    AddressType[AddressType["PointerScript"] = 5] = "PointerScript";
+    AddressType[AddressType["EnterpriseKey"] = 6] = "EnterpriseKey";
+    AddressType[AddressType["EnterpriseScript"] = 7] = "EnterpriseScript";
+    // 0b1000 was chosen because all existing Byron addresses actually start with 0b1000,
+    // therefore we can re-use Byron addresses as-is
+    AddressType[AddressType["Byron"] = 8] = "Byron";
+    AddressType[AddressType["RewardKey"] = 14] = "RewardKey";
+    AddressType[AddressType["RewardScript"] = 15] = "RewardScript";
+    // 1001-1101 are left for future formats
+})(AddressType || (AddressType = {}));
+/**
+ * See: https://github.com/input-output-hk/cardano-js-sdk/blob/d1544fc9d1fb3997eb7c5b94a233789bb9e5cd9f/packages/core/src/Cardano/Address/Address.ts
+ */
+export function verifyCardanoShelleyAddress(address) {
+    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) => {
+    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/esm/utils/src/types/validators/mina.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Example address: B62qpLST3UC1rpVT6SHfB7wqW2iQgiopFAGfrcovPgLjgfpDUN2LLeg
+ */
+export declare function verifyMinaAddress(address: string): boolean;
+/**
+ * Example block hash: 3NK9ToRM1gnzyDbafWzdde7EYemjUN2cb5isjtchcCuupty2MgbC
+ */
+export declare function verifyMinaBlockHash(hash: string): boolean;
+/**
+ * See https://github.com/openmina/openmina/blob/26354df0b4165a82ba67fa9ab1f2301841f7b033/mina-p2p-messages/src/v2/hashing.rs#L89-L92
+ *
+ * Example tx hash: 5JuYVpv6njuwUjgf8WLfXhTEJGHck1pwJXt92Lpcskiwu8kBL632
+ */
+export declare function verifyMinaTransactionHash(hash: string): boolean;
+//# sourceMappingURL=mina.d.ts.map

package/esm/utils/src/types/validators/mina.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mina.d.ts","sourceRoot":"","sources":["../../../../../src/utils/src/types/validators/mina.ts"],"names":[],"mappings":"AAWA;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAS1D;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CASzD;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAS/D"}

package/esm/utils/src/types/validators/mina.js

@@ -0,0 +1,43 @@
+import bs58check from "bs58check";
+import { MALFORMED_ERROR_MSG } from "./utils.js";
+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) {
+    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) {
+    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) {
+    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;
+}