@paimaexample/wallets 0.3.117

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

@@ -0,0 +1,277 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddressTypebox = exports.AddressValidator = exports.TypeboxHelpers = exports.AddressType = void 0;
+exports.checkOrError = checkOrError;
+exports.pick = pick;
+exports.pickAll = pickAll;
+const typebox_1 = require("@sinclair/typebox");
+const value_1 = require("@sinclair/typebox/value");
+const ss58 = __importStar(require("@subsquid/ss58-codec"));
+const bs58check_1 = __importDefault(require("bs58check"));
+const bech32_1 = require("bech32");
+const algorand_js_1 = require("./validators/algorand.js");
+const mina_js_1 = require("./validators/mina.js");
+const cardano_js_1 = require("./validators/cardano.js");
+// IMPORTANT
+// These types are used in the on-chain messages.
+// Do not change or reuse the numeric values.
+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 || (exports.AddressType = AddressType = {}));
+function tryDecode(val, validator, checkResult = () => true) {
+    try {
+        return checkResult(validator(val));
+    }
+    catch (e) {
+        return false;
+    }
+}
+typebox_1.FormatRegistry.Set("algorand-address", (val) => tryDecode(val, algorand_js_1.verifyAlgorandAddress));
+typebox_1.FormatRegistry.Set("algorand-blockhash", (val) => tryDecode(val, algorand_js_1.verifyAlgorandBlockHash));
+typebox_1.FormatRegistry.Set("algorand-txid", (val) => tryDecode(val, algorand_js_1.verifyAlgorandTransactionHash));
+typebox_1.FormatRegistry.Set("mina-address", (val) => tryDecode(val, mina_js_1.verifyMinaAddress));
+typebox_1.FormatRegistry.Set("mina-blockhash", (val) => tryDecode(val, mina_js_1.verifyMinaBlockHash));
+typebox_1.FormatRegistry.Set("mina-txid", (val) => tryDecode(val, mina_js_1.verifyMinaTransactionHash));
+typebox_1.FormatRegistry.Set("cardano-address", (val) => tryDecode(val, cardano_js_1.verifyCardanoByronAddress) ||
+    tryDecode(val, cardano_js_1.verifyCardanoShelleyAddress));
+typebox_1.FormatRegistry.Set("ss58", (val) => tryDecode(val, ss58.decode));
+typebox_1.FormatRegistry.Set("bs58check", (val) => tryDecode(val, bs58check_1.default.decode));
+typebox_1.FormatRegistry.Set("bech32", (val) => 
+// note: increase max bech32 limit since some cryptocurrencies need it
+tryDecode(val, (val) => bech32_1.bech32.decode(val, Number.MAX_SAFE_INTEGER / 2)));
+function forceLowercase(schema) {
+    return typebox_1.Type.Transform(schema)
+        .Decode((value) => value.toLowerCase())
+        .Encode((value) => value.toLowerCase());
+}
+function forceUppercase(schema) {
+    return typebox_1.Type.Transform(schema)
+        .Decode((value) => value.toUpperCase())
+        .Encode((value) => value.toUpperCase());
+}
+exports.TypeboxHelpers = {
+    Uint256: typebox_1.Type.Transform(typebox_1.Type.BigInt({
+        maximum: 115792089237316195423570985008687907853269984665640564039457584007913129639935n,
+        minimum: 0n,
+    }))
+        .Decode((value) => value.toString())
+        .Encode((value) => BigInt(value)),
+    BlockNumber: (options) => typebox_1.Type.Unsafe(typebox_1.Type.Number(options)),
+    AbsoluteSlotNumber: (options) => typebox_1.Type.Unsafe(typebox_1.Type.Number(options)),
+    EpochNumber: (options) => typebox_1.Type.Unsafe(typebox_1.Type.Number(options)),
+    Algorand: {
+        BlockHash: typebox_1.Type.Unsafe(typebox_1.Type.String({ format: "algorand-blockhash" })),
+        TxHash: typebox_1.Type.Unsafe(forceUppercase(typebox_1.Type.String({ format: "algorand-txid" }))),
+        Address: typebox_1.Type.Unsafe(forceUppercase(typebox_1.Type.String({ format: "algorand-address" }))),
+    },
+    Substrate: {
+        Address: typebox_1.Type.Unsafe(typebox_1.Type.String({ format: "ss58" })),
+    },
+    Avail: {
+        BlockHash: typebox_1.Type.Unsafe(forceLowercase(typebox_1.Type.RegExp(/^0x[a-fA-F0-9]{64}$/))),
+        Address: typebox_1.Type.Unsafe(typebox_1.Type.String({ format: "ss58" })),
+        // recall: no good concept of tx hash on Substrate chains
+    },
+    Cardano: {
+        BlockHash: typebox_1.Type.Unsafe(forceLowercase(typebox_1.Type.RegExp(/^[a-fA-F0-9]{64}$/))),
+        TxHash: typebox_1.Type.Unsafe(forceLowercase(typebox_1.Type.RegExp(/^[a-fA-F0-9]{64}$/))),
+        // TODO: this fails on Byron-era addresses
+        Address: typebox_1.Type.Unsafe(typebox_1.Type.String({ format: "cardano-address" })),
+        Credential: typebox_1.Type.Unsafe(forceLowercase(typebox_1.Type.RegExp(/^[a-fA-F0-9]{64}$/))),
+        // TODO: there are two common poolIDs. regex, and poolID bech32
+        PoolId: typebox_1.Type.Unsafe(forceLowercase(typebox_1.Type.String())),
+        PolicyId: typebox_1.Type.Unsafe(forceLowercase(typebox_1.Type.RegExp(/^[a-fA-F0-9]{56}$/))),
+        AssetName: typebox_1.Type.Unsafe(forceLowercase(typebox_1.Type.RegExp(/^[a-fA-F0-9]{64}$/))),
+        // TODO: bech32
+        Cip14Fingerprint: typebox_1.Type.Unsafe(typebox_1.Type.String()),
+        AmountLovelace: typebox_1.Type.Unsafe(typebox_1.Type.RegExp(/^\d+$/)),
+    },
+    Evm: {
+        BlockHash: typebox_1.Type.Unsafe(forceLowercase(typebox_1.Type.RegExp(/^0x[a-fA-F0-9]{64}$/))),
+        TxHash: typebox_1.Type.Unsafe(forceLowercase(typebox_1.Type.RegExp(/^0x[a-fA-F0-9]{64}$/))),
+        Address: typebox_1.Type.Unsafe(forceLowercase(typebox_1.Type.RegExp(/^0x[a-fA-F0-9]{40}$/))),
+        Selector: typebox_1.Type.Unsafe(forceLowercase(typebox_1.Type.RegExp(/^0x[a-fA-F0-9]{8}$/))),
+        FullSelector: typebox_1.Type.Unsafe(forceLowercase(typebox_1.Type.RegExp(/^0x[a-fA-F0-9]{64}$/))),
+        Signature: typebox_1.Type.Unsafe(typebox_1.Type.RegExp(/^0x[a-fA-F0-9]{130}$/)),
+        PrivateKey: typebox_1.Type.Unsafe(typebox_1.Type.RegExp(/^0x[a-fA-F0-9]{64}$/)),
+    },
+    Midnight: {
+        BlockHash: typebox_1.Type.Unsafe(forceLowercase(typebox_1.Type.RegExp(/^0x[a-fA-F0-9]{64}$/))),
+        TxHash: typebox_1.Type.Unsafe(forceLowercase(typebox_1.Type.RegExp(/^0x[a-fA-F0-9]{64}$/))),
+        Address: typebox_1.Type.Unsafe(forceLowercase(typebox_1.Type.RegExp(/^[a-fA-F0-9]{181}$/))),
+    },
+    Mina: {
+        BlockHash: typebox_1.Type.Unsafe(typebox_1.Type.String({ format: "mina-blockhash" })),
+        TxHash: typebox_1.Type.Unsafe(typebox_1.Type.String({ format: "mina-txid" })),
+        Address: typebox_1.Type.Unsafe(typebox_1.Type.String({ format: "mina-address" })),
+    },
+    // TODO THIS IS WRONG TYPE - ONLY A PLACEHOLDER
+    Polkadot: {
+        BlockHash: typebox_1.Type.Unsafe(typebox_1.Type.String({ format: "mina-blockhash" })),
+        TxHash: typebox_1.Type.Unsafe(typebox_1.Type.String({ format: "mina-txid" })),
+        Address: typebox_1.Type.Unsafe(typebox_1.Type.String({ format: "mina-address" })),
+    },
+    Caip2: typebox_1.Type.Unsafe(typebox_1.Type.String()),
+    WalletAddress: () => typebox_1.Type.Union(exports.AddressTypebox),
+    IntervalMs: (options) => typebox_1.Type.Unsafe(typebox_1.Type.Number(options)),
+    IntervalSec: (options) => typebox_1.Type.Unsafe(typebox_1.Type.Number(options)),
+    TimestampMs: (options) => typebox_1.Type.Unsafe(typebox_1.Type.Number(options)),
+    TimestampMsStr: typebox_1.Type.Unsafe(typebox_1.Type.RegExp(/^\d+$/)),
+    HexString0x: (options) => typebox_1.Type.Unsafe(typebox_1.Type.RegExp(/^0x[a-fA-F0-9]+$/, options)),
+    HexStringNo0x: (options) => typebox_1.Type.Unsafe(typebox_1.Type.RegExp(/^[a-fA-F0-9]+$/, options)),
+    UnknownFormat: typebox_1.Type.Unsafe(typebox_1.Type.String()),
+    Lowercase: forceLowercase(typebox_1.Type.String()),
+    TrueOrFalse: typebox_1.Type.Transform(typebox_1.Type.Union([typebox_1.Type.Literal("T"), typebox_1.Type.Literal("F")]))
+        .Decode((value) => value === "T")
+        .Encode((value) => (value ? "T" : "F")),
+    Nullable: (schema, options) => typebox_1.Type.Union([schema, typebox_1.Type.Null()], options),
+    SerializeObjAsJson: () => typebox_1.Type.Transform(typebox_1.Type.Unsafe(typebox_1.Type.Any()))
+        .Decode((x) => JSON.stringify(x))
+        .Encode((x) => JSON.parse(x)),
+    SerializeJsonAsObj: (schema) => typebox_1.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: typebox_1.Type.Unsafe(typebox_1.Type.Any()),
+};
+exports.AddressValidator = {
+    [AddressType.NONE]: typebox_1.Type.Literal("0x0"),
+    [AddressType.EVM]: exports.TypeboxHelpers.Evm.Address,
+    [AddressType.CARDANO]: exports.TypeboxHelpers.Cardano.Address,
+    [AddressType.SUBSTRATE]: exports.TypeboxHelpers.Substrate.Address,
+    [AddressType.AVAIL]: exports.TypeboxHelpers.Avail.Address,
+    [AddressType.ALGORAND]: exports.TypeboxHelpers.Algorand.Address,
+    [AddressType.MINA]: exports.TypeboxHelpers.Mina.Address,
+    [AddressType.MIDNIGHT]: exports.TypeboxHelpers.Midnight.Address,
+    [AddressType.POLKADOT]: exports.TypeboxHelpers.Polkadot.Address,
+};
+exports.AddressTypebox = [
+    typebox_1.Type.Object({
+        type: typebox_1.Type.Literal(AddressType.NONE),
+        address: typebox_1.Type.Literal("0x0"),
+    }),
+    typebox_1.Type.Object({
+        type: typebox_1.Type.Literal(AddressType.EVM),
+        address: exports.TypeboxHelpers.Evm.Address,
+    }),
+    typebox_1.Type.Object({
+        type: typebox_1.Type.Literal(AddressType.CARDANO),
+        address: exports.TypeboxHelpers.Cardano.Address,
+    }),
+    typebox_1.Type.Object({
+        type: typebox_1.Type.Literal(AddressType.SUBSTRATE),
+        address: exports.TypeboxHelpers.Substrate.Address,
+    }),
+    typebox_1.Type.Object({
+        type: typebox_1.Type.Literal(AddressType.AVAIL),
+        address: exports.TypeboxHelpers.Avail.Address,
+    }),
+    typebox_1.Type.Object({
+        type: typebox_1.Type.Literal(AddressType.ALGORAND),
+        address: exports.TypeboxHelpers.Algorand.Address,
+    }),
+    typebox_1.Type.Object({
+        type: typebox_1.Type.Literal(AddressType.MINA),
+        address: exports.TypeboxHelpers.Mina.Address,
+    }),
+    typebox_1.Type.Object({
+        type: typebox_1.Type.Literal(AddressType.MIDNIGHT),
+        address: exports.TypeboxHelpers.Midnight.Address,
+    }),
+    typebox_1.Type.Object({
+        type: typebox_1.Type.Literal(AddressType.POLKADOT),
+        address: exports.TypeboxHelpers.Polkadot.Address,
+    }),
+];
+true;
+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_1.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 !== value_1.ValueErrorType.Intersect &&
+            error.type !== value_1.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_1.Value.Decode(structure, config);
+    return decoded;
+}
+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
+ */
+function pickAll(keys) {
+    return {
+        from: (obj) => pick(keys).from(obj),
+    };
+}

package/script/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/script/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/script/utils/src/types/utils.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.narrowResult = narrowResult;
+exports.strip0x = strip0x;
+exports.add0x = add0x;
+exports.keysOf = keysOf;
+/**
+ * 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
+ */
+function narrowResult(result) {
+    return result;
+}
+function strip0x(str) {
+    if (str.startsWith("0x")) {
+        return str.substring(2);
+    }
+    return str;
+}
+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
+ */
+function keysOf(obj) {
+    return Object.keys(obj);
+}

package/script/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/script/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/script/utils/src/types/validators/algorand.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyAlgorandAddress = verifyAlgorandAddress;
+exports.verifyAlgorandBlockHash = verifyAlgorandBlockHash;
+exports.verifyAlgorandTransactionHash = verifyAlgorandTransactionHash;
+const hi_base32_1 = __importDefault(require("hi-base32"));
+const js_sha512_1 = __importDefault(require("js-sha512"));
+const js_base64_1 = require("js-base64");
+const utils_js_1 = require("./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 = (0, utils_js_1.MALFORMED_ERROR_MSG)("block hash");
+const MALFORMED_TX_ID_ERROR_MSG = (0, utils_js_1.MALFORMED_ERROR_MSG)("tx id");
+const MALFORMED_ADDRESS_ERROR_MSG = (0, utils_js_1.MALFORMED_ERROR_MSG)("address");
+const CHECKSUM_ADDRESS_ERROR_MSG = (0, utils_js_1.CHECKSUM_ERROR_MSG)("address");
+function checksumFromPublicKey(pk) {
+    return Uint8Array.from(js_sha512_1.default.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
+ */
+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 = hi_base32_1.default.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=
+ */
+function verifyAlgorandBlockHash(hash) {
+    // TODO: length check?
+    const decoded = js_base64_1.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
+ */
+function verifyAlgorandTransactionHash(hash) {
+    const decoded = hi_base32_1.default.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/script/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/script/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/script/utils/src/types/validators/cardano.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddressType = exports.InvalidArgumentError = void 0;
+exports.verifyCardanoByronAddress = verifyCardanoByronAddress;
+exports.verifyCardanoShelleyAddress = verifyCardanoShelleyAddress;
+const crc_1 = require("@foxglove/crc");
+const utils_js_1 = require("./utils.js");
+const minicbor_js_1 = require("./minicbor.js");
+const bs58_1 = __importDefault(require("bs58"));
+const bech32_1 = require("bech32");
+const node_buffer_1 = require("node:buffer");
+const CHECKSUM_ADDRESS_ERROR_MSG = (0, utils_js_1.CHECKSUM_ERROR_MSG)("address");
+exports.InvalidArgumentError = Error;
+/**
+ * Example address:
+ * - (mainnet icarus) Ae2tdPwUPEZFRbyhz3cpfC2CumGzNkFBN2L42rcUc2yjQpEkxDbkPodpMAi
+ * - (testnet byron) 37btjrVyb4KDXBNC4haBVPCrro8AQPHwvCMp3RFhhSVWwfFmZ6wwzSK6JK1hY6wHNmtrpTf1kdbva8TCneM2YsiXT7mrzT21EacHnPpz5YyUdj64na
+ * - (mainnet byron) 82d818584283581caf335162c1ecb0a5b95342e3d1d0c9c38a246fa976b077e81dea9d9ba101581e581c2d574aa85a82a80fd6d1c51ea115c2b03b68166230a3c383c9f89ad5001ac3de014e
+ */
+function verifyCardanoByronAddress(address) {
+    return verifyCardanoByronAddressBytes(bs58_1.default.decode(address));
+}
+function verifyCardanoByronAddressBytes(data) {
+    const reader = new minicbor_js_1.MiniCborReader(node_buffer_1.Buffer.from(data).toString("hex"));
+    reader.readStartArray();
+    reader.readTag();
+    const addressDataEncoded = reader.readByteString();
+    if (Number(reader.readInt()) !== (0, crc_1.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;
+}
+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 || (exports.AddressType = AddressType = {}));
+/**
+ * See: https://github.com/input-output-hk/cardano-js-sdk/blob/d1544fc9d1fb3997eb7c5b94a233789bb9e5cd9f/packages/core/src/Cardano/Address/Address.ts
+ */
+function verifyCardanoShelleyAddress(address) {
+    const bech32data = bech32_1.bech32.decode(address, Number.MAX_SAFE_INTEGER / 2);
+    const data = bech32_1.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 = node_buffer_1.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((0, utils_js_1.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 };
+};