@hiero-ledger/sdk 2.70.0

package/lib/util/ASN1-Decoder.d.ts

@@ -0,0 +1,104 @@
+/**
+ * A class to decode ASN.1 encoded data, typically used for parsing cryptographic key data.
+ * @class
+ */
+export class ASN1Decoder {
+    /**
+     * Creates a new ASN1Decoder instance.
+     * @param {Uint8Array|ArrayBuffer} data - The ASN.1 encoded data to decode.
+     */
+    constructor(data: Uint8Array | ArrayBuffer);
+    /**
+     * @private
+     * @type {Uint8Array}
+     */
+    private data;
+    /**
+     * @private
+     * @type {number}
+     */
+    private pos;
+    /**
+     * @private
+     * @type {string[]}
+     */
+    private oids;
+    /**
+     * @private
+     * @type {{[key: string]: string}}
+     */
+    private oidMap;
+    /**
+     * @private
+     * @type {boolean}
+     */
+    private isPublicKey;
+    /**
+     * Reads the length field from the ASN.1 data.
+     * @private
+     * @returns {number} The length value.
+     */
+    private readLength;
+    /**
+     * Reads the type field from the ASN.1 data.
+     * @private
+     * @returns {number} The type value.
+     */
+    private readType;
+    /**
+     * Reads an integer value from the ASN.1 data.
+     * @private
+     * @returns {{integer: number}} Object containing the integer value.
+     */
+    private readInteger;
+    /**
+     * Reads an octet string from the ASN.1 data.
+     * @private
+     * @returns {{pkey: Uint8Array}} Object containing the private key data.
+     */
+    private readOctetString;
+    /**
+     * Reads a bit string from the ASN.1 data.
+     * @private
+     * @returns {{unusedBits: number, pubkey: Uint8Array}} Object containing the public key data and unused bits.
+     */
+    private readBitString;
+    /**
+     * Reads an object identifier from the ASN.1 data.
+     * @private
+     * @returns {{oid: string}} Object containing the OID as a string.
+     */
+    private readObjectIdentifier;
+    /**
+     * Gets the list of object identifiers found during decoding.
+     * @returns {string[]} Array of OID strings.
+     */
+    getOids(): string[];
+    /**
+     * Gets the key types corresponding to the OIDs found during decoding.
+     * @returns {string[]} Array of key type strings.
+     */
+    getOidKeyTypes(): string[];
+    /**
+     * Reads a sequence from the ASN.1 data.
+     * @private
+     * @returns {Array<any>} Array of decoded items in the sequence.
+     */
+    private readSequence;
+    /**
+     * Reads and decodes the next ASN.1 element.
+     * @returns {any} The decoded ASN.1 element.
+     * @throws {Error} If an unsupported type is encountered.
+     */
+    read(): any;
+    /**
+     * Checks if the decoded key is a public key.
+     * @returns {boolean} True if the key is a public key, false otherwise.
+     */
+    isPublicKeyType(): boolean;
+}
+export function asn1DecodeStringDer(keyString: string): {
+    keyTypes: string[];
+    isPublicKey: boolean;
+    isKeyListHex: boolean;
+};

package/lib/util/ASN1-Decoder.js

@@ -0,0 +1,2 @@
+import"@hashgraph/proto";class t{constructor(t){this.data=new Uint8Array(t),this.pos=0,this.oids=[],this.oidMap={"1.3.132.0.10":"ecdsa","1.3.101.112":"ed25519","1.2.840.10045.2.1":"pubkey"},this.isPublicKey=!1}readLength(){let t=this.data[this.pos++];if(128&t){let s=127&t;t=0;for(let e=0;e<s;e++)t=t<<8|this.data[this.pos++]}return t}readType(){return this.data[this.pos++]}readInteger(){const t=this.readLength();let s=0;for(let e=0;e<t;e++)s=s<<8|this.data[this.pos++];return{integer:s}}readOctetString(){const t=this.readLength(),s=this.data.slice(this.pos,this.pos+t);return this.pos+=t,{pkey:s}}readBitString(){const t=this.readLength(),s=this.data[this.pos++],e=this.data.slice(this.pos,this.pos+t-1);return this.pos+=t-1,{unusedBits:s,pubkey:e}}readObjectIdentifier(){const t=this.readLength(),s=this.pos+t,e=[];let i=0;const r=this.data[this.pos++];for(e.push(Math.floor(r/40)),e.push(r%40);this.pos<s;){const t=this.data[this.pos++];i=i<<7|127&t,128&t||(e.push(i),i=0)}const h=e.join(".");return this.oids.push(h),{oid:h}}getOids(){return this.oids}getOidKeyTypes(){return this.oids.map((t=>this.oidMap[t]||"unknown"))}readSequence(){const t=this.readLength(),s=this.pos+t,e=[];for(;this.pos<s;)e.push(this.read());return e}read(){const t=this.readType();switch(t){case 2:return this.readInteger();case 3:return this.readBitString();case 4:return this.readOctetString();case 6:return this.readObjectIdentifier();case 48:case 160:case 161:return this.readSequence();default:throw new Error(`Unsupported type: ${t}`)}}isPublicKeyType(){return this.isPublicKey}}export{t as ASN1Decoder};
+//# sourceMappingURL=ASN1-Decoder.js.map

package/lib/util/ASN1-Decoder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ASN1-Decoder.js","sources":["../../src/util/ASN1-Decoder.js"],"sourcesContent":["import { proto } from \"@hashgraph/proto\";\n/* eslint-disable @typescript-eslint/no-unsafe-return */\n/**\n * A class to decode ASN.1 encoded data, typically used for parsing cryptographic key data.\n * @class\n */\nexport class ASN1Decoder {\n    /**\n     * Creates a new ASN1Decoder instance.\n     * @param {Uint8Array|ArrayBuffer} data - The ASN.1 encoded data to decode.\n     */\n    constructor(data) {\n        /**\n         * @private\n         * @type {Uint8Array}\n         */\n        this.data = new Uint8Array(data);\n\n        /**\n         * @private\n         * @type {number}\n         */\n        this.pos = 0;\n\n        /**\n         * @private\n         * @type {string[]}\n         */\n        this.oids = [];\n\n        /**\n         * @private\n         * @type {{[key: string]: string}}\n         */\n        this.oidMap = {\n            \"1.3.132.0.10\": \"ecdsa\",\n            \"1.3.101.112\": \"ed25519\",\n            \"1.2.840.10045.2.1\": \"pubkey\",\n        };\n\n        /**\n         * @private\n         * @type {boolean}\n         */\n        this.isPublicKey = false;\n    }\n\n    /**\n     * Reads the length field from the ASN.1 data.\n     * @private\n     * @returns {number} The length value.\n     */\n    readLength() {\n        let length = this.data[this.pos++];\n        if (length & 0x80) {\n            let numBytes = length & 0x7f;\n            length = 0;\n            for (let i = 0; i < numBytes; i++) {\n                length = (length << 8) | this.data[this.pos++];\n            }\n        }\n        return length;\n    }\n\n    /**\n     * Reads the type field from the ASN.1 data.\n     * @private\n     * @returns {number} The type value.\n     */\n    readType() {\n        return this.data[this.pos++];\n    }\n\n    /**\n     * Reads an integer value from the ASN.1 data.\n     * @private\n     * @returns {{integer: number}} Object containing the integer value.\n     */\n    readInteger() {\n        const length = this.readLength();\n        let value = 0;\n        for (let i = 0; i < length; i++) {\n            value = (value << 8) | this.data[this.pos++];\n        }\n        return { integer: value };\n    }\n\n    /**\n     * Reads an octet string from the ASN.1 data.\n     * @private\n     * @returns {{pkey: Uint8Array}} Object containing the private key data.\n     */\n    readOctetString() {\n        const length = this.readLength();\n        const value = this.data.slice(this.pos, this.pos + length);\n        this.pos += length;\n        return { pkey: value };\n    }\n\n    /**\n     * Reads a bit string from the ASN.1 data.\n     * @private\n     * @returns {{unusedBits: number, pubkey: Uint8Array}} Object containing the public key data and unused bits.\n     */\n    readBitString() {\n        const length = this.readLength();\n        const unusedBits = this.data[this.pos++]; // First byte indicates the number of unused bits\n        const value = this.data.slice(this.pos, this.pos + length - 1);\n        this.pos += length - 1;\n        return { unusedBits, pubkey: value };\n    }\n\n    /**\n     * Reads an object identifier from the ASN.1 data.\n     * @private\n     * @returns {{oid: string}} Object containing the OID as a string.\n     */\n    readObjectIdentifier() {\n        const length = this.readLength();\n        const endPos = this.pos + length;\n        const oid = [];\n        let value = 0;\n\n        // The first byte contains the first two components\n        const firstByte = this.data[this.pos++];\n        oid.push(Math.floor(firstByte / 40));\n        oid.push(firstByte % 40);\n\n        while (this.pos < endPos) {\n            const byte = this.data[this.pos++];\n            value = (value << 7) | (byte & 0x7f);\n            if (!(byte & 0x80)) {\n                oid.push(value);\n                value = 0;\n            }\n        }\n\n        const oidStr = oid.join(\".\");\n        this.oids.push(oidStr);\n        return { oid: oidStr }; // Return OID as a string\n    }\n\n    /**\n     * Gets the list of object identifiers found during decoding.\n     * @returns {string[]} Array of OID strings.\n     */\n    getOids() {\n        return this.oids;\n    }\n\n    /**\n     * Gets the key types corresponding to the OIDs found during decoding.\n     * @returns {string[]} Array of key type strings.\n     */\n    getOidKeyTypes() {\n        return this.oids.map((oid) => this.oidMap[oid] || \"unknown\");\n    }\n\n    /**\n     * Reads a sequence from the ASN.1 data.\n     * @private\n     * @returns {Array<any>} Array of decoded items in the sequence.\n     */\n    readSequence() {\n        const length = this.readLength();\n        const endPos = this.pos + length;\n        const items = []; // this would better be map or obj\n        while (this.pos < endPos) {\n            items.push(this.read());\n        }\n\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return items;\n    }\n\n    /**\n     * Reads and decodes the next ASN.1 element.\n     * @returns {any} The decoded ASN.1 element.\n     * @throws {Error} If an unsupported type is encountered.\n     */\n    read() {\n        const type = this.readType();\n\n        switch (type) {\n            case 0x02: // INTEGER\n                return this.readInteger();\n            case 0x03: // BIT STRING FOR PUBKEY\n                return this.readBitString();\n            case 0x04: // OCTET STRING FOR PKEY\n                return this.readOctetString();\n            case 0x06: // OBJECT IDENTIFIER FOR CURVE TYPE\n                return this.readObjectIdentifier();\n            case 0x30: // SEQUENCE\n                return this.readSequence();\n            case 0xa0: // NODE TAG COULD BE TREATED AS SEQUENCE\n                return this.readSequence();\n            case 0xa1: // NODE TAG COULD BE TREATED AS SEQUENCE\n                return this.readSequence();\n            default:\n                throw new Error(`Unsupported type: ${type}`);\n        }\n    }\n\n    /**\n     * Checks if the decoded key is a public key.\n     * @returns {boolean} True if the key is a public key, false otherwise.\n     */\n    isPublicKeyType() {\n        return this.isPublicKey;\n    }\n}\n\n/**\n * Processes a hexadecimal string representation of an ASN.1 encoded key.\n * Checks if the input is a list of keys in hexadecimal format. If not, it decodes\n * the ASN.1 data to extract key types and identify if the key is a public key.\n *\n * @param {string} keyString - The hexadecimal string representation of the ASN.1 encoded key.\n * @returns {{keyTypes: string[], isPublicKey: boolean, isKeyListHex: boolean}} Object containing information about the decoded key.\n */\nexport const asn1DecodeStringDer = (keyString) => {\n    const isKeyListHex = isHexKeyList(keyString);\n\n    if (isKeyListHex) {\n        return { keyTypes: [], isPublicKey: false, isKeyListHex };\n    }\n\n    const signerData = Uint8Array.from(Buffer.from(keyString, \"hex\"));\n    const decoder = new ASN1Decoder(signerData);\n\n    decoder.read();\n    const keyTypes = decoder.getOidKeyTypes();\n    const isPublicKey = decoder.isPublicKeyType();\n\n    return {\n        keyTypes,\n        isPublicKey,\n        isKeyListHex: false,\n    };\n};\n\n/**\n * Checks if the input is a list of keys in hexadecimal format.\n * @param {string} hexString - The hexadecimal string representation of the ASN.1 encoded key.\n * @returns {boolean} True if the key is a public key, false otherwise.\n */\nconst isHexKeyList = (hexString) => {\n    try {\n        const binaryData = Buffer.from(hexString, \"hex\");\n        const decodedData = proto.KeyList.decode(binaryData);\n\n        return !!decodedData.keys && Array.isArray(decodedData.keys);\n    } catch (error) {\n        return false;\n    }\n};\n"],"names":["ASN1Decoder","constructor","data","this","Uint8Array","pos","oids","oidMap","isPublicKey","readLength","length","numBytes","i","readType","readInteger","value","integer","readOctetString","slice","pkey","readBitString","unusedBits","pubkey","readObjectIdentifier","endPos","oid","firstByte","push","Math","floor","byte","oidStr","join","getOids","getOidKeyTypes","map","readSequence","items","read","type","Error","isPublicKeyType"],"mappings":"yBAMO,MAAMA,EAKT,WAAAC,CAAYC,GAKRC,KAAKD,KAAO,IAAIE,WAAWF,GAM3BC,KAAKE,IAAM,EAMXF,KAAKG,KAAO,GAMZH,KAAKI,OAAS,CACV,eAAgB,QAChB,cAAe,UACf,oBAAqB,UAOzBJ,KAAKK,aAAc,CAC3B,CAOI,UAAAC,GACI,IAAIC,EAASP,KAAKD,KAAKC,KAAKE,OAC5B,GAAa,IAATK,EAAe,CACf,IAAIC,EAAoB,IAATD,EACfA,EAAS,EACT,IAAK,IAAIE,EAAI,EAAGA,EAAID,EAAUC,IAC1BF,EAAUA,GAAU,EAAKP,KAAKD,KAAKC,KAAKE,MAExD,CACQ,OAAOK,CACf,CAOI,QAAAG,GACI,OAAOV,KAAKD,KAAKC,KAAKE,MAC9B,CAOI,WAAAS,GACI,MAAMJ,EAASP,KAAKM,aACpB,IAAIM,EAAQ,EACZ,IAAK,IAAIH,EAAI,EAAGA,EAAIF,EAAQE,IACxBG,EAASA,GAAS,EAAKZ,KAAKD,KAAKC,KAAKE,OAE1C,MAAO,CAAEW,QAASD,EAC1B,CAOI,eAAAE,GACI,MAAMP,EAASP,KAAKM,aACdM,EAAQZ,KAAKD,KAAKgB,MAAMf,KAAKE,IAAKF,KAAKE,IAAMK,GAEnD,OADAP,KAAKE,KAAOK,EACL,CAAES,KAAMJ,EACvB,CAOI,aAAAK,GACI,MAAMV,EAASP,KAAKM,aACdY,EAAalB,KAAKD,KAAKC,KAAKE,OAC5BU,EAAQZ,KAAKD,KAAKgB,MAAMf,KAAKE,IAAKF,KAAKE,IAAMK,EAAS,GAE5D,OADAP,KAAKE,KAAOK,EAAS,EACd,CAAEW,aAAYC,OAAQP,EACrC,CAOI,oBAAAQ,GACI,MAAMb,EAASP,KAAKM,aACde,EAASrB,KAAKE,IAAMK,EACpBe,EAAM,GACZ,IAAIV,EAAQ,EAGZ,MAAMW,EAAYvB,KAAKD,KAAKC,KAAKE,OAIjC,IAHAoB,EAAIE,KAAKC,KAAKC,MAAMH,EAAY,KAChCD,EAAIE,KAAKD,EAAY,IAEdvB,KAAKE,IAAMmB,GAAQ,CACtB,MAAMM,EAAO3B,KAAKD,KAAKC,KAAKE,OAC5BU,EAASA,GAAS,EAAa,IAAPe,EACX,IAAPA,IACFL,EAAIE,KAAKZ,GACTA,EAAQ,EAExB,CAEQ,MAAMgB,EAASN,EAAIO,KAAK,KAExB,OADA7B,KAAKG,KAAKqB,KAAKI,GACR,CAAEN,IAAKM,EACtB,CAMI,OAAAE,GACI,OAAO9B,KAAKG,IACpB,CAMI,cAAA4B,GACI,OAAO/B,KAAKG,KAAK6B,KAAKV,GAAQtB,KAAKI,OAAOkB,IAAQ,WAC1D,CAOI,YAAAW,GACI,MAAM1B,EAASP,KAAKM,aACde,EAASrB,KAAKE,IAAMK,EACpB2B,EAAQ,GACd,KAAOlC,KAAKE,IAAMmB,GACda,EAAMV,KAAKxB,KAAKmC,QAIpB,OAAOD,CACf,CAOI,IAAAC,GACI,MAAMC,EAAOpC,KAAKU,WAElB,OAAQ0B,GACJ,KAAK,EACD,OAAOpC,KAAKW,cAChB,KAAK,EACD,OAAOX,KAAKiB,gBAChB,KAAK,EACD,OAAOjB,KAAKc,kBAChB,KAAK,EACD,OAAOd,KAAKoB,uBAChB,KAAK,GAEL,KAAK,IAEL,KAAK,IACD,OAAOpB,KAAKiC,eAChB,QACI,MAAM,IAAII,MAAM,qBAAqBD,KAErD,CAMI,eAAAE,GACI,OAAOtC,KAAKK,WACpB"}

package/lib/util.cjs

@@ -0,0 +1,464 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.REQUIRE_UINT8ARRAY_ERROR = exports.REQUIRE_TYPE_ERROR = exports.REQUIRE_STRING_OR_UINT8ARRAY_ERROR = exports.REQUIRE_STRING_ERROR = exports.REQUIRE_NUMBER_ERROR = exports.REQUIRE_NON_NULL_ERROR = exports.REQUIRE_LONG_ERROR = exports.REQUIRE_BIGNUMBER_ERROR = exports.REQUIRE_ARRAY_ERROR = exports.FUNCTION_CONVERT_TO_NUMBER_PARSE_ERROR = exports.FUNCTION_CONVERT_TO_NUMBER_ERROR = exports.FUNCTION_CONVERT_TO_BIGNUMBER_ERROR = void 0;
+exports.arrayEqual = arrayEqual;
+exports.compare = compare;
+exports.convertToBigNumber = convertToBigNumber;
+exports.convertToBigNumberArray = convertToBigNumberArray;
+exports.convertToNumber = convertToNumber;
+exports.isBigNumber = isBigNumber;
+exports.isLong = isLong;
+exports.isLongZeroAddress = isLongZeroAddress;
+exports.isNonNull = isNonNull;
+exports.isNumber = isNumber;
+exports.isString = isString;
+exports.isStringOrUint8Array = isStringOrUint8Array;
+exports.isType = isType;
+exports.isUint8Array = isUint8Array;
+exports.requireBigNumber = requireBigNumber;
+exports.requireLong = requireLong;
+exports.requireNonNull = requireNonNull;
+exports.requireNotNegative = requireNotNegative;
+exports.requireNumber = requireNumber;
+exports.requireString = requireString;
+exports.requireStringOrUint8Array = requireStringOrUint8Array;
+exports.requireType = requireType;
+exports.requireUint8Array = requireUint8Array;
+exports.safeView = safeView;
+exports.screamingSnakeToPascalCase = screamingSnakeToPascalCase;
+exports.shuffle = shuffle;
+exports.wait = wait;
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _long = _interopRequireDefault(require("long"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @typedef {import("./Hbar.js").default} Hbar
+ */
+
+/**
+ * Utility Error Messages
+ */
+const REQUIRE_NON_NULL_ERROR = exports.REQUIRE_NON_NULL_ERROR = "This value cannot be null | undefined.";
+const REQUIRE_STRING_ERROR = exports.REQUIRE_STRING_ERROR = "This value must be a string.";
+const REQUIRE_UINT8ARRAY_ERROR = exports.REQUIRE_UINT8ARRAY_ERROR = "This value must be a Uint8Array.";
+const REQUIRE_STRING_OR_UINT8ARRAY_ERROR = exports.REQUIRE_STRING_OR_UINT8ARRAY_ERROR = "This value must be a string or Uint8Array.";
+const REQUIRE_NUMBER_ERROR = exports.REQUIRE_NUMBER_ERROR = "This value must be a Number.";
+const REQUIRE_BIGNUMBER_ERROR = exports.REQUIRE_BIGNUMBER_ERROR = "This value must be a BigNumber.";
+const REQUIRE_ARRAY_ERROR = exports.REQUIRE_ARRAY_ERROR = "The provided variable must be an Array.";
+const REQUIRE_LONG_ERROR = exports.REQUIRE_LONG_ERROR = "This value must be a Long.";
+const REQUIRE_TYPE_ERROR = exports.REQUIRE_TYPE_ERROR = "The provided variables are not matching types.";
+const FUNCTION_CONVERT_TO_BIGNUMBER_ERROR = exports.FUNCTION_CONVERT_TO_BIGNUMBER_ERROR = "This value must be a String, Number, or BigNumber to be converted.";
+const FUNCTION_CONVERT_TO_NUMBER_ERROR = exports.FUNCTION_CONVERT_TO_NUMBER_ERROR = "This value must be a String, Number, or BigNumber to be converted.";
+const FUNCTION_CONVERT_TO_NUMBER_PARSE_ERROR = exports.FUNCTION_CONVERT_TO_NUMBER_PARSE_ERROR = "Unable to parse given variable. Returns NaN.";
+
+//Soft Checks
+
+/**
+ * Takes any param and returns false if null or undefined.
+ *
+ * @param {any | null | undefined} variable
+ * @returns {boolean}
+ */
+function isNonNull(variable) {
+  return variable != null;
+}
+
+/**
+ * Takes any param and returns true if param variable and type are the same.
+ *
+ * @param {any | null | undefined} variable
+ * @param {any | null | undefined} type
+ * @returns {boolean}
+ */
+function isType(variable, type) {
+  return typeof variable == typeof type;
+}
+
+/**
+ * Takes any param and returns true if param is not null and of type Uint8Array.
+ *
+ * @param {any | null | undefined} variable
+ * @returns {boolean}
+ */
+function isUint8Array(variable) {
+  return isNonNull(variable) && variable instanceof Uint8Array;
+}
+
+/**
+ * Takes any param and returns true if param is not null and of type Number.
+ *
+ * @param {any | null | undefined} variable
+ * @returns {boolean}
+ */
+function isNumber(variable) {
+  return isNonNull(variable) && (typeof variable == "number" || variable instanceof Number);
+}
+
+/**
+ * Takes any param and returns true if param is not null and of type BigNumber.
+ *
+ * @param {any | null | undefined} variable
+ * @returns {boolean}
+ */
+function isBigNumber(variable) {
+  return isNonNull(variable) && variable instanceof _bignumber.default;
+}
+
+/**
+ * Takes any param and returns true if param is not null and of type BigNumber.
+ *
+ * @param {any | null | undefined} variable
+ * @returns {boolean}
+ */
+function isLong(variable) {
+  return isNonNull(variable) && variable instanceof _long.default;
+}
+
+/**
+ * Takes any param and returns true if param is not null and of type string.
+ *
+ * @param {any | null | undefined} variable
+ * @returns {boolean}
+ */
+function isString(variable) {
+  return isNonNull(variable) && typeof variable == "string";
+}
+
+/**
+ * Takes any param and returns true if param is not null and type string or Uint8Array.
+ *
+ * @param {any | null | undefined} variable
+ * @returns {boolean}
+ */
+function isStringOrUint8Array(variable) {
+  return isNonNull(variable) && (isString(variable) || isUint8Array(variable));
+}
+
+/**
+ * Takes an address as `Uint8Array` and returns whether or not this is a long-zero address
+ *
+ * @param {Uint8Array} address
+ * @returns {boolean}
+ */
+function isLongZeroAddress(address) {
+  for (let i = 0; i < 12; i++) {
+    if (address[i] != 0) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Takes any param and returns false if null or undefined.
+ *
+ * @template {Long | Hbar} T
+ * @param {T} variable
+ * @returns {T}
+ */
+function requireNotNegative(variable) {
+  if (variable.isNegative()) {
+    throw new Error("negative value not allowed");
+  }
+  return variable;
+}
+
+/**
+ * Takes any param and throws custom error if null or undefined.
+ *
+ * @param {any} variable
+ * @returns {object}
+ */
+function requireNonNull(variable) {
+  if (!isNonNull(variable)) {
+    throw new Error(REQUIRE_NON_NULL_ERROR);
+  } else {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return variable;
+  }
+}
+
+/**
+ * Takes any param and throws custom error if params are not same type.
+ *
+ * @param {any | null | undefined} variable
+ * @param {any | null | undefined} type
+ * @returns {object}
+ */
+function requireType(variable, type) {
+  if (!isType(variable, type)) {
+    throw new Error(REQUIRE_TYPE_ERROR);
+  } else {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return variable;
+  }
+}
+
+/**
+ * Takes any param and throws custom error if non BigNumber.
+ *
+ * @param {any | null | undefined} variable
+ * @returns {BigNumber}
+ */
+function requireBigNumber(variable) {
+  if (!isBigNumber(requireNonNull(variable))) {
+    throw new Error(REQUIRE_BIGNUMBER_ERROR);
+  } else {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return /** @type {BigNumber} */variable;
+  }
+}
+
+/**
+ * Takes any param and throws custom error if non BigNumber.
+ *
+ * @param {any | null | undefined} variable
+ * @returns {Long}
+ */
+function requireLong(variable) {
+  if (!isLong(requireNonNull(variable))) {
+    throw new Error(REQUIRE_LONG_ERROR);
+  } else {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return /** @type {Long} */variable;
+  }
+}
+
+/**
+ * Takes any param and throws custom error if non string.
+ *
+ * @param {any | null | undefined} variable
+ * @returns {string}
+ */
+function requireString(variable) {
+  if (!isString(requireNonNull(variable))) {
+    throw new Error(REQUIRE_STRING_ERROR);
+  } else {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return /** @type {string} */variable;
+  }
+}
+
+/**
+ * Takes any param and throws custom error if non Uint8Array.
+ *
+ * @param {any | null | undefined} variable
+ * @returns {Uint8Array}
+ */
+function requireUint8Array(variable) {
+  if (!isUint8Array(requireNonNull(variable))) {
+    throw new Error(REQUIRE_UINT8ARRAY_ERROR);
+  } else {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return /** @type {Uint8Array} */variable;
+  }
+}
+
+/**
+ * Takes any param and throws custom error if non Uint8Array.
+ *
+ * @param {any | null | undefined} variable
+ * @returns {number}
+ */
+function requireNumber(variable) {
+  if (!isNumber(requireNonNull(variable))) {
+    throw new Error(REQUIRE_NUMBER_ERROR);
+  } else {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return /** @type {number} */variable;
+  }
+}
+
+/**
+ * Takes any param and throws custom error if null or undefined and not a string or Uint8Array.
+ *
+ * @param {any | null | undefined} variable
+ * @returns {string | Uint8Array}
+ */
+function requireStringOrUint8Array(variable) {
+  if (isStringOrUint8Array(requireNonNull(variable))) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return /** @type {string | Uint8Array} */variable;
+  } else {
+    throw new Error(REQUIRE_STRING_OR_UINT8ARRAY_ERROR);
+  }
+}
+
+//Conversions
+
+/**
+ * Converts number or string to BigNumber.
+ *
+ * @param {any | null | undefined} variable
+ * @returns {BigNumber}
+ */
+function convertToBigNumber(variable) {
+  requireNonNull(variable);
+  if (isBigNumber(variable) || isString(variable) || isNumber(variable) || isLong(variable)) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    return new _bignumber.default(variable);
+  }
+  throw new Error(FUNCTION_CONVERT_TO_BIGNUMBER_ERROR);
+}
+
+/**
+ * Converts Array of Numbers or Strings to Array of BigNumbers.
+ *
+ * @param {any | null | undefined} variable
+ * @returns {Array<BigNumber>}
+ */
+function convertToBigNumberArray(variable) {
+  if (variable instanceof Array) {
+    return /** @type {Array<BigNumber>} */variable.map(convertToBigNumber);
+  } else {
+    throw new Error(REQUIRE_ARRAY_ERROR);
+  }
+}
+
+/**
+ * @param {*} variable
+ * @returns {number}
+ */
+function convertToNumber(variable) {
+  requireNonNull(variable);
+  if (isBigNumber(variable) || isString(variable) || isNumber(variable) || isLong(variable)) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    const num = parseInt(variable);
+    if (isNaN(num)) {
+      throw new Error(FUNCTION_CONVERT_TO_NUMBER_PARSE_ERROR);
+    } else {
+      return num;
+    }
+  } else {
+    throw new Error(FUNCTION_CONVERT_TO_NUMBER_ERROR);
+  }
+}
+
+/**
+ * Creates a DataView on top of an Uint8Array that could be or not be pooled, ensuring that we don't get out of bounds.
+ *
+ * @param {Uint8Array | Int8Array} arr
+ * @param {number | undefined} offset
+ * @param {number | undefined} length
+ * @returns {DataView}
+ */
+function safeView(arr, offset = 0, length = arr.byteLength) {
+  if (!(Number.isInteger(offset) && offset >= 0)) throw new Error("Invalid offset!");
+  if (!(Number.isInteger(length) && length >= 0)) throw new Error("Invalid length!");
+  return new DataView(arr.buffer, arr.byteOffset + offset, Math.min(length, arr.byteLength - offset));
+}
+
+/**
+ * @param {any} a
+ * @param {any} b
+ * @param {Set<string>=} ignore
+ * @returns {boolean}
+ */
+function compare(a, b, ignore = new Set()) {
+  if (typeof a === "object" && typeof b === "object") {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    const aKeys = Object.keys(a);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) {
+      return false;
+    }
+    for (let i = 0; i < aKeys.length; i++) {
+      if (aKeys[i] !== bKeys[i]) {
+        return false;
+      }
+      if (ignore.has(aKeys[i])) {
+        continue;
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      if (!compare(a[aKeys[i]], b[bKeys[i]], ignore)) {
+        return false;
+      }
+    }
+    return true;
+  } else if (typeof a === "number" && typeof b === "number") {
+    return a === b;
+  } else if (typeof a === "string" && typeof b === "string") {
+    return a === b;
+  } else if (typeof a === "boolean" && typeof b === "boolean") {
+    return a === b;
+  } else {
+    return false;
+  }
+}
+
+/**
+ * https://stackoverflow.com/questions/2450954/how-to-randomize-shuffle-a-javascript-array
+ *
+ * @template T
+ * @param {Array<T>} array
+ */
+function shuffle(array) {
+  var currentIndex = array.length,
+    temporaryValue,
+    randomIndex;
+
+  // While there remain elements to shuffle...
+  while (0 !== currentIndex) {
+    // Pick a remaining element...
+    randomIndex = Math.floor(Math.random() * currentIndex);
+    currentIndex -= 1;
+
+    // And swap it with the current element.
+    temporaryValue = array[currentIndex];
+    array[currentIndex] = array[randomIndex];
+    array[randomIndex] = temporaryValue;
+  }
+}
+
+/**
+ * @param {Uint8Array} array1
+ * @param {Uint8Array} array2
+ * @returns {boolean}
+ */
+function arrayEqual(array1, array2) {
+  if (array1 === array2) {
+    return true;
+  }
+  if (array1.byteLength !== array2.byteLength) {
+    return false;
+  }
+  const view1 = new DataView(array1.buffer, array1.byteOffset, array1.byteLength);
+  const view2 = new DataView(array2.buffer, array2.byteOffset, array2.byteLength);
+  let i = array1.byteLength;
+  while (i--) {
+    if (view1.getUint8(i) !== view2.getUint8(i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * @description Function that delays an execution for a given time (in milliseconds)
+ * @param {number} ms
+ * @returns {Promise<void>}
+ */
+function wait(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Converts a SCREAMING_SNAKE_CASE string to PascalCase
+ * @param {string} name - The string to convert
+ * @returns {string} The converted PascalCase string
+ */
+function screamingSnakeToPascalCase(name) {
+  const words = name.toLowerCase().split("_");
+  let result = "";
+  for (let i = 0; i < words.length; i++) {
+    result += words[i].charAt(0).toUpperCase() + words[i].slice(1);
+  }
+  return result;
+}