@paimaexample/wallets 0.3.117

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

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyMinaAddress = verifyMinaAddress;
+exports.verifyMinaBlockHash = verifyMinaBlockHash;
+exports.verifyMinaTransactionHash = verifyMinaTransactionHash;
+const bs58check_1 = __importDefault(require("bs58check"));
+const utils_js_1 = require("./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 = (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");
+/**
+ * Example address: B62qpLST3UC1rpVT6SHfB7wqW2iQgiopFAGfrcovPgLjgfpDUN2LLeg
+ */
+function verifyMinaAddress(address) {
+    const decoded = bs58check_1.default.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
+ */
+function verifyMinaBlockHash(hash) {
+    const decoded = bs58check_1.default.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
+ */
+function verifyMinaTransactionHash(hash) {
+    const decoded = bs58check_1.default.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/script/utils/src/types/validators/minicbor.d.ts

@@ -0,0 +1,98 @@
+/**
+ * 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
+ */
+type HexBlob = string;
+export declare const CborContentException: ErrorConstructor;
+export declare const CborInvalidOperationException: ErrorConstructor;
+export declare enum CborReaderState {
+    Undefined = 0,
+    UnsignedInteger = 1,
+    NegativeInteger = 2,
+    ByteString = 3,
+    StartIndefiniteLengthByteString = 4,
+    EndIndefiniteLengthByteString = 5,
+    TextString = 6,
+    StartIndefiniteLengthTextString = 7,
+    EndIndefiniteLengthTextString = 8,
+    StartArray = 9,
+    EndArray = 10,
+    StartMap = 11,
+    EndMap = 12,
+    Tag = 13,
+    SimpleValue = 14,
+    HalfPrecisionFloat = 15,
+    SinglePrecisionFloat = 16,
+    DoublePrecisionFloat = 17,
+    Null = 18,
+    Boolean = 19,
+    Finished = 20
+}
+export declare enum CborMajorType {
+    UnsignedInteger = 0,
+    NegativeInteger = 1,
+    ByteString = 2,
+    Utf8String = 3,
+    Array = 4,
+    Map = 5,
+    Tag = 6,
+    Simple = 7
+}
+export declare 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 = 55799
+}
+export declare enum CborAdditionalInfo {
+    AdditionalFalse = 20,
+    AdditionalTrue = 21,
+    AdditionalNull = 22,
+    Additional8BitData = 24,
+    Additional16BitData = 25,
+    Additional32BitData = 26,
+    Additional64BitData = 27,
+    IndefiniteLength = 31
+}
+export declare class CborInitialByte {
+    private initialByte;
+    static readonly IndefiniteLengthBreakByte = 255;
+    static readonly AdditionalInformationMask = 31;
+    constructor(initialByte: number);
+    CborInitialByte(majorType: CborMajorType, additionalInfo: CborAdditionalInfo): void;
+    static from(initialByte: number): CborInitialByte;
+    getInitialByte(): number;
+    getMajorType(): CborMajorType;
+    getAdditionalInfo(): CborAdditionalInfo;
+}
+export declare class MiniCborReader {
+    #private;
+    constructor(data: HexBlob);
+    readStartArray(): number | null;
+    readTag(): CborTag;
+    readByteString(): Uint8Array;
+    readInt(): bigint;
+    static ensureReadCapacityInArray(data: Uint8Array, bytesToRead: number): void;
+}
+export {};
+//# sourceMappingURL=minicbor.d.ts.map

package/script/utils/src/types/validators/minicbor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minicbor.d.ts","sourceRoot":"","sources":["../../../../../src/utils/src/types/validators/minicbor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,KAAK,OAAO,GAAG,MAAM,CAAC;AAEtB,eAAO,MAAM,oBAAoB,kBAAQ,CAAC;AAC1C,eAAO,MAAM,6BAA6B,kBAAQ,CAAC;AAEnD,oBAAY,eAAe;IACzB,SAAS,IAAI;IACb,eAAe,IAAA;IACf,eAAe,IAAA;IACf,UAAU,IAAA;IACV,+BAA+B,IAAA;IAC/B,6BAA6B,IAAA;IAC7B,UAAU,IAAA;IACV,+BAA+B,IAAA;IAC/B,6BAA6B,IAAA;IAC7B,UAAU,IAAA;IACV,QAAQ,KAAA;IACR,QAAQ,KAAA;IACR,MAAM,KAAA;IACN,GAAG,KAAA;IACH,WAAW,KAAA;IACX,kBAAkB,KAAA;IAClB,oBAAoB,KAAA;IACpB,oBAAoB,KAAA;IACpB,IAAI,KAAA;IACJ,OAAO,KAAA;IACP,QAAQ,KAAA;CACT;AAED,oBAAY,aAAa;IACvB,eAAe,IAAI;IACnB,eAAe,IAAI;IACnB,UAAU,IAAI;IACd,UAAU,IAAI;IACd,KAAK,IAAI;IACT,GAAG,IAAI;IACP,GAAG,IAAI;IACP,MAAM,IAAI;CACX;AAUD,oBAAY,OAAO;IACjB,cAAc,IAAI;IAClB,eAAe,IAAI;IACnB,cAAc,IAAI;IAClB,cAAc,IAAI;IAClB,eAAe,IAAI;IACnB,QAAQ,IAAI;IACZ,sBAAsB,KAAK;IAC3B,yBAAyB,KAAK;IAC9B,yBAAyB,KAAK;IAC9B,mBAAmB,KAAK;IACxB,cAAc,KAAK;IACnB,GAAG,KAAK;IACR,SAAS,KAAK;IACd,MAAM,KAAK;IACX,KAAK,KAAK;IACV,WAAW,KAAK;IAChB,GAAG,MAAM;IACT,gBAAgB,QAAS;CAC1B;AAID,oBAAY,kBAAkB;IAC5B,eAAe,KAAK;IACpB,cAAc,KAAK;IACnB,cAAc,KAAK;IACnB,kBAAkB,KAAK;IACvB,mBAAmB,KAAK;IACxB,mBAAmB,KAAK;IACxB,mBAAmB,KAAK;IACxB,gBAAgB,KAAK;CACtB;AAED,qBAAa,eAAe;IAId,OAAO,CAAC,WAAW;IAH/B,MAAM,CAAC,QAAQ,CAAC,yBAAyB,OAAQ;IACjD,MAAM,CAAC,QAAQ,CAAC,yBAAyB,MAAe;gBAEpC,WAAW,EAAE,MAAM;IACvC,eAAe,CACb,SAAS,EAAE,aAAa,EACxB,cAAc,EAAE,kBAAkB;IAIpC,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,MAAM;IAK/B,cAAc,IAAI,MAAM;IAGxB,YAAY,IAAI,aAAa;IAG7B,iBAAiB,IAAI,kBAAkB;CAGxC;AAED,qBAAa,cAAc;;gBAQb,IAAI,EAAE,OAAO;IAUzB,cAAc,IAAI,MAAM,GAAG,IAAI;IAoB/B,OAAO,IAAI,OAAO;IAQlB,cAAc,IAAI,UAAU;IA4B5B,OAAO,IAAI,MAAM;IA2OjB,MAAM,CAAC,yBAAyB,CAAC,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM;CAoCvE"}

package/script/utils/src/types/validators/minicbor.js

@@ -0,0 +1,337 @@
+"use strict";
+/**
+ * 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
+ */
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MiniCborReader = exports.CborInitialByte = exports.CborAdditionalInfo = exports.CborTag = exports.CborMajorType = exports.CborReaderState = exports.CborInvalidOperationException = exports.CborContentException = void 0;
+const node_buffer_1 = require("node:buffer");
+exports.CborContentException = Error;
+exports.CborInvalidOperationException = Error;
+var CborReaderState;
+(function (CborReaderState) {
+    CborReaderState[CborReaderState["Undefined"] = 0] = "Undefined";
+    CborReaderState[CborReaderState["UnsignedInteger"] = 1] = "UnsignedInteger";
+    CborReaderState[CborReaderState["NegativeInteger"] = 2] = "NegativeInteger";
+    CborReaderState[CborReaderState["ByteString"] = 3] = "ByteString";
+    CborReaderState[CborReaderState["StartIndefiniteLengthByteString"] = 4] = "StartIndefiniteLengthByteString";
+    CborReaderState[CborReaderState["EndIndefiniteLengthByteString"] = 5] = "EndIndefiniteLengthByteString";
+    CborReaderState[CborReaderState["TextString"] = 6] = "TextString";
+    CborReaderState[CborReaderState["StartIndefiniteLengthTextString"] = 7] = "StartIndefiniteLengthTextString";
+    CborReaderState[CborReaderState["EndIndefiniteLengthTextString"] = 8] = "EndIndefiniteLengthTextString";
+    CborReaderState[CborReaderState["StartArray"] = 9] = "StartArray";
+    CborReaderState[CborReaderState["EndArray"] = 10] = "EndArray";
+    CborReaderState[CborReaderState["StartMap"] = 11] = "StartMap";
+    CborReaderState[CborReaderState["EndMap"] = 12] = "EndMap";
+    CborReaderState[CborReaderState["Tag"] = 13] = "Tag";
+    CborReaderState[CborReaderState["SimpleValue"] = 14] = "SimpleValue";
+    CborReaderState[CborReaderState["HalfPrecisionFloat"] = 15] = "HalfPrecisionFloat";
+    CborReaderState[CborReaderState["SinglePrecisionFloat"] = 16] = "SinglePrecisionFloat";
+    CborReaderState[CborReaderState["DoublePrecisionFloat"] = 17] = "DoublePrecisionFloat";
+    CborReaderState[CborReaderState["Null"] = 18] = "Null";
+    CborReaderState[CborReaderState["Boolean"] = 19] = "Boolean";
+    CborReaderState[CborReaderState["Finished"] = 20] = "Finished";
+})(CborReaderState || (exports.CborReaderState = CborReaderState = {}));
+var CborMajorType;
+(function (CborMajorType) {
+    CborMajorType[CborMajorType["UnsignedInteger"] = 0] = "UnsignedInteger";
+    CborMajorType[CborMajorType["NegativeInteger"] = 1] = "NegativeInteger";
+    CborMajorType[CborMajorType["ByteString"] = 2] = "ByteString";
+    CborMajorType[CborMajorType["Utf8String"] = 3] = "Utf8String";
+    CborMajorType[CborMajorType["Array"] = 4] = "Array";
+    CborMajorType[CborMajorType["Map"] = 5] = "Map";
+    CborMajorType[CborMajorType["Tag"] = 6] = "Tag";
+    CborMajorType[CborMajorType["Simple"] = 7] = "Simple";
+})(CborMajorType || (exports.CborMajorType = CborMajorType = {}));
+var CborTag;
+(function (CborTag) {
+    CborTag[CborTag["DateTimeString"] = 0] = "DateTimeString";
+    CborTag[CborTag["UnixTimeSeconds"] = 1] = "UnixTimeSeconds";
+    CborTag[CborTag["UnsignedBigNum"] = 2] = "UnsignedBigNum";
+    CborTag[CborTag["NegativeBigNum"] = 3] = "NegativeBigNum";
+    CborTag[CborTag["DecimalFraction"] = 4] = "DecimalFraction";
+    CborTag[CborTag["BigFloat"] = 5] = "BigFloat";
+    CborTag[CborTag["Base64UrlLaterEncoding"] = 21] = "Base64UrlLaterEncoding";
+    CborTag[CborTag["Base64StringLaterEncoding"] = 22] = "Base64StringLaterEncoding";
+    CborTag[CborTag["Base16StringLaterEncoding"] = 23] = "Base16StringLaterEncoding";
+    CborTag[CborTag["EncodedCborDataItem"] = 24] = "EncodedCborDataItem";
+    CborTag[CborTag["RationalNumber"] = 30] = "RationalNumber";
+    CborTag[CborTag["Uri"] = 32] = "Uri";
+    CborTag[CborTag["Base64Url"] = 33] = "Base64Url";
+    CborTag[CborTag["Base64"] = 34] = "Base64";
+    CborTag[CborTag["Regex"] = 35] = "Regex";
+    CborTag[CborTag["MimeMessage"] = 36] = "MimeMessage";
+    CborTag[CborTag["Set"] = 258] = "Set";
+    CborTag[CborTag["SelfDescribeCbor"] = 55799] = "SelfDescribeCbor";
+})(CborTag || (exports.CborTag = CborTag = {}));
+const UNEXPECTED_END_OF_BUFFER_MSG = "Unexpected end of buffer";
+var CborAdditionalInfo;
+(function (CborAdditionalInfo) {
+    CborAdditionalInfo[CborAdditionalInfo["AdditionalFalse"] = 20] = "AdditionalFalse";
+    CborAdditionalInfo[CborAdditionalInfo["AdditionalTrue"] = 21] = "AdditionalTrue";
+    CborAdditionalInfo[CborAdditionalInfo["AdditionalNull"] = 22] = "AdditionalNull";
+    CborAdditionalInfo[CborAdditionalInfo["Additional8BitData"] = 24] = "Additional8BitData";
+    CborAdditionalInfo[CborAdditionalInfo["Additional16BitData"] = 25] = "Additional16BitData";
+    CborAdditionalInfo[CborAdditionalInfo["Additional32BitData"] = 26] = "Additional32BitData";
+    CborAdditionalInfo[CborAdditionalInfo["Additional64BitData"] = 27] = "Additional64BitData";
+    CborAdditionalInfo[CborAdditionalInfo["IndefiniteLength"] = 31] = "IndefiniteLength";
+})(CborAdditionalInfo || (exports.CborAdditionalInfo = CborAdditionalInfo = {}));
+class CborInitialByte {
+    initialByte;
+    static IndefiniteLengthBreakByte = 0xff;
+    static AdditionalInformationMask = 0b0001_1111;
+    constructor(initialByte) {
+        this.initialByte = initialByte;
+    }
+    CborInitialByte(majorType, additionalInfo) {
+        this.initialByte = (majorType << 5) | additionalInfo;
+    }
+    static from(initialByte) {
+        const init = new CborInitialByte(initialByte);
+        return init;
+    }
+    getInitialByte() {
+        return this.initialByte;
+    }
+    getMajorType() {
+        return this.initialByte >> 5;
+    }
+    getAdditionalInfo() {
+        return this.initialByte & CborInitialByte.AdditionalInformationMask;
+    }
+}
+exports.CborInitialByte = CborInitialByte;
+class MiniCborReader {
+    #data;
+    #offset = 0;
+    #nestedItems = new Array();
+    #isTagContext = false;
+    #currentFrame;
+    #cachedState = CborReaderState.Undefined;
+    constructor(data) {
+        this.#data = new Uint8Array(node_buffer_1.Buffer.from(data, "hex"));
+        this.#currentFrame = {
+            currentKeyOffset: null,
+            frameOffset: 0,
+            itemsRead: 0,
+            type: null,
+        };
+    }
+    readStartArray() {
+        const header = 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 } = _a.#peekDefiniteLength(header, buffer);
+        this.#advanceBuffer(bytesRead);
+        this.#pushDataItem(CborMajorType.Array, length);
+        return length;
+    }
+    readTag() {
+        const { tag, bytesRead } = this.#peekTagCore();
+        this.#advanceBuffer(bytesRead);
+        this.#isTagContext = true;
+        return tag;
+    }
+    readByteString() {
+        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 } = _a.#peekDefiniteLength(header, buffer);
+        this.#ensureReadCapacity(bytesRead + length);
+        this.#advanceBuffer(bytesRead + length);
+        this.#advanceDataItemCounters();
+        return buffer.slice(bytesRead, bytesRead + length);
+    }
+    readInt() {
+        const value = this.#peekSignedInteger();
+        this.#advanceBuffer(value.bytesRead);
+        this.#advanceDataItemCounters();
+        return value.signedInt;
+    }
+    #peekSignedInteger() {
+        const header = this.#peekInitialByte();
+        switch (header.getMajorType()) {
+            case CborMajorType.UnsignedInteger: {
+                const { unsignedInt: signedInt, bytesRead } = _a
+                    .#decodeUnsignedInteger(header, this.#getRemainingBytes());
+                return { bytesRead, signedInt: BigInt(signedInt) };
+            }
+            case CborMajorType.NegativeInteger: {
+                const { unsignedInt, bytesRead } = _a
+                    .#decodeUnsignedInteger(header, this.#getRemainingBytes());
+                return { bytesRead, signedInt: BigInt(-1) - unsignedInt };
+            }
+            default:
+                throw new exports.CborInvalidOperationException(`Reader type mismatch, expected ${CborMajorType.UnsignedInteger} or ${CborMajorType.NegativeInteger} but got ${header.getMajorType()}`);
+        }
+    }
+    #ensureReadCapacity(bytesToRead) {
+        if (this.#data.length - this.#offset < bytesToRead) {
+            throw new exports.CborContentException(UNEXPECTED_END_OF_BUFFER_MSG);
+        }
+    }
+    #readIndefiniteLengthByteStringConcatenated(type) {
+        const data = this.#getRemainingBytes();
+        let concat = node_buffer_1.Buffer.from([]);
+        let encodingLength = 0;
+        let i = 1; // skip the indefinite-length initial byte
+        let nextInitialByte = _a.#peekNextInitialByte(data.slice(i), type);
+        while (nextInitialByte.getInitialByte() !==
+            CborInitialByte.IndefiniteLengthBreakByte) {
+            const { length: chunkLength, bytesRead } = _a
+                .#peekDefiniteLength(nextInitialByte, data.slice(i));
+            const payloadSize = bytesRead + Number(chunkLength);
+            concat = node_buffer_1.Buffer.concat([
+                concat, // TODO: remove `as any` once @types/node gets updated properly
+                data.slice(i + (payloadSize - chunkLength), i + payloadSize),
+            ]);
+            i += payloadSize;
+            nextInitialByte = _a.#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, expectedType) {
+        _a.ensureReadCapacityInArray(buffer, 1);
+        const header = CborInitialByte.from(buffer[0]);
+        if (header.getInitialByte() !== CborInitialByte.IndefiniteLengthBreakByte &&
+            header.getMajorType() !== expectedType) {
+            throw new exports.CborContentException("Indefinite length string contains invalid data item");
+        }
+        return header;
+    }
+    #peekTagCore() {
+        const header = this.#peekInitialByte(CborMajorType.Tag);
+        const { unsignedInt: result, bytesRead } = _a
+            .#decodeUnsignedInteger(header, this.#getRemainingBytes());
+        return { bytesRead, tag: Number(result) };
+    }
+    static #peekDefiniteLength(header, data) {
+        const { unsignedInt: length, bytesRead } = _a
+            .#decodeUnsignedInteger(header, data);
+        return { bytesRead, length: Number(length) };
+    }
+    #peekInitialByte(expectedType) {
+        if (this.#currentFrame.definiteLength !== undefined &&
+            this.#currentFrame.definiteLength - this.#currentFrame.itemsRead === 0) {
+            throw new exports.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 exports.CborInvalidOperationException("End of root-level. No more data items to read");
+            }
+            throw new exports.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 exports.CborContentException(`Indefinite length string contains invalid data item, ${nextByte.getMajorType()}`);
+        }
+        if (expectedType && expectedType !== nextByte.getMajorType()) {
+            throw new exports.CborInvalidOperationException(`Major type mismatch, expected type ${expectedType} but got ${nextByte.getMajorType()}`);
+        }
+        return nextByte;
+    }
+    static #decodeUnsignedInteger(header, data) {
+        if ((header.getInitialByte() & CborInitialByte.AdditionalInformationMask) <
+            CborAdditionalInfo.Additional8BitData) {
+            return { bytesRead: 1, unsignedInt: BigInt(header.getAdditionalInfo()) };
+        }
+        switch (header.getAdditionalInfo()) {
+            case CborAdditionalInfo.Additional8BitData: {
+                _a.ensureReadCapacityInArray(data, 2);
+                return { bytesRead: 2, unsignedInt: BigInt(data[1]) };
+            }
+            case CborAdditionalInfo.Additional16BitData: {
+                _a.ensureReadCapacityInArray(data, 3);
+                const buffer = node_buffer_1.Buffer.from(data.slice(1));
+                const val = buffer.readUInt16BE();
+                return { bytesRead: 3, unsignedInt: BigInt(val) };
+            }
+            case CborAdditionalInfo.Additional32BitData: {
+                _a.ensureReadCapacityInArray(data, 5);
+                const buffer = node_buffer_1.Buffer.from(data.slice(1));
+                const val = buffer.readUInt32BE();
+                return { bytesRead: 5, unsignedInt: BigInt(val) };
+            }
+            case CborAdditionalInfo.Additional64BitData: {
+                _a.ensureReadCapacityInArray(data, 9);
+                const buffer = node_buffer_1.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 exports.CborContentException("Invalid integer encoding");
+        }
+    }
+    static ensureReadCapacityInArray(data, bytesToRead) {
+        if (data.length < bytesToRead) {
+            throw new exports.CborContentException(UNEXPECTED_END_OF_BUFFER_MSG);
+        }
+    }
+    #advanceBuffer(length) {
+        if (this.#offset + length > this.#data.length) {
+            throw new exports.CborContentException("Buffer offset out of bounds");
+        }
+        this.#offset += length;
+        this.#cachedState = CborReaderState.Undefined;
+    }
+    #pushDataItem(majorType, definiteLength) {
+        const frame = {
+            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() {
+        return this.#data.slice(this.#offset);
+    }
+}
+exports.MiniCborReader = MiniCborReader;
+_a = MiniCborReader;

package/script/utils/src/types/validators/mod.d.ts

@@ -0,0 +1,3 @@
+export * from "./algorand.js";
+export * from "./utils.js";
+//# sourceMappingURL=mod.d.ts.map

package/script/utils/src/types/validators/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../src/utils/src/types/validators/mod.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC"}

package/script/utils/src/types/validators/mod.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./algorand.js"), exports);
+__exportStar(require("./utils.js"), exports);

package/script/utils/src/types/validators/utils.d.ts

@@ -0,0 +1,6 @@
+import type { HexStringNo0x, UnknownFormat } from "../nominal.js";
+export declare function hexStringToUint8Array(hexString: UnknownFormat): Uint8Array;
+export declare function uint8ArrayToHexString(uint8Array: Uint8Array): HexStringNo0x;
+export declare const MALFORMED_ERROR_MSG: (str: string) => string;
+export declare const CHECKSUM_ERROR_MSG: (str: string) => string;
+//# sourceMappingURL=utils.d.ts.map

package/script/utils/src/types/validators/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/utils/src/types/validators/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAiBlE,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,aAAa,GAAG,UAAU,CAE1E;AAED,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,UAAU,GAAG,aAAa,CAO3E;AAED,eAAO,MAAM,mBAAmB,GAAI,KAAK,MAAM,KAAG,MAC3B,CAAC;AACxB,eAAO,MAAM,kBAAkB,GAAI,KAAK,MAAM,KAAG,MACrB,CAAC"}

package/script/utils/src/types/validators/utils.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHECKSUM_ERROR_MSG = exports.MALFORMED_ERROR_MSG = void 0;
+exports.hexStringToUint8Array = hexStringToUint8Array;
+exports.uint8ArrayToHexString = uint8ArrayToHexString;
+function hexStringToBytes(hexString) {
+    if (!/^[0-9a-fA-F]+$/.test(hexString)) {
+        throw new Error("Non-hex digits found in hex string");
+    }
+    const bytes = [];
+    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;
+}
+function hexStringToUint8Array(hexString) {
+    return new Uint8Array(hexStringToBytes(hexString));
+}
+function uint8ArrayToHexString(uint8Array) {
+    // 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("");
+}
+const MALFORMED_ERROR_MSG = (str) => `${str} is malformed`;
+exports.MALFORMED_ERROR_MSG = MALFORMED_ERROR_MSG;
+const CHECKSUM_ERROR_MSG = (str) => `${str} checksum is wrong`;
+exports.CHECKSUM_ERROR_MSG = CHECKSUM_ERROR_MSG;

package/script/utils/src/viem.d.ts

@@ -0,0 +1,6 @@
+import type { Account, Address, HttpTransport, ParseAccount, PublicClient, PublicClientConfig, RpcSchema, Transport } from "viem";
+import { type Chain } from "viem";
+import type { Evm4ByteSelector, EvmSelector } from "./types/nominal.js";
+export declare function truncateSelector(fullSelector: EvmSelector): Evm4ByteSelector;
+export declare function createViemPublicClient<chain extends Chain, transport extends Transport = HttpTransport, accountOrAddress extends Account | Address | undefined = undefined, rpcSchema extends RpcSchema | undefined = undefined>(chain: chain, override?: Partial<Omit<PublicClientConfig<transport, chain, accountOrAddress, rpcSchema>, "chain">>): PublicClient<transport, chain, ParseAccount<accountOrAddress>, rpcSchema>;
+//# sourceMappingURL=viem.d.ts.map

package/script/utils/src/viem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viem.d.ts","sourceRoot":"","sources":["../../../src/utils/src/viem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,OAAO,EACP,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,kBAAkB,EAClB,SAAS,EACT,SAAS,EACV,MAAM,MAAM,CAAC;AACd,OAAO,EAAE,KAAK,KAAK,EAA4B,MAAM,MAAM,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAExE,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,WAAW,GAAG,gBAAgB,CAE5E;AAED,wBAAgB,sBAAsB,CACpC,KAAK,SAAS,KAAK,EACnB,SAAS,SAAS,SAAS,GAAG,aAAa,EAC3C,gBAAgB,SAAS,OAAO,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,EAClE,SAAS,SAAS,SAAS,GAAG,SAAS,GAAG,SAAS,EAEnD,KAAK,EAAE,KAAK,EACZ,QAAQ,CAAC,EAAE,OAAO,CAChB,IAAI,CACF,kBAAkB,CAAC,SAAS,EAAE,KAAK,EAAE,gBAAgB,EAAE,SAAS,CAAC,EACjE,OAAO,CACR,CACF,GACA,YAAY,CAAC,SAAS,EAAE,KAAK,EAAE,YAAY,CAAC,gBAAgB,CAAC,EAAE,SAAS,CAAC,CAU3E"}

package/script/utils/src/viem.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truncateSelector = truncateSelector;
+exports.createViemPublicClient = createViemPublicClient;
+const viem_1 = require("viem");
+function truncateSelector(fullSelector) {
+    return fullSelector.slice(0, 10);
+}
+function createViemPublicClient(chain, override) {
+    return (0, viem_1.createPublicClient)({
+        chain,
+        transport: (0, viem_1.http)(chain.rpcUrls.default.http[0], {
+            // batch is needed for sync protocols to be efficient. Does this ever cause issues in other scenarios?
+            batch: true,
+            // TODO: transport options should come from the sync protocol configuration
+        }),
+        ...override,
+    });
+}

package/script/wallets/src/IProvider.d.ts

@@ -0,0 +1,48 @@
+import { AddressType } from "../../utils/src/mod.js";
+export type WalletOption = {
+    name: string;
+    displayName: string;
+    /**
+     * URI-encoded image
+     * DANGER: SVGs can contain Javascript, so these should only be rendered with <img> tags
+     *
+     * Note: not every wallet type has an image (ex: locally generated keypairs)
+     * Example values:
+     * data:image/svg+xml,...
+     * data:image/png;base64,...
+     */
+    icon?: undefined | string;
+};
+export type ActiveConnection<T> = {
+    metadata: WalletOption;
+    api: T;
+};
+export type ConnectionOption<T> = {
+    metadata: WalletOption;
+    api: () => Promise<T>;
+};
+export declare function optionToActive<T>(option: ConnectionOption<T>): Promise<ActiveConnection<T>>;
+export interface IConnector<T> {
+    getProvider(): undefined | IProvider<T>;
+    getOrThrowProvider(): IProvider<T>;
+    isConnected(): boolean;
+}
+export interface IInjectedConnector<T> {
+    /** connect while letting Paima pick all the connection logic for you */
+    connectSimple(): Promise<IProvider<T>>;
+    /** connect to an explicit API that Paima supports */
+    connectNamed(name: string): Promise<IProvider<T>>;
+    /** connect to an API that you've initialized yourself externally */
+    connectExternal(conn: ActiveConnection<T>): Promise<IProvider<T>>;
+}
+export type AddressAndType = {
+    type: AddressType;
+    address: string;
+};
+export type UserSignature = string;
+export interface IProvider<T> {
+    getConnection(): ActiveConnection<T>;
+    signMessage(message: string): Promise<UserSignature>;
+    getAddress(): AddressAndType;
+}
+//# sourceMappingURL=IProvider.d.ts.map