ccxt 4.3.69 → 4.3.71

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

@@ -0,0 +1,265 @@
+// ----------------------------------------------------------------------------
+
+// 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 { StarknetChainId, ZERO } from '../constants.js';
+import { tuple } from './calldata/cairo.js';
+import { CairoCustomEnum } from './calldata/enum/CairoCustomEnum.js';
+/* eslint-disable no-param-reassign */
+const basicAlphabet = 'abcdefghijklmnopqrstuvwxyz0123456789-';
+const basicSizePlusOne = BigInt(basicAlphabet.length + 1);
+const bigAlphabet = '这来';
+const basicAlphabetSize = BigInt(basicAlphabet.length);
+const bigAlphabetSize = BigInt(bigAlphabet.length);
+const bigAlphabetSizePlusOne = BigInt(bigAlphabet.length + 1);
+function extractStars(str) {
+    let k = 0;
+    while (str.endsWith(bigAlphabet[bigAlphabet.length - 1])) {
+        str = str.substring(0, str.length - 1);
+        k += 1;
+    }
+    return [str, k];
+}
+/**
+ * Decodes an array of BigInts into a string using the given algorithm.
+ * @param {bigint[]} encoded - The encoded array of BigInts.
+ * @return {string} The decoded string.
+ */
+export function useDecoded(encoded) {
+    let decoded = '';
+    encoded.forEach((subdomain) => {
+        while (subdomain !== ZERO) {
+            const code = subdomain % basicSizePlusOne;
+            subdomain /= basicSizePlusOne;
+            if (code === BigInt(basicAlphabet.length)) {
+                const nextSubdomain = subdomain / bigAlphabetSizePlusOne;
+                if (nextSubdomain === ZERO) {
+                    const code2 = subdomain % bigAlphabetSizePlusOne;
+                    subdomain = nextSubdomain;
+                    if (code2 === ZERO)
+                        decoded += basicAlphabet[0];
+                    else
+                        decoded += bigAlphabet[Number(code2) - 1];
+                }
+                else {
+                    const code2 = subdomain % bigAlphabetSize;
+                    decoded += bigAlphabet[Number(code2)];
+                    subdomain /= bigAlphabetSize;
+                }
+            }
+            else
+                decoded += basicAlphabet[Number(code)];
+        }
+        const [str, k] = extractStars(decoded);
+        if (k)
+            decoded =
+                str +
+                    (k % 2 === 0
+                        ? bigAlphabet[bigAlphabet.length - 1].repeat(k / 2 - 1) +
+                            bigAlphabet[0] +
+                            basicAlphabet[1]
+                        : bigAlphabet[bigAlphabet.length - 1].repeat((k - 1) / 2 + 1));
+        decoded += '.';
+    });
+    if (!decoded) {
+        return decoded;
+    }
+    return decoded.concat('stark');
+}
+/**
+ * Encodes a string into a bigint value.
+ *
+ * @param {string} decoded - The string to be encoded.
+ * @returns {bigint} - The encoded bigint value.
+ */
+export function useEncoded(decoded) {
+    let encoded = BigInt(0);
+    let multiplier = BigInt(1);
+    if (decoded.endsWith(bigAlphabet[0] + basicAlphabet[1])) {
+        const [str, k] = extractStars(decoded.substring(0, decoded.length - 2));
+        decoded = str + bigAlphabet[bigAlphabet.length - 1].repeat(2 * (k + 1));
+    }
+    else {
+        const [str, k] = extractStars(decoded);
+        if (k)
+            decoded = str + bigAlphabet[bigAlphabet.length - 1].repeat(1 + 2 * (k - 1));
+    }
+    for (let i = 0; i < decoded.length; i += 1) {
+        const char = decoded[i];
+        const index = basicAlphabet.indexOf(char);
+        const bnIndex = BigInt(basicAlphabet.indexOf(char));
+        if (index !== -1) {
+            // add encoded + multiplier * index
+            if (i === decoded.length - 1 && decoded[i] === basicAlphabet[0]) {
+                encoded += multiplier * basicAlphabetSize;
+                multiplier *= basicSizePlusOne;
+                // add 0
+                multiplier *= basicSizePlusOne;
+            }
+            else {
+                encoded += multiplier * bnIndex;
+                multiplier *= basicSizePlusOne;
+            }
+        }
+        else if (bigAlphabet.indexOf(char) !== -1) {
+            // add encoded + multiplier * (basicAlphabetSize)
+            encoded += multiplier * basicAlphabetSize;
+            multiplier *= basicSizePlusOne;
+            // add encoded + multiplier * index
+            const newid = (i === decoded.length - 1 ? 1 : 0) + bigAlphabet.indexOf(char);
+            encoded += multiplier * BigInt(newid);
+            multiplier *= bigAlphabetSize;
+        }
+    }
+    return encoded;
+}
+/**
+ * Returns the Starknet ID contract address based on the provided chain ID.
+ *
+ * @param {StarknetChainId} chainId - The chain ID of the Starknet network.
+ * @return {string} The Starknet ID contract address.
+ * @throws {Error} Throws an error if the Starknet ID contract is not deployed on the network.
+ */
+export function getStarknetIdContract(chainId) {
+    switch (chainId) {
+        case StarknetChainId.SN_MAIN:
+            return "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678" /* StarknetIdContract.MAINNET */;
+        case StarknetChainId.SN_SEPOLIA:
+            return "0x0707f09bc576bd7cfee59694846291047e965f4184fe13dac62c56759b3b6fa7" /* StarknetIdContract.TESTNET_SEPOLIA */;
+        default:
+            throw new Error('Starknet.id is not yet deployed on this network');
+    }
+}
+/**
+ * Returns the Starknet ID identity contract address for the given chain ID.
+ *
+ * @param {StarknetChainId} chainId - The chain ID for the specified network.
+ *
+ * @return {string} - The Starknet ID identity contract address for the specified network.
+ *
+ * @throws {Error} - If the Starknet ID verifier contract is not deployed on the network.
+ */
+export function getStarknetIdIdentityContract(chainId) {
+    switch (chainId) {
+        case StarknetChainId.SN_MAIN:
+            return "0x05dbdedc203e92749e2e746e2d40a768d966bd243df04a6b712e222bc040a9af" /* StarknetIdIdentityContract.MAINNET */;
+        case StarknetChainId.SN_SEPOLIA:
+            return "0x070DF8B4F5cb2879f8592849fA8f3134da39d25326B8558cc9C8FE8D47EA3A90" /* StarknetIdIdentityContract.TESTNET_SEPOLIA */;
+        default:
+            throw new Error('Starknet.id verifier contract is not yet deployed on this network');
+    }
+}
+export const StarknetIdMulticallContract = '0x034ffb8f4452df7a613a0210824d6414dbadcddce6c6e19bf4ddc9e22ce5f970';
+/**
+ * Returns the Starknet.id multicall contract address based on the provided chainId.
+ *
+ * @param {StarknetChainId} chainId - The chainId of the network.
+ * @return {string} - The address of the Starknet.id multicall contract.
+ * @throws {Error} - If the Starknet.id multicall contract is not deployed on the network.
+ */
+export function getStarknetIdMulticallContract(chainId) {
+    switch (chainId) {
+        case StarknetChainId.SN_MAIN:
+            return StarknetIdMulticallContract;
+        case StarknetChainId.SN_SEPOLIA:
+            return StarknetIdMulticallContract;
+        default:
+            throw new Error('Starknet.id multicall contract is not yet deployed on this network');
+    }
+}
+/**
+ * Returns the address of the Starknet ID Verifier contract based on the specified chain ID.
+ *
+ * @param {StarknetChainId} chainId - The ID of the Starknet chain.
+ * @return {string} - The address of the Starknet ID Verifier contract.
+ * @throws {Error} - If the Starknet ID Verifier contract is not deployed on the specified network.
+ */
+export function getStarknetIdVerifierContract(chainId) {
+    switch (chainId) {
+        case StarknetChainId.SN_MAIN:
+            return "0x07d14dfd8ee95b41fce179170d88ba1f0d5a512e13aeb232f19cfeec0a88f8bf" /* StarknetIdVerifierContract.MAINNET */;
+        case StarknetChainId.SN_SEPOLIA:
+            return "0x0182EcE8173C216A395f4828e1523541b7e3600bf190CB252E1a1A0cE219d184" /* StarknetIdVerifierContract.TESTNET_SEPOLIA */;
+        default:
+            throw new Error('Starknet.id verifier contract is not yet deployed on this network');
+    }
+}
+/**
+ * Retrieves the contract address of the Starknet.id profile picture verifier contract based on the given chain ID.
+ *
+ * @param {StarknetChainId} chainId - The chain ID of the network.
+ * @returns {string} - The contract address of the Starknet.id profile picture verifier contract.
+ * @throws {Error} - Throws an error if the Starknet.id profile picture verifier contract is not yet deployed on the network.
+ */
+export function getStarknetIdPfpContract(chainId) {
+    switch (chainId) {
+        case StarknetChainId.SN_MAIN:
+            return "0x070aaa20ec4a46da57c932d9fd89ca5e6bb9ca3188d3df361a32306aff7d59c7" /* StarknetIdPfpContract.MAINNET */;
+        case StarknetChainId.SN_SEPOLIA:
+            return "0x058061bb6bdc501eE215172c9f87d557C1E0f466dC498cA81b18f998Bf1362b2" /* StarknetIdPfpContract.TESTNET_SEPOLIA */;
+        default:
+            throw new Error('Starknet.id profile picture verifier contract is not yet deployed on this network');
+    }
+}
+/**
+ * Retrieves the Starknet ID Proof of Personhood (IdPop) verifier contract address for the given chain ID.
+ *
+ * @param {StarknetChainId} chainId - The chain ID of the Starknet network.
+ * @return {string} - The Starknet ID Pop contract address.
+ * @throws {Error} - If the Starknet ID Pop contract is not deployed on the specified network.
+ */
+export function getStarknetIdPopContract(chainId) {
+    switch (chainId) {
+        case StarknetChainId.SN_MAIN:
+            return "0x0293eb2ba9862f762bd3036586d5755a782bd22e6f5028320f1d0405fd47bff4" /* StarknetIdPopContract.MAINNET */;
+        case StarknetChainId.SN_SEPOLIA:
+            return "0x0023FE3b845ed5665a9eb3792bbB17347B490EE4090f855C1298d03BB5F49B49" /* StarknetIdPopContract.TESTNET_SEPOLIA */;
+        default:
+            throw new Error('Starknet.id proof of personhood verifier contract is not yet deployed on this network');
+    }
+}
+/**
+ * Executes a method and returns a CairoCustomEnum object.
+ *
+ * Functions to build CairoCustomEnum for multicall contracts
+ * @param {Object} staticEx - An optional object defining the "Static" value of the CairoCustomEnum.
+ * @param {number[]} ifEqual - An optional array defining the "IfEqual" value of the CairoCustomEnum.
+ * @param {number[]} ifNotEqual - An optional array defining the "IfNotEqual" value of the CairoCustomEnum.
+ * @return {CairoCustomEnum} - The created CairoCustomEnum object.
+ */
+export function execution(staticEx, ifEqual = undefined, ifNotEqual = undefined) {
+    return new CairoCustomEnum({
+        Static: staticEx,
+        IfEqual: ifEqual ? tuple(ifEqual[0], ifEqual[1], ifEqual[2]) : undefined,
+        IfNotEqual: ifNotEqual ? tuple(ifNotEqual[0], ifNotEqual[1], ifNotEqual[2]) : undefined,
+    });
+}
+/**
+ * Creates a new instance of CairoCustomEnum.
+ *
+ * @param {BigNumberish | undefined} hardcoded - The hardcoded value for the CairoCustomEnum.
+ * @param {number[] | undefined} reference - The reference array for the CairoCustomEnum.
+ * @returns {CairoCustomEnum} The new instance of CairoCustomEnum.
+ */
+export function dynamicFelt(hardcoded, reference = undefined) {
+    return new CairoCustomEnum({
+        Hardcoded: hardcoded,
+        Reference: reference ? tuple(reference[0], reference[1]) : undefined,
+    });
+}
+/**
+ * Creates a new instance of CairoCustomEnum with the given parameters.
+ * @param {BigNumberish | undefined} hardcoded - The hardcoded value.
+ * @param {BigNumberish[] | undefined} [reference] - The reference value (optional).
+ * @param {BigNumberish[] | undefined} [arrayReference] - The array reference value (optional).
+ * @return {CairoCustomEnum} - The new instance of CairoCustomEnum.
+ */
+export function dynamicCallData(hardcoded, reference = undefined, arrayReference = undefined) {
+    return new CairoCustomEnum({
+        Hardcoded: hardcoded,
+        Reference: reference ? tuple(reference[0], reference[1]) : undefined,
+        ArrayReference: arrayReference ? tuple(arrayReference[0], arrayReference[1]) : undefined,
+    });
+}

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

@@ -0,0 +1,54 @@
+import { BigNumberish, TypedDataRevision as Revision, StarknetMerkleType, StarknetType, TypedData } from '../types/index.js';
+/** @deprecated prefer importing from 'types' over 'typedData' */
+interface Context {
+    parent?: string;
+    key?: string;
+}
+/**
+ * Prepares the selector for use.
+ *
+ * @param {string} selector - The selector to be prepared.
+ * @returns {string} The prepared selector.
+ */
+export declare function prepareSelector(selector: string): string;
+/**
+ * Checks if the given Starknet type is a Merkle tree type.
+ *
+ * @param {StarknetType} type - The StarkNet type to check.
+ *
+ * @returns {boolean} - True if the type is a Merkle tree type, false otherwise.
+ */
+export declare function isMerkleTreeType(type: StarknetType): type is StarknetMerkleType;
+/**
+ * Get the dependencies of a struct type. If a struct has the same dependency multiple times, it's only included once
+ * in the resulting array.
+ */
+export declare function getDependencies(types: TypedData['types'], type: string, dependencies?: string[], contains?: string, revision?: Revision): string[];
+/**
+ * Encode a type to a string. All dependent types are alphabetically sorted.
+ */
+export declare function encodeType(types: TypedData['types'], type: string, revision?: Revision): string;
+/**
+ * Get a type string as hash.
+ */
+export declare function getTypeHash(types: TypedData['types'], type: string, revision?: Revision): string;
+/**
+ * Encodes a single value to an ABI serialisable string, number or Buffer. Returns the data as tuple, which consists of
+ * an array of ABI compatible types, and an array of corresponding values.
+ */
+export declare function encodeValue(types: TypedData['types'], type: string, data: unknown, ctx?: Context, revision?: Revision): [string, string];
+/**
+ * Encode the data to an ABI encoded Buffer. The data should be a key -> value object with all the required values.
+ * All dependent types are automatically encoded.
+ */
+export declare function encodeData<T extends TypedData>(types: T['types'], type: string, data: T['message'], revision?: Revision): string[][];
+/**
+ * Get encoded data as a hash. The data should be a key -> value object with all the required values.
+ * All dependent types are automatically encoded.
+ */
+export declare function getStructHash<T extends TypedData>(types: T['types'], type: string, data: T['message'], revision?: Revision): string;
+/**
+ * Get the SNIP-12 encoded message to sign, from the typedData object.
+ */
+export declare function getMessageHash(typedData: TypedData, account: BigNumberish): string;
+export {};

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

@@ -0,0 +1,321 @@
+// ----------------------------------------------------------------------------
+
+// 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
+
+/* eslint-disable no-param-reassign */
+import { PRIME, RANGE_FELT, RANGE_I128, RANGE_U128 } from '../constants.js';
+import { TypedDataRevision as Revision, } from '../types/index.js';
+import assert from './assert.js';
+import { byteArrayFromString } from './calldata/byteArray.js';
+import { computePedersenHash, computePedersenHashOnElements, computePoseidonHash, computePoseidonHashOnElements, getSelectorFromName, } from './hash/index.js';
+import { MerkleTree } from './merkle.js';
+import { isHex, toHex } from './num.js';
+import { encodeShortString, isString } from './shortString.js';
+const presetTypes = {
+    u256: JSON.parse('[{ "name": "low", "type": "u128" }, { "name": "high", "type": "u128" }]'),
+    TokenAmount: JSON.parse('[{ "name": "token_address", "type": "ContractAddress" }, { "name": "amount", "type": "u256" }]'),
+    NftId: JSON.parse('[{ "name": "collection_address", "type": "ContractAddress" }, { "name": "token_id", "type": "u256" }]'),
+};
+const revisionConfiguration = {
+    [Revision.Active]: {
+        domain: 'StarknetDomain',
+        hashMethod: computePoseidonHashOnElements,
+        hashMerkleMethod: computePoseidonHash,
+        escapeTypeString: (s) => `"${s}"`,
+        presetTypes,
+    },
+    [Revision.Legacy]: {
+        domain: 'StarkNetDomain',
+        hashMethod: computePedersenHashOnElements,
+        hashMerkleMethod: computePedersenHash,
+        escapeTypeString: (s) => s,
+        presetTypes: {},
+    },
+};
+function assertRange(data, type, { min, max }) {
+    const value = BigInt(data);
+    assert(value >= min && value <= max, `${value} (${type}) is out of bounds [${min}, ${max}]`);
+}
+function identifyRevision({ types, domain }) {
+    if (revisionConfiguration[Revision.Active].domain in types && domain.revision === Revision.Active)
+        return Revision.Active;
+    if (revisionConfiguration[Revision.Legacy].domain in types &&
+        (domain.revision ?? Revision.Legacy) === Revision.Legacy)
+        return Revision.Legacy;
+    return undefined;
+}
+function getHex(value) {
+    try {
+        return toHex(value);
+    }
+    catch (e) {
+        if (isString(value)) {
+            return toHex(encodeShortString(value));
+        }
+        throw new Error(`Invalid BigNumberish: ${value}`);
+    }
+}
+/**
+ * Validates that `data` matches the EIP-712 JSON schema.
+ */
+function validateTypedData(data) {
+    const typedData = data;
+    return Boolean(typedData.message && typedData.primaryType && typedData.types && identifyRevision(typedData));
+}
+/**
+ * Prepares the selector for use.
+ *
+ * @param {string} selector - The selector to be prepared.
+ * @returns {string} The prepared selector.
+ */
+export function prepareSelector(selector) {
+    return isHex(selector) ? selector : getSelectorFromName(selector);
+}
+/**
+ * Checks if the given Starknet type is a Merkle tree type.
+ *
+ * @param {StarknetType} type - The StarkNet type to check.
+ *
+ * @returns {boolean} - True if the type is a Merkle tree type, false otherwise.
+ */
+export function isMerkleTreeType(type) {
+    return type.type === 'merkletree';
+}
+/**
+ * Get the dependencies of a struct type. If a struct has the same dependency multiple times, it's only included once
+ * in the resulting array.
+ */
+export function getDependencies(types, type, dependencies = [], contains = '', revision = Revision.Legacy) {
+    // Include pointers (struct arrays)
+    if (type[type.length - 1] === '*') {
+        type = type.slice(0, -1);
+    }
+    else if (revision === Revision.Active) {
+        // enum base
+        if (type === 'enum') {
+            type = contains;
+        }
+        // enum element types
+        else if (type.match(/^\(.*\)$/)) {
+            type = type.slice(1, -1);
+        }
+    }
+    if (dependencies.includes(type) || !types[type]) {
+        return dependencies;
+    }
+    return [
+        type,
+        ...types[type].reduce((previous, t) => [
+            ...previous,
+            ...getDependencies(types, t.type, previous, t.contains, revision).filter((dependency) => !previous.includes(dependency)),
+        ], []),
+    ];
+}
+function getMerkleTreeType(types, ctx) {
+    if (ctx.parent && ctx.key) {
+        const parentType = types[ctx.parent];
+        const merkleType = parentType.find((t) => t.name === ctx.key);
+        const isMerkleTree = isMerkleTreeType(merkleType);
+        if (!isMerkleTree) {
+            throw new Error(`${ctx.key} is not a merkle tree`);
+        }
+        if (merkleType.contains.endsWith('*')) {
+            throw new Error(`Merkle tree contain property must not be an array but was given ${ctx.key}`);
+        }
+        return merkleType.contains;
+    }
+    return 'raw';
+}
+/**
+ * Encode a type to a string. All dependent types are alphabetically sorted.
+ */
+export function encodeType(types, type, revision = Revision.Legacy) {
+    const allTypes = revision === Revision.Active
+        ? { ...types, ...revisionConfiguration[revision].presetTypes }
+        : types;
+    const [primary, ...dependencies] = getDependencies(allTypes, type, undefined, undefined, revision);
+    const newTypes = !primary ? [] : [primary, ...dependencies.sort()];
+    const esc = revisionConfiguration[revision].escapeTypeString;
+    return newTypes
+        .map((dependency) => {
+        const dependencyElements = allTypes[dependency].map((t) => {
+            const targetType = t.type === 'enum' && revision === Revision.Active
+                ? t.contains
+                : t.type;
+            // parentheses handling for enum variant types
+            const typeString = targetType.match(/^\(.*\)$/)
+                ? `(${targetType
+                    .slice(1, -1)
+                    .split(',')
+                    .map((e) => (e ? esc(e) : e))
+                    .join(',')})`
+                : esc(targetType);
+            return `${esc(t.name)}:${typeString}`;
+        });
+        return `${esc(dependency)}(${dependencyElements})`;
+    })
+        .join('');
+}
+/**
+ * Get a type string as hash.
+ */
+export function getTypeHash(types, type, revision = Revision.Legacy) {
+    return getSelectorFromName(encodeType(types, type, revision));
+}
+/**
+ * Encodes a single value to an ABI serialisable string, number or Buffer. Returns the data as tuple, which consists of
+ * an array of ABI compatible types, and an array of corresponding values.
+ */
+export function encodeValue(types, type, data, ctx = {}, revision = Revision.Legacy) {
+    if (types[type]) {
+        return [type, getStructHash(types, type, data, revision)];
+    }
+    if (revisionConfiguration[revision].presetTypes[type]) {
+        return [
+            type,
+            getStructHash(revisionConfiguration[revision].presetTypes, type, data, revision),
+        ];
+    }
+    if (type.endsWith('*')) {
+        const hashes = data.map((entry) => encodeValue(types, type.slice(0, -1), entry, undefined, revision)[1]);
+        return [type, revisionConfiguration[revision].hashMethod(hashes)];
+    }
+    switch (type) {
+        case 'enum': {
+            if (revision === Revision.Active) {
+                const [variantKey, variantData] = Object.entries(data)[0];
+                const parentType = types[ctx.parent][0];
+                const enumType = types[parentType.contains];
+                const variantType = enumType.find((t) => t.name === variantKey);
+                const variantIndex = enumType.indexOf(variantType);
+                const encodedSubtypes = variantType.type
+                    .slice(1, -1)
+                    .split(',')
+                    .map((subtype, index) => {
+                    if (!subtype)
+                        return subtype;
+                    const subtypeData = variantData[index];
+                    return encodeValue(types, subtype, subtypeData, undefined, revision)[1];
+                });
+                return [
+                    type,
+                    revisionConfiguration[revision].hashMethod([variantIndex, ...encodedSubtypes]),
+                ];
+            } // else fall through to default
+            return [type, getHex(data)];
+        }
+        case 'merkletree': {
+            const merkleTreeType = getMerkleTreeType(types, ctx);
+            const structHashes = data.map((struct) => {
+                return encodeValue(types, merkleTreeType, struct, undefined, revision)[1];
+            });
+            const { root } = new MerkleTree(structHashes, revisionConfiguration[revision].hashMerkleMethod);
+            return ['felt', root];
+        }
+        case 'selector': {
+            return ['felt', prepareSelector(data)];
+        }
+        case 'string': {
+            if (revision === Revision.Active) {
+                const byteArray = byteArrayFromString(data);
+                const elements = [
+                    byteArray.data.length,
+                    ...byteArray.data,
+                    byteArray.pending_word,
+                    byteArray.pending_word_len,
+                ];
+                return [type, revisionConfiguration[revision].hashMethod(elements)];
+            } // else fall through to default
+            return [type, getHex(data)];
+        }
+        case 'i128': {
+            if (revision === Revision.Active) {
+                const value = BigInt(data);
+                assertRange(value, type, RANGE_I128);
+                return [type, getHex(value < 0n ? PRIME + value : value)];
+            } // else fall through to default
+            return [type, getHex(data)];
+        }
+        case 'timestamp':
+        case 'u128': {
+            if (revision === Revision.Active) {
+                assertRange(data, type, RANGE_U128);
+            } // else fall through to default
+            return [type, getHex(data)];
+        }
+        case 'felt':
+        case 'shortstring': {
+            // TODO: should 'shortstring' diverge into directly using encodeShortString()?
+            if (revision === Revision.Active) {
+                assertRange(getHex(data), type, RANGE_FELT);
+            } // else fall through to default
+            return [type, getHex(data)];
+        }
+        case 'ClassHash':
+        case 'ContractAddress': {
+            if (revision === Revision.Active) {
+                assertRange(data, type, RANGE_FELT);
+            } // else fall through to default
+            return [type, getHex(data)];
+        }
+        case 'bool': {
+            if (revision === Revision.Active) {
+                assert(typeof data === 'boolean', `Type mismatch for ${type} ${data}`);
+            } // else fall through to default
+            return [type, getHex(data)];
+        }
+        default: {
+            if (revision === Revision.Active) {
+                throw new Error(`Unsupported type: ${type}`);
+            }
+            return [type, getHex(data)];
+        }
+    }
+}
+/**
+ * Encode the data to an ABI encoded Buffer. The data should be a key -> value object with all the required values.
+ * All dependent types are automatically encoded.
+ */
+export function encodeData(types, type, data, revision = Revision.Legacy) {
+    const targetType = types[type] ?? revisionConfiguration[revision].presetTypes[type];
+    const [returnTypes, values] = targetType.reduce(([ts, vs], field) => {
+        if (data[field.name] === undefined ||
+            (data[field.name] === null && field.type !== 'enum')) {
+            throw new Error(`Cannot encode data: missing data for '${field.name}'`);
+        }
+        const value = data[field.name];
+        const ctx = { parent: type, key: field.name };
+        const [t, encodedValue] = encodeValue(types, field.type, value, ctx, revision);
+        return [
+            [...ts, t],
+            [...vs, encodedValue],
+        ];
+    }, [['felt'], [getTypeHash(types, type, revision)]]);
+    return [returnTypes, values];
+}
+/**
+ * Get encoded data as a hash. The data should be a key -> value object with all the required values.
+ * All dependent types are automatically encoded.
+ */
+export function getStructHash(types, type, data, revision = Revision.Legacy) {
+    return revisionConfiguration[revision].hashMethod(encodeData(types, type, data, revision)[1]);
+}
+/**
+ * Get the SNIP-12 encoded message to sign, from the typedData object.
+ */
+export function getMessageHash(typedData, account) {
+    if (!validateTypedData(typedData)) {
+        throw new Error('Typed data does not match JSON schema');
+    }
+    const revision = identifyRevision(typedData);
+    const { domain, hashMethod } = revisionConfiguration[revision];
+    const message = [
+        encodeShortString('StarkNet Message'),
+        getStructHash(typedData.types, domain, typedData.domain, revision),
+        account,
+        getStructHash(typedData.types, typedData.primaryType, typedData.message, revision),
+    ];
+    return hashMethod(message);
+}

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

@@ -0,0 +1,21 @@
+import { BigNumberish, Uint256 } from '../types/index.js';
+import { UINT_128_MAX, UINT_256_MAX } from './cairoDataTypes/uint256.js';
+/**
+ * @deprecated Legacy support Export
+ */
+export { UINT_128_MAX, UINT_256_MAX };
+/**
+ * Convert Uint256 to bigint
+ * Legacy support Export
+ */
+export declare function uint256ToBN(uint256: Uint256): bigint;
+/**
+ * Test BigNumberish is smaller or equal 2**256-1
+ * Legacy support Export
+ */
+export declare function isUint256(bn: BigNumberish): boolean;
+/**
+ * Convert BigNumberish (string | number | bigint) to Uint256 (hex)
+ * Legacy support Export
+ */
+export declare function bnToUint256(bn: BigNumberish): Uint256;