ccxt-ir 4.10.0 → 4.12.0

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

@@ -0,0 +1,84 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+import { computePedersenHash } from './hash/index.js';
+export class MerkleTree {
+    constructor(leafHashes, hashMethod = 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 = 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);
+    }
+}
+/**
+ * Test Merkle tree path
+ * @param root hex-string
+ * @param leaf hex-string
+ * @param path hex-string array
+ * @param hashMethod hash method override, Pedersen default
+ */
+export function proofMerklePath(root, leaf, path, hashMethod = computePedersenHash) {
+    if (path.length === 0) {
+        return root === leaf;
+    }
+    const [next, ...rest] = path;
+    return proofMerklePath(root, MerkleTree.hash(leaf, next, hashMethod), rest, hashMethod);
+}

package/js/src/src/static_dependencies/starknet/utils/num.d.ts

@@ -0,0 +1,182 @@
+import { BigNumberish } from '../types/index.js';
+/** @deprecated prefer importing from 'types' over 'num' */
+export type { BigNumberish };
+/**
+ * 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
+ * ```
+ */
+export declare function isHex(hex: string): boolean;
+/**
+ * Convert BigNumberish to bigint
+ */
+export declare function toBigInt(value: BigNumberish): bigint;
+/**
+ * Test if value is bigint
+ */
+export declare function isBigInt(value: any): value is bigint;
+/**
+ * Convert BigNumberish to hex-string
+ * @returns format: hex-string
+ */
+export declare function toHex(number: BigNumberish): string;
+/**
+ * Alias of ToHex
+ */
+export declare const toHexString: typeof toHex;
+/**
+ * Convert BigNumberish to storage-key-string
+ *
+ * Same as toHex but conforming to the STORAGE_KEY pattern `^0x0[0-7]{1}[a-fA-F0-9]{0,62}$`.
+ *
+ * A storage key is represented as up to 62 hex digits, 3 bits, and 5 leading zeroes:
+ * `0x0 + [0-7] + 62 hex = 0x + 64 hex`
+ * @returns format: storage-key-string
+ */
+export declare function toStorageKey(number: BigNumberish): string;
+/**
+ * Convert hexadecimal string to decimal string
+ * @param hex hex-string
+ * @returns format: decimal string
+ */
+export declare function hexToDecimalString(hex: string): string;
+/**
+ * Remove hex string leading zero and lowercase it
+ * @example '0x01A...' -> '0x1a..'
+ * @param hex hex-string
+ * @returns format: hex-string
+ */
+export declare const cleanHex: (hex: string) => string;
+/**
+ * Asserts input is equal to or greater then lowerBound and lower then upperBound.
+ *
+ * The `inputName` parameter is used in the assertion message.
+ * @param input Value to check
+ * @param lowerBound Lower bound value
+ * @param upperBound Upper bound value
+ * @param inputName Name of the input for error message
+ * @Throws Error if input is out of range
+ * @example
+ * ```typescript
+ * const input1:BigNumberish = 10;
+ * assertInRange(input1, 5, 20, 'value')
+ *
+ * const input2: BigNumberish = 25;
+ * assertInRange(input2, 5, 20, 'value');
+ * // Throws Error: Message not signable, invalid value length.
+ * ```
+ */
+export declare function assertInRange(input: BigNumberish, lowerBound: BigNumberish, upperBound: BigNumberish, inputName?: string): void;
+/**
+ * Convert BigNumberish array to decimal string array
+ * @returns format: decimal string array
+ */
+export declare function bigNumberishArrayToDecimalStringArray(rawCalldata: BigNumberish[]): string[];
+/**
+ * Convert BigNumberish array to hexadecimal string array
+ * @returns format: hex-string array
+ */
+export declare function bigNumberishArrayToHexadecimalStringArray(rawCalldata: BigNumberish[]): string[];
+/**
+ * Test if string is whole number (0, 1, 2, 3...)
+ */
+export declare const isStringWholeNumber: (value: string) => boolean;
+/**
+ * Convert string to decimal string
+ * @returns format: decimal string
+ * @example
+ * ```typescript
+ * const result = getDecimalString("0x1a");
+ * // result = "26"
+ *
+ * const result2 = getDecimalString("Hello");
+ * // Throws Error: "Hello need to be hex-string or whole-number-string"
+ * ```
+ */
+export declare function getDecimalString(value: string): string;
+/**
+ * Convert string to hexadecimal string
+ * @returns format: hex-string
+ * @example
+ * ```typescript
+ * const result = getHexString("123");
+ * // result = "0x7b"
+ *
+ * const result2 = getHexString("Hello");
+ * // Throws Error: Hello need to be hex-string or whole-number-string
+ * ```
+ */
+export declare function getHexString(value: string): string;
+/**
+ * Convert string array to hex-string array
+ * @returns format: hex-string array
+ */
+export declare function getHexStringArray(value: Array<string>): string[];
+/**
+ * Convert boolean to "0" or "1"
+ * @param value The boolean value to be converted.
+ * @returns {boolean} Returns true if the value is a number, otherwise returns false.
+ * @example
+ * ```typescript
+ * const result = toCairoBool(true);
+ * // result ="1"
+ *
+ * const result2 = toCairoBool(false);
+ * // result2 = "0"
+ * ```
+ */
+export declare const toCairoBool: (value: boolean) => string;
+/**
+ * Convert hex-string to an array of Bytes (Uint8Array)
+ * @param value hex-string
+ */
+export declare function hexToBytes(value: string): Uint8Array;
+/**
+ *
+ * @param number value to be increased
+ * @param percent integer as percent ex. 50 for 50%
+ * @returns increased value
+ */
+export declare function addPercent(number: BigNumberish, percent: number): bigint;
+/**
+ * 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.
+ */
+export declare function isNumber(value: unknown): value is 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.
+ */
+export declare function isBoolean(value: unknown): value is boolean;

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

@@ -0,0 +1,244 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+import { hexToBytes as hexToBytesNoble } from '../../noble-curves/abstract/utils.js';
+import assert from './assert.js';
+import { addHexPrefix, removeHexPrefix } from './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
+ * ```
+ */
+export function isHex(hex) {
+    return /^0x[0-9a-f]*$/i.test(hex);
+}
+/**
+ * Convert BigNumberish to bigint
+ */
+export function toBigInt(value) {
+    return BigInt(value);
+}
+/**
+ * Test if value is bigint
+ */
+export function isBigInt(value) {
+    return typeof value === 'bigint';
+}
+/**
+ * Convert BigNumberish to hex-string
+ * @returns format: hex-string
+ */
+export function toHex(number) {
+    return addHexPrefix(toBigInt(number).toString(16));
+}
+/**
+ * Alias of ToHex
+ */
+export const toHexString = toHex;
+/**
+ * Convert BigNumberish to storage-key-string
+ *
+ * Same as toHex but conforming to the STORAGE_KEY pattern `^0x0[0-7]{1}[a-fA-F0-9]{0,62}$`.
+ *
+ * A storage key is represented as up to 62 hex digits, 3 bits, and 5 leading zeroes:
+ * `0x0 + [0-7] + 62 hex = 0x + 64 hex`
+ * @returns format: storage-key-string
+ */
+export function toStorageKey(number) {
+    const res = addHexPrefix(toBigInt(number).toString(16).padStart(64, '0'));
+    return res;
+}
+/**
+ * Convert hexadecimal string to decimal string
+ * @param hex hex-string
+ * @returns format: decimal string
+ */
+export function hexToDecimalString(hex) {
+    return BigInt(addHexPrefix(hex)).toString(10);
+}
+/**
+ * Remove hex string leading zero and lowercase it
+ * @example '0x01A...' -> '0x1a..'
+ * @param hex hex-string
+ * @returns format: hex-string
+ */
+export const cleanHex = (hex) => hex.toLowerCase().replace(/^(0x)0+/, '$1');
+/**
+ * Asserts input is equal to or greater then lowerBound and lower then upperBound.
+ *
+ * The `inputName` parameter is used in the assertion message.
+ * @param input Value to check
+ * @param lowerBound Lower bound value
+ * @param upperBound Upper bound value
+ * @param inputName Name of the input for error message
+ * @Throws Error if input is out of range
+ * @example
+ * ```typescript
+ * const input1:BigNumberish = 10;
+ * assertInRange(input1, 5, 20, 'value')
+ *
+ * const input2: BigNumberish = 25;
+ * assertInRange(input2, 5, 20, 'value');
+ * // Throws Error: Message not signable, invalid value length.
+ * ```
+ */
+export function assertInRange(input, lowerBound, upperBound, inputName = '') {
+    const messageSuffix = inputName === '' ? 'invalid length' : `invalid ${inputName} length`;
+    const inputBigInt = BigInt(input);
+    const lowerBoundBigInt = BigInt(lowerBound);
+    const upperBoundBigInt = BigInt(upperBound);
+    assert(inputBigInt >= lowerBoundBigInt && inputBigInt <= upperBoundBigInt, `Message not signable, ${messageSuffix}.`);
+}
+/**
+ * Convert BigNumberish array to decimal string array
+ * @returns format: decimal string array
+ */
+export function bigNumberishArrayToDecimalStringArray(rawCalldata) {
+    return rawCalldata.map((x) => toBigInt(x).toString(10));
+}
+/**
+ * Convert BigNumberish array to hexadecimal string array
+ * @returns format: hex-string array
+ */
+export function bigNumberishArrayToHexadecimalStringArray(rawCalldata) {
+    return rawCalldata.map((x) => toHex(x));
+}
+/**
+ * Test if string is whole number (0, 1, 2, 3...)
+ */
+export const isStringWholeNumber = (value) => /^\d+$/.test(value);
+/**
+ * Convert string to decimal string
+ * @returns format: decimal string
+ * @example
+ * ```typescript
+ * const result = getDecimalString("0x1a");
+ * // result = "26"
+ *
+ * const result2 = getDecimalString("Hello");
+ * // Throws Error: "Hello need to be hex-string or whole-number-string"
+ * ```
+ */
+export function getDecimalString(value) {
+    if (isHex(value)) {
+        return hexToDecimalString(value);
+    }
+    if (isStringWholeNumber(value)) {
+        return value;
+    }
+    throw new Error(`${value} need to be hex-string or whole-number-string`);
+}
+/**
+ * Convert string to hexadecimal string
+ * @returns format: hex-string
+ * @example
+ * ```typescript
+ * const result = getHexString("123");
+ * // result = "0x7b"
+ *
+ * const result2 = getHexString("Hello");
+ * // Throws Error: Hello need to be hex-string or whole-number-string
+ * ```
+ */
+export function getHexString(value) {
+    if (isHex(value)) {
+        return value;
+    }
+    if (isStringWholeNumber(value)) {
+        return toHexString(value);
+    }
+    throw new Error(`${value} need to be hex-string or whole-number-string`);
+}
+/**
+ * Convert string array to hex-string array
+ * @returns format: hex-string array
+ */
+export function getHexStringArray(value) {
+    return value.map((el) => getHexString(el));
+}
+/**
+ * Convert boolean to "0" or "1"
+ * @param value The boolean value to be converted.
+ * @returns {boolean} Returns true if the value is a number, otherwise returns false.
+ * @example
+ * ```typescript
+ * const result = toCairoBool(true);
+ * // result ="1"
+ *
+ * const result2 = toCairoBool(false);
+ * // result2 = "0"
+ * ```
+ */
+export const toCairoBool = (value) => (+value).toString();
+/**
+ * Convert hex-string to an array of Bytes (Uint8Array)
+ * @param value hex-string
+ */
+export function hexToBytes(value) {
+    if (!isHex(value))
+        throw new Error(`${value} need to be a hex-string`);
+    let adaptedValue = removeHexPrefix(value);
+    if (adaptedValue.length % 2 !== 0) {
+        adaptedValue = `0${adaptedValue}`;
+    }
+    return hexToBytesNoble(adaptedValue);
+}
+/**
+ *
+ * @param number value to be increased
+ * @param percent integer as percent ex. 50 for 50%
+ * @returns increased value
+ */
+export function addPercent(number, percent) {
+    const bigIntNum = BigInt(number);
+    return bigIntNum + (bigIntNum * BigInt(percent)) / 100n;
+}
+/**
+ * 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.
+ */
+export 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.
+ */
+export function isBoolean(value) {
+    return typeof value === 'boolean';
+}

package/js/src/src/static_dependencies/starknet/utils/selector.d.ts

@@ -0,0 +1,48 @@
+import { BigNumberish } from '../types/index.js';
+/**
+ * Calculate hex-string keccak hash for a given BigNumberish
+ *
+ * BigNumberish -> hex-string keccak hash
+ * @returns format: hex-string
+ */
+export declare function keccakBn(value: BigNumberish): string;
+/**
+ * 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
+ */
+export declare function starknetKeccak(str: string): bigint;
+/**
+ * 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'
+ */
+export declare function getSelectorFromName(funcName: string): string;
+/**
+ * Calculate hex-string selector from abi-function-name, decimal string or hex string
+ *
+ * ('abi-function-name' or dec-string or hex-string) -> hex-string selector
+ *
+ * @param value hex-string | dec-string | ascii-string
+ * @returns format: hex-string
+ * @example
+ * ```typescript
+ * const selector: string = getSelector("myFunction");
+ * // selector = "0x7e44bafo"
+ *
+ * const selector1: string = getSelector("0x123abc");
+ * // selector1 = "0x123abc"
+ *
+ * const selector2: string = getSelector("123456");
+ * // selector2 = "0x1e240"
+ * ```
+ */
+export declare function getSelector(value: string): string;

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

@@ -0,0 +1,85 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+import { keccak } from '../../scure-starknet/index.js';
+import { MASK_250 } from '../constants.js';
+import { addHexPrefix, removeHexPrefix, utf8ToArray } from './encode.js';
+import { hexToBytes, isHex, isStringWholeNumber, toHex, toHexString } from './num.js';
+/**
+ * Calculate hex-string keccak hash for a given BigNumberish
+ *
+ * BigNumberish -> hex-string keccak hash
+ * @returns format: hex-string
+ */
+export function keccakBn(value) {
+    const hexWithoutPrefix = removeHexPrefix(toHex(BigInt(value)));
+    const evenHex = hexWithoutPrefix.length % 2 === 0 ? hexWithoutPrefix : `0${hexWithoutPrefix}`;
+    return addHexPrefix(keccak(hexToBytes(addHexPrefix(evenHex))).toString(16));
+}
+/**
+ * Calculate hex-string keccak hash for a given string
+ *
+ * String -> hex-string keccak hash
+ * @returns format: hex-string
+ */
+function keccakHex(str) {
+    return addHexPrefix(keccak(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
+ */
+export function starknetKeccak(str) {
+    const hash = BigInt(keccakHex(str));
+    // eslint-disable-next-line no-bitwise
+    return hash & 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'
+ */
+export function getSelectorFromName(funcName) {
+    // sometimes BigInteger pads the hex string with zeros, which is not allowed in the starknet api
+    return toHex(starknetKeccak(funcName));
+}
+/**
+ * Calculate hex-string selector from abi-function-name, decimal string or hex string
+ *
+ * ('abi-function-name' or dec-string or hex-string) -> hex-string selector
+ *
+ * @param value hex-string | dec-string | ascii-string
+ * @returns format: hex-string
+ * @example
+ * ```typescript
+ * const selector: string = getSelector("myFunction");
+ * // selector = "0x7e44bafo"
+ *
+ * const selector1: string = getSelector("0x123abc");
+ * // selector1 = "0x123abc"
+ *
+ * const selector2: string = getSelector("123456");
+ * // selector2 = "0x1e240"
+ * ```
+ */
+export function getSelector(value) {
+    if (isHex(value)) {
+        return value;
+    }
+    if (isStringWholeNumber(value)) {
+        return toHexString(value);
+    }
+    return getSelectorFromName(value);
+}

package/js/src/src/static_dependencies/starknet/utils/shortString.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Test if string contains only ASCII characters (string can be ascii text)
+ */
+export declare function isASCII(str: string): boolean;
+/**
+ * Test if string is a Cairo short string (string has less or equal 31 characters)
+ */
+export declare function isShortString(str: string): boolean;
+/**
+ * Test if string contains only numbers (string can be converted to decimal number)
+ */
+export declare function isDecimalString(str: string): boolean;
+/**
+ * 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.
+ */
+export declare function isString(value: unknown): value is string;
+/**
+ * Test if value is a free-from string text, and not a hex string or number string
+ */
+export declare function isText(val: any): boolean;
+/**
+ * Test if value is short text
+ */
+export declare const isShortText: (val: any) => boolean;
+/**
+ * Test if value is long text
+ */
+export declare const isLongText: (val: any) => boolean;
+/**
+ * Split long text into short strings
+ */
+export declare function splitLongString(longStr: string): string[];
+/**
+ * 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")
+ * ```
+ */
+export declare function encodeShortString(str: string): string;
+/**
+ * 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")
+ * ```
+ */
+export declare function decodeShortString(str: string): string;