starknet 6.9.0 → 6.10.1

package/dist/utils/typedData.cjs

@@ -0,0 +1,285 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  prepareSelector: true,
+  isMerkleTreeType: true,
+  getDependencies: true,
+  encodeType: true,
+  getTypeHash: true,
+  encodeValue: true,
+  encodeData: true,
+  getStructHash: true,
+  getMessageHash: true
+};
+exports.encodeData = encodeData;
+exports.encodeType = encodeType;
+exports.encodeValue = encodeValue;
+exports.getDependencies = getDependencies;
+exports.getMessageHash = getMessageHash;
+exports.getStructHash = getStructHash;
+exports.getTypeHash = getTypeHash;
+exports.isMerkleTreeType = isMerkleTreeType;
+exports.prepareSelector = prepareSelector;
+var _constants = require("../constants.cjs");
+var _types = require("../types/index.cjs");
+var _assert = _interopRequireDefault(require("./assert.cjs"));
+var _byteArray = require("./calldata/byteArray.cjs");
+var _hash = require("./hash/index.cjs");
+var _merkle = require("./merkle.cjs");
+var _num = require("./num.cjs");
+var _shortString = require("./shortString.cjs");
+var _typedData = require("../types/typedData.cjs");
+Object.keys(_typedData).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _typedData[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _typedData[key];
+    }
+  });
+});
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+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 = {
+  [_types.TypedDataRevision.ACTIVE]: {
+    domain: "StarknetDomain",
+    hashMethod: _hash.computePoseidonHashOnElements,
+    hashMerkleMethod: _hash.computePoseidonHash,
+    escapeTypeString: s => `"${s}"`,
+    presetTypes
+  },
+  [_types.TypedDataRevision.LEGACY]: {
+    domain: "StarkNetDomain",
+    hashMethod: _hash.computePedersenHashOnElements,
+    hashMerkleMethod: _hash.computePedersenHash,
+    escapeTypeString: s => s,
+    presetTypes: {}
+  }
+};
+function assertRange(data, type, {
+  min,
+  max
+}) {
+  const value = BigInt(data);
+  (0, _assert.default)(value >= min && value <= max, `${value} (${type}) is out of bounds [${min}, ${max}]`);
+}
+function identifyRevision({
+  types,
+  domain
+}) {
+  if (revisionConfiguration[_types.TypedDataRevision.ACTIVE].domain in types && domain.revision === _types.TypedDataRevision.ACTIVE) return _types.TypedDataRevision.ACTIVE;
+  if (revisionConfiguration[_types.TypedDataRevision.LEGACY].domain in types && (domain.revision ?? _types.TypedDataRevision.LEGACY) === _types.TypedDataRevision.LEGACY) return _types.TypedDataRevision.LEGACY;
+  return void 0;
+}
+function getHex(value) {
+  try {
+    return (0, _num.toHex)(value);
+  } catch (e) {
+    if ((0, _shortString.isString)(value)) {
+      return (0, _num.toHex)((0, _shortString.encodeShortString)(value));
+    }
+    throw new Error(`Invalid BigNumberish: ${value}`);
+  }
+}
+function validateTypedData(data) {
+  const typedData = data;
+  return Boolean(typedData.message && typedData.primaryType && typedData.types && identifyRevision(typedData));
+}
+function prepareSelector(selector) {
+  return (0, _num.isHex)(selector) ? selector : (0, _hash.getSelectorFromName)(selector);
+}
+function isMerkleTreeType(type) {
+  return type.type === "merkletree";
+}
+function getDependencies(types, type, dependencies = [], contains = "", revision = _types.TypedDataRevision.LEGACY) {
+  if (type[type.length - 1] === "*") {
+    type = type.slice(0, -1);
+  } else if (revision === _types.TypedDataRevision.ACTIVE) {
+    if (type === "enum") {
+      type = contains;
+    } 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";
+}
+function encodeType(types, type, revision = _types.TypedDataRevision.LEGACY) {
+  const allTypes = revision === _types.TypedDataRevision.ACTIVE ? {
+    ...types,
+    ...revisionConfiguration[revision].presetTypes
+  } : types;
+  const [primary, ...dependencies] = getDependencies(allTypes, type, void 0, void 0, 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 === _types.TypedDataRevision.ACTIVE ? t.contains : t.type;
+      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("");
+}
+function getTypeHash(types, type, revision = _types.TypedDataRevision.LEGACY) {
+  return (0, _hash.getSelectorFromName)(encodeType(types, type, revision));
+}
+function encodeValue(types, type, data, ctx = {}, revision = _types.TypedDataRevision.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, void 0, revision)[1]);
+    return [type, revisionConfiguration[revision].hashMethod(hashes)];
+  }
+  switch (type) {
+    case "enum":
+      {
+        if (revision === _types.TypedDataRevision.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, void 0, revision)[1];
+          });
+          return [type, revisionConfiguration[revision].hashMethod([variantIndex, ...encodedSubtypes])];
+        }
+        return [type, getHex(data)];
+      }
+    case "merkletree":
+      {
+        const merkleTreeType = getMerkleTreeType(types, ctx);
+        const structHashes = data.map(struct => {
+          return encodeValue(types, merkleTreeType, struct, void 0, revision)[1];
+        });
+        const {
+          root
+        } = new _merkle.MerkleTree(structHashes, revisionConfiguration[revision].hashMerkleMethod);
+        return ["felt", root];
+      }
+    case "selector":
+      {
+        return ["felt", prepareSelector(data)];
+      }
+    case "string":
+      {
+        if (revision === _types.TypedDataRevision.ACTIVE) {
+          const byteArray = (0, _byteArray.byteArrayFromString)(data);
+          const elements = [byteArray.data.length, ...byteArray.data, byteArray.pending_word, byteArray.pending_word_len];
+          return [type, revisionConfiguration[revision].hashMethod(elements)];
+        }
+        return [type, getHex(data)];
+      }
+    case "i128":
+      {
+        if (revision === _types.TypedDataRevision.ACTIVE) {
+          const value = BigInt(data);
+          assertRange(value, type, _constants.RANGE_I128);
+          return [type, getHex(value < 0n ? _constants.PRIME + value : value)];
+        }
+        return [type, getHex(data)];
+      }
+    case "timestamp":
+    case "u128":
+      {
+        if (revision === _types.TypedDataRevision.ACTIVE) {
+          assertRange(data, type, _constants.RANGE_U128);
+        }
+        return [type, getHex(data)];
+      }
+    case "felt":
+    case "shortstring":
+      {
+        if (revision === _types.TypedDataRevision.ACTIVE) {
+          assertRange(getHex(data), type, _constants.RANGE_FELT);
+        }
+        return [type, getHex(data)];
+      }
+    case "ClassHash":
+    case "ContractAddress":
+      {
+        if (revision === _types.TypedDataRevision.ACTIVE) {
+          assertRange(data, type, _constants.RANGE_FELT);
+        }
+        return [type, getHex(data)];
+      }
+    case "bool":
+      {
+        if (revision === _types.TypedDataRevision.ACTIVE) {
+          (0, _assert.default)(typeof data === "boolean", `Type mismatch for ${type} ${data}`);
+        }
+        return [type, getHex(data)];
+      }
+    default:
+      {
+        if (revision === _types.TypedDataRevision.ACTIVE) {
+          throw new Error(`Unsupported type: ${type}`);
+        }
+        return [type, getHex(data)];
+      }
+  }
+}
+function encodeData(types, type, data, revision = _types.TypedDataRevision.LEGACY) {
+  const targetType = types[type] ?? revisionConfiguration[revision].presetTypes[type];
+  const [returnTypes, values] = targetType.reduce(([ts, vs], field) => {
+    if (data[field.name] === void 0 || 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];
+}
+function getStructHash(types, type, data, revision = _types.TypedDataRevision.LEGACY) {
+  return revisionConfiguration[revision].hashMethod(encodeData(types, type, data, revision)[1]);
+}
+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 = [(0, _shortString.encodeShortString)("StarkNet Message"), getStructHash(typedData.types, domain, typedData.domain, revision), account, getStructHash(typedData.types, typedData.primaryType, typedData.message, revision)];
+  return hashMethod(message);
+}

package/dist/utils/typedData.d.ts

@@ -0,0 +1,54 @@
+import { BigNumberish, TypedDataRevision as Revision, StarknetMerkleType, StarknetType, TypedData } from '../types';
+/** @deprecated prefer importing from 'types' over 'typedData' */
+export * from '../types/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;

package/dist/utils/typedData.mjs

@@ -0,0 +1,286 @@
+import { PRIME, RANGE_FELT, RANGE_I128, RANGE_U128 } from "../constants.mjs";
+import {
+  TypedDataRevision as Revision
+} from "../types/index.mjs";
+import assert from "./assert.mjs";
+import { byteArrayFromString } from "./calldata/byteArray.mjs";
+import {
+  computePedersenHash,
+  computePedersenHashOnElements,
+  computePoseidonHash,
+  computePoseidonHashOnElements,
+  getSelectorFromName
+} from "./hash/index.mjs";
+import { MerkleTree } from "./merkle.mjs";
+import { isHex, toHex } from "./num.mjs";
+import { encodeShortString, isString } from "./shortString.mjs";
+export * from "../types/typedData.mjs";
+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 void 0;
+}
+function getHex(value) {
+  try {
+    return toHex(value);
+  } catch (e) {
+    if (isString(value)) {
+      return toHex(encodeShortString(value));
+    }
+    throw new Error(`Invalid BigNumberish: ${value}`);
+  }
+}
+function validateTypedData(data) {
+  const typedData = data;
+  return Boolean(
+    typedData.message && typedData.primaryType && typedData.types && identifyRevision(typedData)
+  );
+}
+export function prepareSelector(selector) {
+  return isHex(selector) ? selector : getSelectorFromName(selector);
+}
+export function isMerkleTreeType(type) {
+  return type.type === "merkletree";
+}
+export function getDependencies(types, type, dependencies = [], contains = "", revision = Revision.LEGACY) {
+  if (type[type.length - 1] === "*") {
+    type = type.slice(0, -1);
+  } else if (revision === Revision.ACTIVE) {
+    if (type === "enum") {
+      type = contains;
+    } 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";
+}
+export function encodeType(types, type, revision = Revision.LEGACY) {
+  const allTypes = revision === Revision.ACTIVE ? { ...types, ...revisionConfiguration[revision].presetTypes } : types;
+  const [primary, ...dependencies] = getDependencies(
+    allTypes,
+    type,
+    void 0,
+    void 0,
+    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;
+      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("");
+}
+export function getTypeHash(types, type, revision = Revision.LEGACY) {
+  return getSelectorFromName(encodeType(types, type, revision));
+}
+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, void 0, 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, void 0, revision)[1];
+        });
+        return [
+          type,
+          revisionConfiguration[revision].hashMethod([variantIndex, ...encodedSubtypes])
+        ];
+      }
+      return [type, getHex(data)];
+    }
+    case "merkletree": {
+      const merkleTreeType = getMerkleTreeType(types, ctx);
+      const structHashes = data.map((struct) => {
+        return encodeValue(types, merkleTreeType, struct, void 0, 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)];
+      }
+      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)];
+      }
+      return [type, getHex(data)];
+    }
+    case "timestamp":
+    case "u128": {
+      if (revision === Revision.ACTIVE) {
+        assertRange(data, type, RANGE_U128);
+      }
+      return [type, getHex(data)];
+    }
+    case "felt":
+    case "shortstring": {
+      if (revision === Revision.ACTIVE) {
+        assertRange(getHex(data), type, RANGE_FELT);
+      }
+      return [type, getHex(data)];
+    }
+    case "ClassHash":
+    case "ContractAddress": {
+      if (revision === Revision.ACTIVE) {
+        assertRange(data, type, RANGE_FELT);
+      }
+      return [type, getHex(data)];
+    }
+    case "bool": {
+      if (revision === Revision.ACTIVE) {
+        assert(typeof data === "boolean", `Type mismatch for ${type} ${data}`);
+      }
+      return [type, getHex(data)];
+    }
+    default: {
+      if (revision === Revision.ACTIVE) {
+        throw new Error(`Unsupported type: ${type}`);
+      }
+      return [type, getHex(data)];
+    }
+  }
+}
+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] === void 0 || 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];
+}
+export function getStructHash(types, type, data, revision = Revision.LEGACY) {
+  return revisionConfiguration[revision].hashMethod(encodeData(types, type, data, revision)[1]);
+}
+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/dist/utils/uint256.cjs

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "UINT_128_MAX", {
+  enumerable: true,
+  get: function () {
+    return _uint.UINT_128_MAX;
+  }
+});
+Object.defineProperty(exports, "UINT_256_MAX", {
+  enumerable: true,
+  get: function () {
+    return _uint.UINT_256_MAX;
+  }
+});
+exports.bnToUint256 = bnToUint256;
+exports.isUint256 = isUint256;
+exports.uint256ToBN = uint256ToBN;
+var _uint = require("./cairoDataTypes/uint256.cjs");
+function uint256ToBN(uint256) {
+  return new _uint.CairoUint256(uint256).toBigInt();
+}
+function isUint256(bn) {
+  return _uint.CairoUint256.is(bn);
+}
+function bnToUint256(bn) {
+  return new _uint.CairoUint256(bn).toUint256HexString();
+}