ccxt 4.3.70 → 4.3.71

package/dist/cjs/src/static_dependencies/starknet/utils/calldata/validate.js

@@ -0,0 +1,206 @@
+'use strict';
+
+var calldata = require('../../types/calldata.js');
+require('../../types/lib/index.js');
+var assert = require('../assert.js');
+var uint256 = require('../cairoDataTypes/uint256.js');
+var uint512 = require('../cairoDataTypes/uint512.js');
+var num = require('../num.js');
+var shortString = require('../shortString.js');
+var cairo = require('./cairo.js');
+
+/**
+ * Validate cairo contract method arguments
+ * Flow: Determine type from abi and than validate against parameter
+ */
+const validateFelt = (parameter, input) => {
+    assert(shortString.isString(parameter) || num.isNumber(parameter) || num.isBigInt(parameter), `Validate: arg ${input.name} should be a felt typed as (String, Number or BigInt)`);
+    if (shortString.isString(parameter) && !num.isHex(parameter))
+        return; // shortstring
+    const param = BigInt(parameter.toString(10));
+    assert(
+    // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1266
+    param >= 0n && param <= 2n ** 252n - 1n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^252-1]`);
+};
+const validateBytes31 = (parameter, input) => {
+    assert(shortString.isString(parameter), `Validate: arg ${input.name} should be a string.`);
+    assert(parameter.length < 32, `Validate: arg ${input.name} cairo typed ${input.type} should be a string of less than 32 characters.`);
+};
+const validateByteArray = (parameter, input) => {
+    assert(shortString.isString(parameter), `Validate: arg ${input.name} should be a string.`);
+};
+const validateUint = (parameter, input) => {
+    if (num.isNumber(parameter)) {
+        assert(parameter <= Number.MAX_SAFE_INTEGER, `Validation: Parameter is to large to be typed as Number use (BigInt or String)`);
+    }
+    assert(shortString.isString(parameter) ||
+        num.isNumber(parameter) ||
+        num.isBigInt(parameter) ||
+        (typeof parameter === 'object' && 'low' in parameter && 'high' in parameter) ||
+        (typeof parameter === 'object' &&
+            ['limb0', 'limb1', 'limb2', 'limb3'].every((key) => key in parameter)), `Validate: arg ${input.name} of cairo type ${input.type} should be type (String, Number or BigInt), but is ${typeof parameter} ${parameter}.`);
+    let param;
+    switch (input.type) {
+        case calldata.Uint.u256:
+            param = new uint256.CairoUint256(parameter).toBigInt();
+            break;
+        case calldata.Uint.u512:
+            param = new uint512.CairoUint512(parameter).toBigInt();
+            break;
+        default:
+            param = num.toBigInt(parameter);
+    }
+    switch (input.type) {
+        case calldata.Uint.u8:
+            assert(param >= 0n && param <= 255n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0 - 255]`);
+            break;
+        case calldata.Uint.u16:
+            assert(param >= 0n && param <= 65535n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 65535]`);
+            break;
+        case calldata.Uint.u32:
+            assert(param >= 0n && param <= 4294967295n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 4294967295]`);
+            break;
+        case calldata.Uint.u64:
+            assert(param >= 0n && param <= 2n ** 64n - 1n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^64-1]`);
+            break;
+        case calldata.Uint.u128:
+            assert(param >= 0n && param <= 2n ** 128n - 1n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^128-1]`);
+            break;
+        case calldata.Uint.u256:
+            assert(param >= 0n && param <= 2n ** 256n - 1n, `Validate: arg ${input.name} is ${input.type} 0 - 2^256-1`);
+            break;
+        case calldata.Uint.u512:
+            assert(uint512.CairoUint512.is(param), `Validate: arg ${input.name} is ${input.type} 0 - 2^512-1`);
+            break;
+        case calldata.Literal.ClassHash:
+            assert(
+            // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1670
+            param >= 0n && param <= 2n ** 252n - 1n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^252-1]`);
+            break;
+        case calldata.Literal.ContractAddress:
+            assert(
+            // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1245
+            param >= 0n && param <= 2n ** 252n - 1n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^252-1]`);
+            break;
+        case calldata.Literal.Secp256k1Point: {
+            assert(param >= 0n && param <= 2n ** 512n - 1n, `Validate: arg ${input.name} must be ${input.type} : a 512 bits number.`);
+            break;
+        }
+    }
+};
+const validateBool = (parameter, input) => {
+    assert(num.isBoolean(parameter), `Validate: arg ${input.name} of cairo type ${input.type} should be type (Boolean)`);
+};
+const validateStruct = (parameter, input, structs) => {
+    // c1v2 uint256 or u512 in struct
+    if (input.type === calldata.Uint.u256 || input.type === calldata.Uint.u512) {
+        validateUint(parameter, input);
+        return;
+    }
+    if (input.type === 'core::starknet::eth_address::EthAddress') {
+        assert(typeof parameter !== 'object', `EthAddress type is waiting a BigNumberish. Got ${parameter}`);
+        const param = BigInt(parameter.toString(10));
+        assert(
+        // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1259
+        param >= 0n && param <= 2n ** 160n - 1n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^160-1]`);
+        return;
+    }
+    assert(typeof parameter === 'object' && !Array.isArray(parameter), `Validate: arg ${input.name} is cairo type struct (${input.type}), and should be defined as js object (not array)`);
+    // shallow struct validation, only first depth level
+    structs[input.type].members.forEach(({ name }) => {
+        assert(Object.keys(parameter).includes(name), `Validate: arg ${input.name} should have a property ${name}`);
+    });
+};
+const validateEnum = (parameter, input) => {
+    assert(typeof parameter === 'object' && !Array.isArray(parameter), `Validate: arg ${input.name} is cairo type Enum (${input.type}), and should be defined as js object (not array)`);
+    const methodsKeys = Object.getOwnPropertyNames(Object.getPrototypeOf(parameter));
+    const keys = [...Object.getOwnPropertyNames(parameter), ...methodsKeys];
+    if (cairo.isTypeOption(input.type) && keys.includes('isSome') && keys.includes('isNone')) {
+        return; // Option Enum
+    }
+    if (cairo.isTypeResult(input.type) && keys.includes('isOk') && keys.includes('isErr')) {
+        return; // Result Enum
+    }
+    if (keys.includes('variant') && keys.includes('activeVariant')) {
+        return; // Custom Enum
+    }
+    throw new Error(`Validate Enum: argument ${input.name}, type ${input.type}, value received ${parameter}, is not an Enum.`);
+};
+const validateTuple = (parameter, input) => {
+    assert(typeof parameter === 'object' && !Array.isArray(parameter), `Validate: arg ${input.name} should be a tuple (defined as object)`);
+    // todo: skip tuple structural validation for now
+};
+const validateArray = (parameter, input, structs, enums) => {
+    const baseType = cairo.getArrayType(input.type);
+    // Long text (special case when parameter is not an array but long text)
+    if (cairo.isTypeFelt(baseType) && shortString.isLongText(parameter)) {
+        return;
+    }
+    assert(Array.isArray(parameter), `Validate: arg ${input.name} should be an Array`);
+    switch (true) {
+        case cairo.isTypeFelt(baseType):
+            parameter.forEach((param) => validateFelt(param, input));
+            break;
+        case cairo.isTypeTuple(baseType):
+            parameter.forEach((it) => validateTuple(it, { name: input.name, type: baseType }));
+            break;
+        case cairo.isTypeArray(baseType):
+            parameter.forEach((param) => validateArray(param, { name: '', type: baseType }, structs, enums));
+            break;
+        case cairo.isTypeStruct(baseType, structs):
+            parameter.forEach((it) => validateStruct(it, { name: input.name, type: baseType }, structs));
+            break;
+        case cairo.isTypeEnum(baseType, enums):
+            parameter.forEach((it) => validateEnum(it, { name: input.name, type: baseType }));
+            break;
+        case cairo.isTypeUint(baseType) || cairo.isTypeLiteral(baseType):
+            parameter.forEach((param) => validateUint(param, { name: '', type: baseType }));
+            break;
+        case cairo.isTypeBool(baseType):
+            parameter.forEach((param) => validateBool(param, input));
+            break;
+        default:
+            throw new Error(`Validate Unhandled: argument ${input.name}, type ${input.type}, value ${parameter}`);
+    }
+};
+function validateFields(abiMethod, args, structs, enums) {
+    abiMethod.inputs.reduce((acc, input) => {
+        const parameter = args[acc];
+        switch (true) {
+            case cairo.isLen(input.name):
+                return acc;
+            case cairo.isTypeFelt(input.type):
+                validateFelt(parameter, input);
+                break;
+            case cairo.isTypeBytes31(input.type):
+                validateBytes31(parameter, input);
+                break;
+            case cairo.isTypeUint(input.type) || cairo.isTypeLiteral(input.type):
+                validateUint(parameter, input);
+                break;
+            case cairo.isTypeBool(input.type):
+                validateBool(parameter, input);
+                break;
+            case cairo.isTypeByteArray(input.type):
+                validateByteArray(parameter, input);
+                break;
+            case cairo.isTypeArray(input.type):
+                validateArray(parameter, input, structs, enums);
+                break;
+            case cairo.isTypeStruct(input.type, structs):
+                validateStruct(parameter, input, structs);
+                break;
+            case cairo.isTypeEnum(input.type, enums):
+                validateEnum(parameter, input);
+                break;
+            case cairo.isTypeTuple(input.type):
+                validateTuple(parameter, input);
+                break;
+            default:
+                throw new Error(`Validate Unhandled: argument ${input.name}, type ${input.type}, value ${parameter}`);
+        }
+        return acc + 1;
+    }, 0);
+}
+
+module.exports = validateFields;

package/dist/cjs/src/static_dependencies/starknet/utils/encode.js

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../../scure-base/index.js');
+
+/**
+ * Convert utf8-string to Uint8Array
+ *
+ * *[internal usage]*
+ *
+ * @param {string} str The UTF-8 string to convert.
+ * @returns {Uint8Array} The encoded Uint8Array.
+ *
+ * @example
+ * ```typescript
+ * const myString = 'Hi';
+ * const result = encode.utf8ToArray(myString);
+ * // result = Uint8Array(2) [ 72, 105 ]
+ * ```
+ */
+function utf8ToArray(str) {
+    return new TextEncoder().encode(str);
+}
+/**
+ * Remove hex prefix '0x' from hex-string
+ * @param hex hex-string
+ * @returns {string} The hex-string
+ *
+ * @example
+ * ```typescript
+ * const hexStringWithPrefix = '0x48656c6c6f';
+ * const result = encode.removeHexPrefix(hexStringWithPrefix);
+ * // result: "48656c6c6f"
+ * ```
+ */
+function removeHexPrefix(hex) {
+    return hex.replace(/^0x/i, '');
+}
+/**
+ * Add hex prefix '0x' to base16-string
+ * @param hex base16-string
+ * @returns {string} The hex-string
+ *
+ * @example
+ * ```typescript
+ * const plainHexString = '48656c6c6f';
+ * const result = encode.addHexPrefix(plainHexString);
+ * // result: "0x48656c6c6f"
+ * ```
+ */
+function addHexPrefix(hex) {
+    return `0x${removeHexPrefix(hex)}`;
+}
+
+exports.addHexPrefix = addHexPrefix;
+exports.removeHexPrefix = removeHexPrefix;
+exports.utf8ToArray = utf8ToArray;

package/dist/cjs/src/static_dependencies/starknet/utils/hash/classHash.js

@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index$1 = require('../../../scure-starknet/index.js');
+var constants = require('../../constants.js');
+var index = require('../calldata/index.js');
+var cairo = require('../calldata/cairo.js');
+require('../../../scure-base/index.js');
+var num = require('../num.js');
+
+/**
+ * Class Hash
+ */
+function computePedersenHash(a, b) {
+    return index$1.pedersen(BigInt(a), BigInt(b));
+}
+function computePoseidonHash(a, b) {
+    return num.toHex(index$1.poseidonHash(BigInt(a), BigInt(b)));
+}
+/**
+ * Compute pedersen hash from data
+ * @returns format: hex-string - pedersen hash
+ */
+function computeHashOnElements(data) {
+    return [...data, data.length]
+        .reduce((x, y) => index$1.pedersen(BigInt(x), BigInt(y)), 0)
+        .toString();
+}
+const computePedersenHashOnElements = computeHashOnElements;
+function computePoseidonHashOnElements(data) {
+    return num.toHex(index$1.poseidonHashMany(data.map((x) => BigInt(x))));
+}
+/**
+ * Calculate contract address from class hash
+ * @returns format: hex-string
+ */
+function calculateContractAddressFromHash(salt, classHash, constructorCalldata, deployerAddress) {
+    const compiledCalldata = index.CallData.compile(constructorCalldata);
+    const constructorCalldataHash = computeHashOnElements(compiledCalldata);
+    const CONTRACT_ADDRESS_PREFIX = cairo.felt('0x535441524b4e45545f434f4e54524143545f41444452455353'); // Equivalent to 'STARKNET_CONTRACT_ADDRESS'
+    const hash = computeHashOnElements([
+        CONTRACT_ADDRESS_PREFIX,
+        deployerAddress,
+        salt,
+        classHash,
+        constructorCalldataHash,
+    ]);
+    return num.toHex(BigInt(hash) % constants.ADDR_BOUND);
+}
+
+exports.calculateContractAddressFromHash = calculateContractAddressFromHash;
+exports.computeHashOnElements = computeHashOnElements;
+exports.computePedersenHash = computePedersenHash;
+exports.computePedersenHashOnElements = computePedersenHashOnElements;
+exports.computePoseidonHash = computePoseidonHash;
+exports.computePoseidonHashOnElements = computePoseidonHashOnElements;

package/dist/cjs/src/static_dependencies/starknet/utils/merkle.js

@@ -0,0 +1,76 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../../noble-curves/abstract/modular.js');
+require('../../scure-starknet/index.js');
+require('../constants.js');
+require('../../scure-base/index.js');
+require('../../noble-curves/abstract/utils.js');
+var classHash = require('./hash/classHash.js');
+
+class MerkleTree {
+    constructor(leafHashes, hashMethod = classHash.computePedersenHash) {
+        this.branches = [];
+        this.hashMethod = hashMethod;
+        this.leaves = leafHashes;
+        this.root = this.build(leafHashes);
+    }
+    /**
+     * Create Merkle tree
+     * @param leaves hex-string array
+     * @returns format: hex-string; Merkle tree root
+     */
+    build(leaves) {
+        if (leaves.length === 1) {
+            return leaves[0];
+        }
+        if (leaves.length !== this.leaves.length) {
+            this.branches.push(leaves);
+        }
+        const newLeaves = [];
+        for (let i = 0; i < leaves.length; i += 2) {
+            if (i + 1 === leaves.length) {
+                newLeaves.push(MerkleTree.hash(leaves[i], '0x0', this.hashMethod));
+            }
+            else {
+                newLeaves.push(MerkleTree.hash(leaves[i], leaves[i + 1], this.hashMethod));
+            }
+        }
+        return this.build(newLeaves);
+    }
+    /**
+     * Create hash from ordered a and b, Pedersen hash default
+     * @returns format: hex-string
+     */
+    static hash(a, b, hashMethod = classHash.computePedersenHash) {
+        const [aSorted, bSorted] = [BigInt(a), BigInt(b)].sort((x, y) => (x >= y ? 1 : -1));
+        return hashMethod(aSorted, bSorted);
+    }
+    /**
+     * Return path to leaf
+     * @param leaf hex-string
+     * @param branch hex-string array
+     * @param hashPath hex-string array
+     * @returns format: hex-string array
+     */
+    getProof(leaf, branch = this.leaves, hashPath = []) {
+        const index = branch.indexOf(leaf);
+        if (index === -1) {
+            throw new Error('leaf not found');
+        }
+        if (branch.length === 1) {
+            return hashPath;
+        }
+        const isLeft = index % 2 === 0;
+        const neededBranch = (isLeft ? branch[index + 1] : branch[index - 1]) ?? '0x0';
+        const newHashPath = [...hashPath, neededBranch];
+        const currentBranchLevelIndex = this.leaves.length === branch.length
+            ? -1
+            : this.branches.findIndex((b) => b.length === branch.length);
+        const nextBranch = this.branches[currentBranchLevelIndex + 1] ?? [this.root];
+        return this.getProof(MerkleTree.hash(isLeft ? leaf : neededBranch, isLeft ? neededBranch : leaf, this.hashMethod), nextBranch, newHashPath);
+    }
+}
+
+exports.MerkleTree = MerkleTree;

package/dist/cjs/src/static_dependencies/starknet/utils/num.js

@@ -0,0 +1,92 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../../noble-curves/abstract/utils.js');
+var encode = require('./encode.js');
+
+/**
+ * Test if string is hex-string
+ * @param hex hex-string
+ * @returns {boolean} True if the input string is a hexadecimal string, false otherwise
+ * @example
+ * ```typescript
+ * const hexString1 = "0x2fd23d9182193775423497fc0c472e156c57c69e4089a1967fb288a2d84e914";
+ * const result1 = isHex(hexString1);
+ * // result1 = true
+ *
+ * const hexString2 = "2fd23d9182193775423497fc0c472e156c57c69e4089a1967fb288a2d84e914";
+ * const result2 = isHex(hexString2);
+ * // result2 = false
+ * ```
+ */
+function isHex(hex) {
+    return /^0x[0-9a-f]*$/i.test(hex);
+}
+/**
+ * Convert BigNumberish to bigint
+ */
+function toBigInt(value) {
+    return BigInt(value);
+}
+/**
+ * Test if value is bigint
+ */
+function isBigInt(value) {
+    return typeof value === 'bigint';
+}
+/**
+ * Convert BigNumberish to hex-string
+ * @returns format: hex-string
+ */
+function toHex(number) {
+    return encode.addHexPrefix(toBigInt(number).toString(16));
+}
+/**
+ * Test if string is whole number (0, 1, 2, 3...)
+ */
+const isStringWholeNumber = (value) => /^\d+$/.test(value);
+/**
+ * Check if a value is a number.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} Returns true if the value is a number, otherwise returns false.
+ * @example
+ * ```typescript
+ * const result = isNumber(123);
+ * // result = true
+ *
+ * const result2 = isNumber("123");
+ * // result2 = false
+ * ```
+ * @return {boolean} Returns true if the value is a number, otherwise returns false.
+ */
+function isNumber(value) {
+    return typeof value === 'number';
+}
+/**
+ * Checks if a given value is of boolean type.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} - True if the value is of boolean type, false otherwise.
+ * @example
+ * ```typescript
+ * const result = isBoolean(true);
+ * // result = true
+ *
+ * const result2 = isBoolean(false);
+ * // result2 = false
+ * ```
+ * @return {boolean} - True if the value is of boolean type, false otherwise.
+ */
+function isBoolean(value) {
+    return typeof value === 'boolean';
+}
+
+exports.isBigInt = isBigInt;
+exports.isBoolean = isBoolean;
+exports.isHex = isHex;
+exports.isNumber = isNumber;
+exports.isStringWholeNumber = isStringWholeNumber;
+exports.toBigInt = toBigInt;
+exports.toHex = toHex;

package/dist/cjs/src/static_dependencies/starknet/utils/selector.js

@@ -0,0 +1,48 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('../../scure-starknet/index.js');
+var constants = require('../constants.js');
+var encode = require('./encode.js');
+var num = require('./num.js');
+
+/**
+ * Calculate hex-string keccak hash for a given string
+ *
+ * String -> hex-string keccak hash
+ * @returns format: hex-string
+ */
+function keccakHex(str) {
+    return encode.addHexPrefix(index.keccak(encode.utf8ToArray(str)).toString(16));
+}
+/**
+ * Calculate bigint keccak hash for a given string
+ *
+ * String -> bigint keccak hash
+ *
+ * [Reference](https://github.com/starkware-libs/cairo-lang/blob/master/src/starkware/starknet/public/abi.py#L17-L22)
+ * @param str the value you want to get the keccak hash from
+ * @returns starknet keccak hash as BigInt
+ */
+function starknetKeccak(str) {
+    const hash = BigInt(keccakHex(str));
+    // eslint-disable-next-line no-bitwise
+    return hash & constants.MASK_250;
+}
+/**
+ * Calculate hex-string selector for a given abi-function-name
+ *
+ * Abi-function-name -> hex-string selector
+ *
+ * [Reference](https://github.com/starkware-libs/cairo-lang/blob/master/src/starkware/starknet/public/abi.py#L25-L26)
+ * @param funcName ascii-string of 'abi function name'
+ * @returns format: hex-string; selector for 'abi function name'
+ */
+function getSelectorFromName(funcName) {
+    // sometimes BigInteger pads the hex string with zeros, which is not allowed in the starknet api
+    return num.toHex(starknetKeccak(funcName));
+}
+
+exports.getSelectorFromName = getSelectorFromName;
+exports.starknetKeccak = starknetKeccak;

package/dist/cjs/src/static_dependencies/starknet/utils/shortString.js

@@ -0,0 +1,101 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../constants.js');
+var encode = require('./encode.js');
+var num = require('./num.js');
+
+/**
+ * Test if string contains only ASCII characters (string can be ascii text)
+ */
+function isASCII(str) {
+    // eslint-disable-next-line no-control-regex
+    return /^[\x00-\x7F]*$/.test(str);
+}
+/**
+ * Test if string is a Cairo short string (string has less or equal 31 characters)
+ */
+function isShortString(str) {
+    return str.length <= constants.TEXT_TO_FELT_MAX_LEN;
+}
+/**
+ * Test if string contains only numbers (string can be converted to decimal number)
+ */
+function isDecimalString(str) {
+    return /^[0-9]*$/i.test(str);
+}
+/**
+ * Checks if a given value is a string.
+ *
+ * @param {unknown} value - The value to be checked.
+ * @return {boolean} - Returns true if the value is a string, false otherwise.
+ */
+function isString(value) {
+    return typeof value === 'string';
+}
+/**
+ * Test if value is a free-from string text, and not a hex string or number string
+ */
+function isText(val) {
+    return isString(val) && !num.isHex(val) && !num.isStringWholeNumber(val);
+}
+/**
+ * Test if value is long text
+ */
+const isLongText = (val) => isText(val) && !isShortString(val);
+/**
+ * Split long text into short strings
+ */
+function splitLongString(longStr) {
+    const regex = RegExp(`[^]{1,${constants.TEXT_TO_FELT_MAX_LEN}}`, 'g');
+    return longStr.match(regex) || [];
+}
+/**
+ * Convert an ASCII string to a hexadecimal string.
+ * @param str short string (ASCII string, 31 characters max)
+ * @returns format: hex-string; 248 bits max
+ * @example
+ * ```typescript
+ * const myEncodedString: string = encodeShortString("uri/pict/t38.jpg");
+ * // return hex string (ex."0x7572692f706963742f7433382e6a7067")
+ * ```
+ */
+function encodeShortString(str) {
+    if (!isASCII(str))
+        throw new Error(`${str} is not an ASCII string`);
+    if (!isShortString(str))
+        throw new Error(`${str} is too long`);
+    return encode.addHexPrefix(str.replace(/./g, (char) => char.charCodeAt(0).toString(16)));
+}
+/**
+ * Convert a hexadecimal or decimal string to an ASCII string.
+ * @param str representing a 248 bit max number (ex. "0x1A4F64EA56" or "236942575435676423")
+ * @returns format: short string; 31 characters max
+ * @example
+ * ```typescript
+ * const myDecodedString: string = decodeShortString("0x7572692f706963742f7433382e6a7067");
+ * // return string (ex."uri/pict/t38.jpg")
+ * ```
+ */
+function decodeShortString(str) {
+    if (!isASCII(str))
+        throw new Error(`${str} is not an ASCII string`);
+    if (num.isHex(str)) {
+        return encode.removeHexPrefix(str).replace(/.{2}/g, (hex) => String.fromCharCode(parseInt(hex, 16)));
+    }
+    if (isDecimalString(str)) {
+        return decodeShortString('0X'.concat(BigInt(str).toString(16)));
+    }
+    throw new Error(`${str} is not Hex or decimal`);
+}
+
+exports.decodeShortString = decodeShortString;
+exports.encodeShortString = encodeShortString;
+exports.isASCII = isASCII;
+exports.isDecimalString = isDecimalString;
+exports.isLongText = isLongText;
+exports.isShortString = isShortString;
+exports.isString = isString;
+exports.isText = isText;
+exports.splitLongString = splitLongString;