starknet 6.9.0 → 6.10.1

package/dist/utils/fetchPonyfill.cjs

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _fetchCookie = _interopRequireDefault(require("fetch-cookie"));
+var _isomorphicFetch = _interopRequireDefault(require("isomorphic-fetch"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+module.exports = typeof window !== "undefined" && window.fetch ||
+// use buildin fetch in browser if available
+typeof global !== "undefined" && (0, _fetchCookie.default)(global.fetch) ||
+// use buildin fetch in node, react-native and service worker if available
+_isomorphicFetch.default;

package/dist/utils/fetchPonyfill.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/utils/fetchPonyfill.mjs

@@ -0,0 +1,5 @@
+import makeFetchCookie from "fetch-cookie";
+import isomorphicFetch from "isomorphic-fetch";
+export default typeof window !== "undefined" && window.fetch || // use buildin fetch in browser if available
+typeof global !== "undefined" && makeFetchCookie(global.fetch) || // use buildin fetch in node, react-native and service worker if available
+isomorphicFetch;

package/dist/utils/hash/classHash.cjs

@@ -0,0 +1,151 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculateContractAddressFromHash = calculateContractAddressFromHash;
+exports.computeCompiledClassHash = computeCompiledClassHash;
+exports.computeContractClassHash = computeContractClassHash;
+exports.computeHashOnElements = computeHashOnElements;
+exports.computeHintedClassHash = computeHintedClassHash;
+exports.computeLegacyContractClassHash = computeLegacyContractClassHash;
+exports.computePedersenHash = computePedersenHash;
+exports.computePedersenHashOnElements = void 0;
+exports.computePoseidonHash = computePoseidonHash;
+exports.computePoseidonHashOnElements = computePoseidonHashOnElements;
+exports.computeSierraContractClassHash = computeSierraContractClassHash;
+exports.formatSpaces = formatSpaces;
+exports.hashByteCodeSegments = hashByteCodeSegments;
+var _starknet = require("@scure/starknet");
+var _constants = require("../../constants.cjs");
+var _calldata = require("../calldata/index.cjs");
+var _cairo = require("../calldata/cairo.cjs");
+var _ec = require("../ec.cjs");
+var _encode = require("../encode.cjs");
+var _json = require("../json.cjs");
+var _num = require("../num.cjs");
+var _shortString = require("../shortString.cjs");
+function computePedersenHash(a, b) {
+  return _ec.starkCurve.pedersen(BigInt(a), BigInt(b));
+}
+function computePoseidonHash(a, b) {
+  return (0, _num.toHex)(_ec.starkCurve.poseidonHash(BigInt(a), BigInt(b)));
+}
+function computeHashOnElements(data) {
+  return [...data, data.length].reduce((x, y) => _ec.starkCurve.pedersen(BigInt(x), BigInt(y)), 0).toString();
+}
+const computePedersenHashOnElements = exports.computePedersenHashOnElements = computeHashOnElements;
+function computePoseidonHashOnElements(data) {
+  return (0, _num.toHex)((0, _starknet.poseidonHashMany)(data.map(x => BigInt(x))));
+}
+function calculateContractAddressFromHash(salt, classHash, constructorCalldata, deployerAddress) {
+  const compiledCalldata = _calldata.CallData.compile(constructorCalldata);
+  const constructorCalldataHash = computeHashOnElements(compiledCalldata);
+  const CONTRACT_ADDRESS_PREFIX = (0, _cairo.felt)("0x535441524b4e45545f434f4e54524143545f41444452455353");
+  const hash = computeHashOnElements([CONTRACT_ADDRESS_PREFIX, deployerAddress, salt, classHash, constructorCalldataHash]);
+  return (0, _num.toHex)(BigInt(hash) % _constants.ADDR_BOUND);
+}
+function nullSkipReplacer(key, value) {
+  if (key === "attributes" || key === "accessible_scopes") {
+    return Array.isArray(value) && value.length === 0 ? void 0 : value;
+  }
+  if (key === "debug_info") {
+    return null;
+  }
+  return value === null ? void 0 : value;
+}
+function formatSpaces(json) {
+  let insideQuotes = false;
+  const newString = [];
+  for (const char of json) {
+    if (char === '"' && (newString.length > 0 && newString.slice(-1)[0] === "\\") === false) {
+      insideQuotes = !insideQuotes;
+    }
+    if (insideQuotes) {
+      newString.push(char);
+    } else {
+      newString.push(char === ":" ? ": " : char === "," ? ", " : char);
+    }
+  }
+  return newString.join("");
+}
+function computeHintedClassHash(compiledContract) {
+  const {
+    abi,
+    program
+  } = compiledContract;
+  const contractClass = {
+    abi,
+    program
+  };
+  const serializedJson = formatSpaces((0, _json.stringify)(contractClass, nullSkipReplacer));
+  return (0, _encode.addHexPrefix)(_ec.starkCurve.keccak((0, _encode.utf8ToArray)(serializedJson)).toString(16));
+}
+function computeLegacyContractClassHash(contract) {
+  const compiledContract = (0, _shortString.isString)(contract) ? (0, _json.parse)(contract) : contract;
+  const apiVersion = (0, _num.toHex)(_constants.API_VERSION);
+  const externalEntryPointsHash = computeHashOnElements(compiledContract.entry_points_by_type.EXTERNAL.flatMap(e => [e.selector, e.offset]));
+  const l1HandlerEntryPointsHash = computeHashOnElements(compiledContract.entry_points_by_type.L1_HANDLER.flatMap(e => [e.selector, e.offset]));
+  const constructorEntryPointHash = computeHashOnElements(compiledContract.entry_points_by_type.CONSTRUCTOR.flatMap(e => [e.selector, e.offset]));
+  const builtinsHash = computeHashOnElements(compiledContract.program.builtins.map(s => (0, _shortString.encodeShortString)(s)));
+  const hintedClassHash = computeHintedClassHash(compiledContract);
+  const dataHash = computeHashOnElements(compiledContract.program.data);
+  return computeHashOnElements([apiVersion, externalEntryPointsHash, l1HandlerEntryPointsHash, constructorEntryPointHash, builtinsHash, hintedClassHash, dataHash]);
+}
+function hashBuiltins(builtins) {
+  return (0, _starknet.poseidonHashMany)(builtins.flatMap(it => {
+    return BigInt((0, _shortString.encodeShortString)(it));
+  }));
+}
+function hashEntryPoint(data) {
+  const base = data.flatMap(it => {
+    return [BigInt(it.selector), BigInt(it.offset), hashBuiltins(it.builtins)];
+  });
+  return (0, _starknet.poseidonHashMany)(base);
+}
+function hashByteCodeSegments(casm) {
+  const byteCode = casm.bytecode.map(n => BigInt(n));
+  const bytecodeSegmentLengths = casm.bytecode_segment_lengths ?? [];
+  let segmentStart = 0;
+  const hashLeaves = bytecodeSegmentLengths.flatMap(len => {
+    const segment = byteCode.slice(segmentStart, segmentStart += len);
+    return [BigInt(len), (0, _starknet.poseidonHashMany)(segment)];
+  });
+  return 1n + (0, _starknet.poseidonHashMany)(hashLeaves);
+}
+function computeCompiledClassHash(casm) {
+  const COMPILED_CLASS_VERSION = "COMPILED_CLASS_V1";
+  const compiledClassVersion = BigInt((0, _shortString.encodeShortString)(COMPILED_CLASS_VERSION));
+  const externalEntryPointsHash = hashEntryPoint(casm.entry_points_by_type.EXTERNAL);
+  const l1Handlers = hashEntryPoint(casm.entry_points_by_type.L1_HANDLER);
+  const constructor = hashEntryPoint(casm.entry_points_by_type.CONSTRUCTOR);
+  const bytecode = casm.bytecode_segment_lengths ? hashByteCodeSegments(casm) : (0, _starknet.poseidonHashMany)(casm.bytecode.map(it => BigInt(it)));
+  return (0, _num.toHex)((0, _starknet.poseidonHashMany)([compiledClassVersion, externalEntryPointsHash, l1Handlers, constructor, bytecode]));
+}
+function hashEntryPointSierra(data) {
+  const base = data.flatMap(it => {
+    return [BigInt(it.selector), BigInt(it.function_idx)];
+  });
+  return (0, _starknet.poseidonHashMany)(base);
+}
+function hashAbi(sierra) {
+  const indentString = formatSpaces((0, _json.stringify)(sierra.abi, null));
+  return BigInt((0, _encode.addHexPrefix)(_ec.starkCurve.keccak((0, _encode.utf8ToArray)(indentString)).toString(16)));
+}
+function computeSierraContractClassHash(sierra) {
+  const CONTRACT_CLASS_VERSION = "CONTRACT_CLASS_V0.1.0";
+  const compiledClassVersion = BigInt((0, _shortString.encodeShortString)(CONTRACT_CLASS_VERSION));
+  const externalEntryPointsHash = hashEntryPointSierra(sierra.entry_points_by_type.EXTERNAL);
+  const l1Handlers = hashEntryPointSierra(sierra.entry_points_by_type.L1_HANDLER);
+  const constructor = hashEntryPointSierra(sierra.entry_points_by_type.CONSTRUCTOR);
+  const abiHash = hashAbi(sierra);
+  const sierraProgram = (0, _starknet.poseidonHashMany)(sierra.sierra_program.map(it => BigInt(it)));
+  return (0, _num.toHex)((0, _starknet.poseidonHashMany)([compiledClassVersion, externalEntryPointsHash, l1Handlers, constructor, abiHash, sierraProgram]));
+}
+function computeContractClassHash(contract) {
+  const compiledContract = (0, _shortString.isString)(contract) ? (0, _json.parse)(contract) : contract;
+  if ("sierra_program" in compiledContract) {
+    return computeSierraContractClassHash(compiledContract);
+  }
+  return computeLegacyContractClassHash(compiledContract);
+}

package/dist/utils/hash/classHash.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Class Hash
+ */
+import { BigNumberish, CompiledContract, CompiledSierra, CompiledSierraCasm, LegacyCompiledContract, RawArgs } from '../../types';
+export declare function computePedersenHash(a: BigNumberish, b: BigNumberish): string;
+export declare function computePoseidonHash(a: BigNumberish, b: BigNumberish): string;
+/**
+ * Compute Pedersen hash from data
+ *
+ * @param {BigNumberish[]} data Array of data to compute Pedersen hash on
+ * @returns {string} hex-string of Pedersen hash
+ *
+ * @example
+ * ```typescript
+ * const result = hash.computeHashOnElements(['0xabc', '0x123', '0xabc123'])
+ * // result = 0x148141e8f7db29d005a0187669a56f0790d7e8c2c5b2d780e4d8b9e436a5521
+ * ```
+ */
+export declare function computeHashOnElements(data: BigNumberish[]): string;
+export declare const computePedersenHashOnElements: typeof computeHashOnElements;
+export declare function computePoseidonHashOnElements(data: BigNumberish[]): string;
+/**
+ * Calculate contract address from class hash
+ *
+ * @param {BigNumberish} salt Salt to be used for hashing
+ * @param {BigNumberish} classHash Class hash of contract to generate address for
+ * @param {RawArgs} constructorCalldata Call data for contract constructor
+ * @param {BigNumberish} deployerAddress Address of contract deployer
+ * @returns {string} hex-string
+ * @example
+ * ```typescript
+ * const result = hash.calculateContractAddressFromHash(1234, 0x1cf4fe5d37868d25524cdacb89518d88bf217a9240a1e6fde71cc22c429e0e3, [1234, true, false], 0x052fb1a9ab0db3c4f81d70fea6a2f6e55f57c709a46089b25eeec0e959db3695);
+ * // result = 0x5fb03d3a88d8e474976932f927ff6a9e332e06ed36642ea3e8c7e38bf010f76
+ * ```
+ */
+export declare function calculateContractAddressFromHash(salt: BigNumberish, classHash: BigNumberish, constructorCalldata: RawArgs, deployerAddress: BigNumberish): string;
+/**
+ * Format json-string without spaces to conform starknet json-string
+ * @param {string} json json-string without spaces
+ * @returns {string} json-string with additional spaces after `:` and `,`
+ * @example
+ * ```typescript
+ * const result = hash.formatSpaces("{'onchain':true,'isStarknet':true}");
+ * // result = "{'onchain': true, 'isStarknet': true}"
+ * ```
+ */
+export declare function formatSpaces(json: string): string;
+/**
+ * Compute hinted class hash for legacy compiled contract (Cairo 0)
+ * @param {LegacyCompiledContract} compiledContract
+ * @returns {string} hex-string
+ * @example
+ * ```typescript
+ * const compiledCairo0 = json.parse(fs.readFileSync("./cairo0contract.json").toString("ascii"));
+ * const result=hash.computeHintedClassHash(compiledCairo0);
+ * // result = "0x293eabb06955c0a1e55557014675aa4e7a1fd69896147382b29b2b6b166a2ac"
+ * ``` */
+export declare function computeHintedClassHash(compiledContract: LegacyCompiledContract): string;
+/**
+ * Computes the class hash for legacy compiled contract (Cairo 0)
+ * @param {LegacyCompiledContract | string} contract legacy compiled contract content
+ * @returns {string} hex-string of class hash
+ * @example
+ * ```typescript
+ * const compiledCairo0 = json.parse(fs.readFileSync("./cairo0contract.json").toString("ascii"));
+ * const result=hash.computeLegacyContractClassHash(compiledCairo0);
+ * // result = "0x4a5cae61fa8312b0a3d0c44658b403d3e4197be80027fd5020ffcdf0c803331"
+ * ```
+ */
+export declare function computeLegacyContractClassHash(contract: LegacyCompiledContract | string): string;
+/**
+ * Compute hash of the bytecode for Sierra v1.5.0 onwards (Cairo 2.6.0)
+ * Each segment is Poseidon hashed.
+ * The global hash is : 1 + PoseidonHash(len0, h0, len1, h1, ...)
+ * @param {CompiledSierraCasm} casm compiled Sierra CASM file content.
+ * @returns {bigint} the bytecode hash as bigint.
+ * @example
+ * ```typescript
+ * const compiledCasm = json.parse(fs.readFileSync("./contractC260.casm.json").toString("ascii"));
+ * const result = hash.hashByteCodeSegments(compiledCasm);
+ * // result = 80499149343908132326491548897246987792410240503053732367044713070598981699n
+ * ```
+ */
+export declare function hashByteCodeSegments(casm: CompiledSierraCasm): bigint;
+/**
+ * Compute compiled class hash for contract (Cairo 1)
+ * @param {CompiledSierraCasm} casm Cairo 1 compiled contract content
+ * @returns {string} hex-string of class hash
+ * @example
+ * ```typescript
+ * const compiledCasm = json.parse(fs.readFileSync("./cairo260.casm.json").toString("ascii"));
+ * const result = hash.computeCompiledClassHash(compiledCasm);
+ * // result = "0x4087905743b4fa2b3affc1fc71333f1390c8c5d1e8ea47d6ba70786de3fc01a"
+```
+ */
+export declare function computeCompiledClassHash(casm: CompiledSierraCasm): string;
+/**
+ * Compute sierra contract class hash (Cairo 1)
+ * @param {CompiledSierra} sierra Cairo 1 Sierra contract content
+ * @returns {string} hex-string of class hash
+ * @example
+ * ```typescript
+ * const compiledSierra = json.parse(fs.readFileSync("./cairo260.sierra.json").toString("ascii"));
+ * const result = hash.computeSierraContractClassHash(compiledSierra);
+ * // result = "0x67b6b4f02baded46f02feeed58c4f78e26c55364e59874d8abfd3532d85f1ba"
+```
+ */
+export declare function computeSierraContractClassHash(sierra: CompiledSierra): string;
+/**
+ * Compute ClassHash (sierra or legacy) based on provided contract
+ * @param {CompiledContract | string} contract Cairo 1 contract content
+ * @returns {string} hex-string of class hash
+ * @example
+ * ```typescript
+ * const compiledSierra = json.parse(fs.readFileSync("./cairo260.sierra.json").toString("ascii"));
+ * const result = hash.computeContractClassHash(compiledSierra);
+ * // result = "0x67b6b4f02baded46f02feeed58c4f78e26c55364e59874d8abfd3532d85f1ba"
+```
+ */
+export declare function computeContractClassHash(contract: CompiledContract | string): string;

package/dist/utils/hash/classHash.mjs

@@ -0,0 +1,168 @@
+import { poseidonHashMany } from "@scure/starknet";
+import { ADDR_BOUND, API_VERSION } from "../../constants.mjs";
+import { CallData } from "../calldata/index.mjs";
+import { felt } from "../calldata/cairo.mjs";
+import { starkCurve } from "../ec.mjs";
+import { addHexPrefix, utf8ToArray } from "../encode.mjs";
+import { parse, stringify } from "../json.mjs";
+import { toHex } from "../num.mjs";
+import { encodeShortString, isString } from "../shortString.mjs";
+export function computePedersenHash(a, b) {
+  return starkCurve.pedersen(BigInt(a), BigInt(b));
+}
+export function computePoseidonHash(a, b) {
+  return toHex(starkCurve.poseidonHash(BigInt(a), BigInt(b)));
+}
+export function computeHashOnElements(data) {
+  return [...data, data.length].reduce((x, y) => starkCurve.pedersen(BigInt(x), BigInt(y)), 0).toString();
+}
+export const computePedersenHashOnElements = computeHashOnElements;
+export function computePoseidonHashOnElements(data) {
+  return toHex(poseidonHashMany(data.map((x) => BigInt(x))));
+}
+export function calculateContractAddressFromHash(salt, classHash, constructorCalldata, deployerAddress) {
+  const compiledCalldata = CallData.compile(constructorCalldata);
+  const constructorCalldataHash = computeHashOnElements(compiledCalldata);
+  const CONTRACT_ADDRESS_PREFIX = felt("0x535441524b4e45545f434f4e54524143545f41444452455353");
+  const hash = computeHashOnElements([
+    CONTRACT_ADDRESS_PREFIX,
+    deployerAddress,
+    salt,
+    classHash,
+    constructorCalldataHash
+  ]);
+  return toHex(BigInt(hash) % ADDR_BOUND);
+}
+function nullSkipReplacer(key, value) {
+  if (key === "attributes" || key === "accessible_scopes") {
+    return Array.isArray(value) && value.length === 0 ? void 0 : value;
+  }
+  if (key === "debug_info") {
+    return null;
+  }
+  return value === null ? void 0 : value;
+}
+export function formatSpaces(json) {
+  let insideQuotes = false;
+  const newString = [];
+  for (const char of json) {
+    if (char === '"' && (newString.length > 0 && newString.slice(-1)[0] === "\\") === false) {
+      insideQuotes = !insideQuotes;
+    }
+    if (insideQuotes) {
+      newString.push(char);
+    } else {
+      newString.push(char === ":" ? ": " : char === "," ? ", " : char);
+    }
+  }
+  return newString.join("");
+}
+export function computeHintedClassHash(compiledContract) {
+  const { abi, program } = compiledContract;
+  const contractClass = { abi, program };
+  const serializedJson = formatSpaces(stringify(contractClass, nullSkipReplacer));
+  return addHexPrefix(starkCurve.keccak(utf8ToArray(serializedJson)).toString(16));
+}
+export function computeLegacyContractClassHash(contract) {
+  const compiledContract = isString(contract) ? parse(contract) : contract;
+  const apiVersion = toHex(API_VERSION);
+  const externalEntryPointsHash = computeHashOnElements(
+    compiledContract.entry_points_by_type.EXTERNAL.flatMap((e) => [e.selector, e.offset])
+  );
+  const l1HandlerEntryPointsHash = computeHashOnElements(
+    compiledContract.entry_points_by_type.L1_HANDLER.flatMap((e) => [e.selector, e.offset])
+  );
+  const constructorEntryPointHash = computeHashOnElements(
+    compiledContract.entry_points_by_type.CONSTRUCTOR.flatMap((e) => [e.selector, e.offset])
+  );
+  const builtinsHash = computeHashOnElements(
+    compiledContract.program.builtins.map((s) => encodeShortString(s))
+  );
+  const hintedClassHash = computeHintedClassHash(compiledContract);
+  const dataHash = computeHashOnElements(compiledContract.program.data);
+  return computeHashOnElements([
+    apiVersion,
+    externalEntryPointsHash,
+    l1HandlerEntryPointsHash,
+    constructorEntryPointHash,
+    builtinsHash,
+    hintedClassHash,
+    dataHash
+  ]);
+}
+function hashBuiltins(builtins) {
+  return poseidonHashMany(
+    builtins.flatMap((it) => {
+      return BigInt(encodeShortString(it));
+    })
+  );
+}
+function hashEntryPoint(data) {
+  const base = data.flatMap((it) => {
+    return [BigInt(it.selector), BigInt(it.offset), hashBuiltins(it.builtins)];
+  });
+  return poseidonHashMany(base);
+}
+export function hashByteCodeSegments(casm) {
+  const byteCode = casm.bytecode.map((n) => BigInt(n));
+  const bytecodeSegmentLengths = casm.bytecode_segment_lengths ?? [];
+  let segmentStart = 0;
+  const hashLeaves = bytecodeSegmentLengths.flatMap((len) => {
+    const segment = byteCode.slice(segmentStart, segmentStart += len);
+    return [BigInt(len), poseidonHashMany(segment)];
+  });
+  return 1n + poseidonHashMany(hashLeaves);
+}
+export function computeCompiledClassHash(casm) {
+  const COMPILED_CLASS_VERSION = "COMPILED_CLASS_V1";
+  const compiledClassVersion = BigInt(encodeShortString(COMPILED_CLASS_VERSION));
+  const externalEntryPointsHash = hashEntryPoint(casm.entry_points_by_type.EXTERNAL);
+  const l1Handlers = hashEntryPoint(casm.entry_points_by_type.L1_HANDLER);
+  const constructor = hashEntryPoint(casm.entry_points_by_type.CONSTRUCTOR);
+  const bytecode = casm.bytecode_segment_lengths ? hashByteCodeSegments(casm) : poseidonHashMany(casm.bytecode.map((it) => BigInt(it)));
+  return toHex(
+    poseidonHashMany([
+      compiledClassVersion,
+      externalEntryPointsHash,
+      l1Handlers,
+      constructor,
+      bytecode
+    ])
+  );
+}
+function hashEntryPointSierra(data) {
+  const base = data.flatMap((it) => {
+    return [BigInt(it.selector), BigInt(it.function_idx)];
+  });
+  return poseidonHashMany(base);
+}
+function hashAbi(sierra) {
+  const indentString = formatSpaces(stringify(sierra.abi, null));
+  return BigInt(addHexPrefix(starkCurve.keccak(utf8ToArray(indentString)).toString(16)));
+}
+export function computeSierraContractClassHash(sierra) {
+  const CONTRACT_CLASS_VERSION = "CONTRACT_CLASS_V0.1.0";
+  const compiledClassVersion = BigInt(encodeShortString(CONTRACT_CLASS_VERSION));
+  const externalEntryPointsHash = hashEntryPointSierra(sierra.entry_points_by_type.EXTERNAL);
+  const l1Handlers = hashEntryPointSierra(sierra.entry_points_by_type.L1_HANDLER);
+  const constructor = hashEntryPointSierra(sierra.entry_points_by_type.CONSTRUCTOR);
+  const abiHash = hashAbi(sierra);
+  const sierraProgram = poseidonHashMany(sierra.sierra_program.map((it) => BigInt(it)));
+  return toHex(
+    poseidonHashMany([
+      compiledClassVersion,
+      externalEntryPointsHash,
+      l1Handlers,
+      constructor,
+      abiHash,
+      sierraProgram
+    ])
+  );
+}
+export function computeContractClassHash(contract) {
+  const compiledContract = isString(contract) ? parse(contract) : contract;
+  if ("sierra_program" in compiledContract) {
+    return computeSierraContractClassHash(compiledContract);
+  }
+  return computeLegacyContractClassHash(compiledContract);
+}

package/dist/utils/hash/index.cjs

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  poseidon: true
+};
+exports.poseidon = void 0;
+var _poseidon = _interopRequireWildcard(require("@noble/curves/abstract/poseidon"));
+exports.poseidon = _poseidon;
+var _selector = require("./selector.cjs");
+Object.keys(_selector).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _selector[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _selector[key];
+    }
+  });
+});
+var _transactionHash = require("./transactionHash/index.cjs");
+Object.keys(_transactionHash).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _transactionHash[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _transactionHash[key];
+    }
+  });
+});
+var _classHash = require("./classHash.cjs");
+Object.keys(_classHash).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _classHash[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _classHash[key];
+    }
+  });
+});
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }

package/dist/utils/hash/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Hashes Exports
+ */
+export * as poseidon from '@noble/curves/abstract/poseidon';
+export * from './selector';
+export * from './transactionHash';
+export * from './classHash';

package/dist/utils/hash/index.mjs

@@ -0,0 +1,4 @@
+export * as poseidon from "@noble/curves/abstract/poseidon";
+export * from "./selector.mjs";
+export * from "./transactionHash/index.mjs";
+export * from "./classHash.mjs";

package/dist/utils/hash/selector.cjs

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSelector = getSelector;
+exports.getSelectorFromName = getSelectorFromName;
+exports.keccakBn = keccakBn;
+exports.starknetKeccak = starknetKeccak;
+var _starknet = require("@scure/starknet");
+var _constants = require("../../constants.cjs");
+var _encode = require("../encode.cjs");
+var _num = require("../num.cjs");
+function keccakBn(value) {
+  const hexWithoutPrefix = (0, _encode.removeHexPrefix)((0, _num.toHex)(BigInt(value)));
+  const evenHex = hexWithoutPrefix.length % 2 === 0 ? hexWithoutPrefix : `0${hexWithoutPrefix}`;
+  return (0, _encode.addHexPrefix)((0, _starknet.keccak)((0, _num.hexToBytes)((0, _encode.addHexPrefix)(evenHex))).toString(16));
+}
+function keccakHex(str) {
+  return (0, _encode.addHexPrefix)((0, _starknet.keccak)((0, _encode.utf8ToArray)(str)).toString(16));
+}
+function starknetKeccak(str) {
+  const hash = BigInt(keccakHex(str));
+  return hash & _constants.MASK_250;
+}
+function getSelectorFromName(funcName) {
+  return (0, _num.toHex)(starknetKeccak(funcName));
+}
+function getSelector(value) {
+  if ((0, _num.isHex)(value)) {
+    return value;
+  }
+  if ((0, _num.isStringWholeNumber)(value)) {
+    return (0, _num.toHexString)(value);
+  }
+  return getSelectorFromName(value);
+}

package/dist/utils/hash/selector.d.ts

@@ -0,0 +1,57 @@
+import { BigNumberish } from '../../types';
+/**
+ * Calculate the hex-string Keccak hash for a given BigNumberish
+ *
+ * @param value value to hash
+ * @returns hex-string Keccak hash
+ * @example
+ * ```typescript
+ * const result = keccakBn('0xabc');
+ * // result = '0x11cf08aac85935e32397f410e48217a127b6855d41b1e3877eb4179c0904b77'
+ * ```
+ */
+export declare function keccakBn(value: BigNumberish): string;
+/**
+ * Calculate the BigInt Starknet Keccak hash for a given string
+ * [Reference](https://github.com/starkware-libs/cairo-lang/blob/master/src/starkware/starknet/public/abi.py#L38)
+ *
+ * @param str value to hash
+ * @returns BigInt Keccak hash
+ * @example
+ * ```typescript
+ * const result = starknetKeccak('test').toString();
+ * // result = '61835310290161785288773114225739080147441215596947647498723774891619563096'
+ * ```
+ */
+export declare function starknetKeccak(str: string): bigint;
+/**
+ * Calculate the hex-string selector for a given abi function name
+ * [Reference](https://github.com/starkware-libs/cairo-lang/blob/master/src/starkware/starknet/public/abi.py#L46)
+ *
+ * @param funcName abi function name
+ * @returns hex-string selector
+ * @example
+ * ```typescript
+ * const result = getSelectorFromName('myFunction');
+ * // result = '0xc14cfe23f3fa7ce7b1f8db7d7682305b1692293f71a61cc06637f0d8d8b6c8'
+ * ```
+ */
+export declare function getSelectorFromName(funcName: string): string;
+/**
+ * Calculate the hex-string selector from a given abi function name, decimal string or hex string
+ *
+ * @param value hex-string | dec-string | ascii-string
+ * @returns hex-string selector
+ * @example
+ * ```typescript
+ * const selector1: string = getSelector("myFunction");
+ * // selector1 = "0xc14cfe23f3fa7ce7b1f8db7d7682305b1692293f71a61cc06637f0d8d8b6c8"
+ *
+ * const selector2: string = getSelector("0x123abc");
+ * // selector2 = "0x123abc"
+ *
+ * const selector3: string = getSelector("123456");
+ * // selector3 = "0x1e240"
+ * ```
+ */
+export declare function getSelector(value: string): string;

package/dist/utils/hash/selector.mjs

@@ -0,0 +1,28 @@
+import { keccak } from "@scure/starknet";
+import { MASK_250 } from "../../constants.mjs";
+import { addHexPrefix, removeHexPrefix, utf8ToArray } from "../encode.mjs";
+import { hexToBytes, isHex, isStringWholeNumber, toHex, toHexString } from "../num.mjs";
+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));
+}
+function keccakHex(str) {
+  return addHexPrefix(keccak(utf8ToArray(str)).toString(16));
+}
+export function starknetKeccak(str) {
+  const hash = BigInt(keccakHex(str));
+  return hash & MASK_250;
+}
+export function getSelectorFromName(funcName) {
+  return toHex(starknetKeccak(funcName));
+}
+export function getSelector(value) {
+  if (isHex(value)) {
+    return value;
+  }
+  if (isStringWholeNumber(value)) {
+    return toHexString(value);
+  }
+  return getSelectorFromName(value);
+}