starknet 6.9.0 → 6.10.1

package/dist/utils/merkle.cjs

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MerkleTree = void 0;
+exports.proofMerklePath = proofMerklePath;
+var _hash = require("./hash/index.cjs");
+class MerkleTree {
+  leaves;
+  branches = [];
+  root;
+  hashMethod;
+  /**
+   * Create a Merkle tree
+   *
+   * @param leafHashes hex-string array
+   * @param hashMethod hash method to use, default: Pedersen
+   * @returns created Merkle tree
+   * @example
+   * ```typescript
+   * const leaves = ['0x1', '0x2', '0x3', '0x4', '0x5', '0x6', '0x7'];
+   * const tree = new MerkleTree(leaves);
+   * // tree = {
+   * //   branches: [['0x5bb9440e2...', '0x262697b88...', ...], ['0x38118a340...', ...], ...],
+   * //   leaves: ['0x1', '0x2', '0x3', '0x4', '0x5', '0x6', '0x7'],
+   * //   root: '0x7f748c75e5bdb7ae28013f076b8ab650c4e01d3530c6e5ab665f9f1accbe7d4',
+   * //   hashMethod: [Function computePedersenHash],
+   * // }
+   * ```
+   */
+  constructor(leafHashes, hashMethod = _hash.computePedersenHash) {
+    this.hashMethod = hashMethod;
+    this.leaves = leafHashes;
+    this.root = this.build(leafHashes);
+  }
+  /** @ignore */
+  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);
+  }
+  /**
+   * Calculate hash from ordered a and b, Pedersen hash default
+   *
+   * @param a first value
+   * @param b second value
+   * @param hashMethod hash method to use, default: Pedersen
+   * @returns result of the hash function
+   * @example
+   * ```typescript
+   * const result1 = MerkleTree.hash('0xabc', '0xdef');
+   * // result1 = '0x484f029da7914ada038b1adf67fc83632364a3ebc2cd9349b41ab61626d9e82'
+   *
+   * const customHashMethod = (a, b) => `custom_${a}_${b}`;
+   * const result2 = MerkleTree.hash('0xabc', '0xdef', customHashMethod);
+   * // result2 = 'custom_2748_3567'
+   * ```
+   */
+  static hash(a, b, hashMethod = _hash.computePedersenHash) {
+    const [aSorted, bSorted] = [BigInt(a), BigInt(b)].sort((x, y) => x >= y ? 1 : -1);
+    return hashMethod(aSorted, bSorted);
+  }
+  /**
+   * Calculates the merkle membership proof path
+   *
+   * @param leaf hex-string
+   * @param branch hex-string array
+   * @param hashPath hex-string array
+   * @returns collection of merkle proof hex-string hashes
+   * @example
+   * ```typescript
+   * const leaves = ['0x1', '0x2', '0x3', '0x4', '0x5', '0x6', '0x7'];
+   * const tree = new MerkleTree(leaves);
+   * const result = tree.getProof('0x3');
+   * // result = [
+   * //   '0x4',
+   * //   '0x5bb9440e27889a364bcb678b1f679ecd1347acdedcbf36e83494f857cc58026',
+   * //   '0x8c0e46dd2df9aaf3a8ebfbc25408a582ad7fa7171f0698ddbbc5130b4b4e60',
+   * // ]
+   * ```
+   */
+  getProof(leaf, branch = this.leaves, hashPath = []) {
+    const index = branch.indexOf(leaf);
+    if (index === -1) {
+      throw new Error("leaf not found");
+    }
+    if (branch.length === 1) {
+      return hashPath;
+    }
+    const isLeft = index % 2 === 0;
+    const neededBranch = (isLeft ? branch[index + 1] : branch[index - 1]) ?? "0x0";
+    const newHashPath = [...hashPath, neededBranch];
+    const currentBranchLevelIndex = this.leaves.length === branch.length ? -1 : this.branches.findIndex(b => b.length === branch.length);
+    const nextBranch = this.branches[currentBranchLevelIndex + 1] ?? [this.root];
+    return this.getProof(MerkleTree.hash(isLeft ? leaf : neededBranch, isLeft ? neededBranch : leaf, this.hashMethod), nextBranch, newHashPath);
+  }
+}
+exports.MerkleTree = MerkleTree;
+function proofMerklePath(root, leaf, path, hashMethod = _hash.computePedersenHash) {
+  if (path.length === 0) {
+    return root === leaf;
+  }
+  const [next, ...rest] = path;
+  return proofMerklePath(root, MerkleTree.hash(leaf, next, hashMethod), rest, hashMethod);
+}

package/dist/utils/merkle.d.ts

@@ -0,0 +1,87 @@
+import { BigNumberish } from '../types';
+export declare class MerkleTree {
+    leaves: string[];
+    branches: string[][];
+    root: string;
+    hashMethod: (a: BigNumberish, b: BigNumberish) => string;
+    /**
+     * Create a Merkle tree
+     *
+     * @param leafHashes hex-string array
+     * @param hashMethod hash method to use, default: Pedersen
+     * @returns created Merkle tree
+     * @example
+     * ```typescript
+     * const leaves = ['0x1', '0x2', '0x3', '0x4', '0x5', '0x6', '0x7'];
+     * const tree = new MerkleTree(leaves);
+     * // tree = {
+     * //   branches: [['0x5bb9440e2...', '0x262697b88...', ...], ['0x38118a340...', ...], ...],
+     * //   leaves: ['0x1', '0x2', '0x3', '0x4', '0x5', '0x6', '0x7'],
+     * //   root: '0x7f748c75e5bdb7ae28013f076b8ab650c4e01d3530c6e5ab665f9f1accbe7d4',
+     * //   hashMethod: [Function computePedersenHash],
+     * // }
+     * ```
+     */
+    constructor(leafHashes: string[], hashMethod?: (a: BigNumberish, b: BigNumberish) => string);
+    /** @ignore */
+    private build;
+    /**
+     * Calculate hash from ordered a and b, Pedersen hash default
+     *
+     * @param a first value
+     * @param b second value
+     * @param hashMethod hash method to use, default: Pedersen
+     * @returns result of the hash function
+     * @example
+     * ```typescript
+     * const result1 = MerkleTree.hash('0xabc', '0xdef');
+     * // result1 = '0x484f029da7914ada038b1adf67fc83632364a3ebc2cd9349b41ab61626d9e82'
+     *
+     * const customHashMethod = (a, b) => `custom_${a}_${b}`;
+     * const result2 = MerkleTree.hash('0xabc', '0xdef', customHashMethod);
+     * // result2 = 'custom_2748_3567'
+     * ```
+     */
+    static hash(a: BigNumberish, b: BigNumberish, hashMethod?: (a: BigNumberish, b: BigNumberish) => string): string;
+    /**
+     * Calculates the merkle membership proof path
+     *
+     * @param leaf hex-string
+     * @param branch hex-string array
+     * @param hashPath hex-string array
+     * @returns collection of merkle proof hex-string hashes
+     * @example
+     * ```typescript
+     * const leaves = ['0x1', '0x2', '0x3', '0x4', '0x5', '0x6', '0x7'];
+     * const tree = new MerkleTree(leaves);
+     * const result = tree.getProof('0x3');
+     * // result = [
+     * //   '0x4',
+     * //   '0x5bb9440e27889a364bcb678b1f679ecd1347acdedcbf36e83494f857cc58026',
+     * //   '0x8c0e46dd2df9aaf3a8ebfbc25408a582ad7fa7171f0698ddbbc5130b4b4e60',
+     * // ]
+     * ```
+     */
+    getProof(leaf: string, branch?: string[], hashPath?: string[]): string[];
+}
+/**
+ * Tests a Merkle tree path
+ *
+ * @param root hex-string
+ * @param leaf hex-string
+ * @param path hex-string array
+ * @param hashMethod hash method to use, default: Pedersen
+ * @returns true if the path is valid, false otherwise
+ * @example
+ * ```typescript
+ * const leaves = ['0x1', '0x2', '0x3', '0x4', '0x5', '0x6', '0x7'];
+ * const tree = new MerkleTree(leaves);
+ * const result = proofMerklePath(tree.root, '0x3', [
+ *   '0x4',
+ *   '0x5bb9440e27889a364bcb678b1f679ecd1347acdedcbf36e83494f857cc58026',
+ *   '0x8c0e46dd2df9aaf3a8ebfbc25408a582ad7fa7171f0698ddbbc5130b4b4e60',
+ * ]);
+ * // result = true
+ * ```
+ */
+export declare function proofMerklePath(root: string, leaf: string, path: string[], hashMethod?: (a: BigNumberish, b: BigNumberish) => string): boolean;

package/dist/utils/merkle.mjs

@@ -0,0 +1,114 @@
+import { computePedersenHash } from "./hash/index.mjs";
+export class MerkleTree {
+  leaves;
+  branches = [];
+  root;
+  hashMethod;
+  /**
+   * Create a Merkle tree
+   *
+   * @param leafHashes hex-string array
+   * @param hashMethod hash method to use, default: Pedersen
+   * @returns created Merkle tree
+   * @example
+   * ```typescript
+   * const leaves = ['0x1', '0x2', '0x3', '0x4', '0x5', '0x6', '0x7'];
+   * const tree = new MerkleTree(leaves);
+   * // tree = {
+   * //   branches: [['0x5bb9440e2...', '0x262697b88...', ...], ['0x38118a340...', ...], ...],
+   * //   leaves: ['0x1', '0x2', '0x3', '0x4', '0x5', '0x6', '0x7'],
+   * //   root: '0x7f748c75e5bdb7ae28013f076b8ab650c4e01d3530c6e5ab665f9f1accbe7d4',
+   * //   hashMethod: [Function computePedersenHash],
+   * // }
+   * ```
+   */
+  constructor(leafHashes, hashMethod = computePedersenHash) {
+    this.hashMethod = hashMethod;
+    this.leaves = leafHashes;
+    this.root = this.build(leafHashes);
+  }
+  /** @ignore */
+  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);
+  }
+  /**
+   * Calculate hash from ordered a and b, Pedersen hash default
+   *
+   * @param a first value
+   * @param b second value
+   * @param hashMethod hash method to use, default: Pedersen
+   * @returns result of the hash function
+   * @example
+   * ```typescript
+   * const result1 = MerkleTree.hash('0xabc', '0xdef');
+   * // result1 = '0x484f029da7914ada038b1adf67fc83632364a3ebc2cd9349b41ab61626d9e82'
+   *
+   * const customHashMethod = (a, b) => `custom_${a}_${b}`;
+   * const result2 = MerkleTree.hash('0xabc', '0xdef', customHashMethod);
+   * // result2 = 'custom_2748_3567'
+   * ```
+   */
+  static hash(a, b, hashMethod = computePedersenHash) {
+    const [aSorted, bSorted] = [BigInt(a), BigInt(b)].sort((x, y) => x >= y ? 1 : -1);
+    return hashMethod(aSorted, bSorted);
+  }
+  /**
+   * Calculates the merkle membership proof path
+   *
+   * @param leaf hex-string
+   * @param branch hex-string array
+   * @param hashPath hex-string array
+   * @returns collection of merkle proof hex-string hashes
+   * @example
+   * ```typescript
+   * const leaves = ['0x1', '0x2', '0x3', '0x4', '0x5', '0x6', '0x7'];
+   * const tree = new MerkleTree(leaves);
+   * const result = tree.getProof('0x3');
+   * // result = [
+   * //   '0x4',
+   * //   '0x5bb9440e27889a364bcb678b1f679ecd1347acdedcbf36e83494f857cc58026',
+   * //   '0x8c0e46dd2df9aaf3a8ebfbc25408a582ad7fa7171f0698ddbbc5130b4b4e60',
+   * // ]
+   * ```
+   */
+  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
+    );
+  }
+}
+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/dist/utils/num.cjs

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addPercent = addPercent;
+exports.assertInRange = assertInRange;
+exports.bigNumberishArrayToDecimalStringArray = bigNumberishArrayToDecimalStringArray;
+exports.bigNumberishArrayToHexadecimalStringArray = bigNumberishArrayToHexadecimalStringArray;
+exports.cleanHex = cleanHex;
+exports.getDecimalString = getDecimalString;
+exports.getHexString = getHexString;
+exports.getHexStringArray = getHexStringArray;
+exports.hexToBytes = hexToBytes;
+exports.hexToDecimalString = hexToDecimalString;
+exports.isBigInt = isBigInt;
+exports.isBoolean = isBoolean;
+exports.isHex = isHex;
+exports.isNumber = isNumber;
+exports.isStringWholeNumber = isStringWholeNumber;
+exports.toBigInt = toBigInt;
+exports.toCairoBool = toCairoBool;
+exports.toHex = toHex;
+exports.toHexString = void 0;
+exports.toStorageKey = toStorageKey;
+var _utils = require("@noble/curves/abstract/utils");
+var _assert = _interopRequireDefault(require("./assert.cjs"));
+var _encode = require("./encode.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function isHex(hex) {
+  return /^0x[0-9a-f]*$/i.test(hex);
+}
+function toBigInt(value) {
+  return BigInt(value);
+}
+function isBigInt(value) {
+  return typeof value === "bigint";
+}
+function toHex(value) {
+  return (0, _encode.addHexPrefix)(toBigInt(value).toString(16));
+}
+const toHexString = exports.toHexString = toHex;
+function toStorageKey(number) {
+  return (0, _encode.addHexPrefix)(toBigInt(number).toString(16).padStart(64, "0"));
+}
+function hexToDecimalString(hex) {
+  return BigInt((0, _encode.addHexPrefix)(hex)).toString(10);
+}
+function cleanHex(hex) {
+  return hex.toLowerCase().replace(/^(0x)0+/, "$1");
+}
+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);
+  (0, _assert.default)(inputBigInt >= lowerBoundBigInt && inputBigInt <= upperBoundBigInt, `Message not signable, ${messageSuffix}.`);
+}
+function bigNumberishArrayToDecimalStringArray(data) {
+  return data.map(x => toBigInt(x).toString(10));
+}
+function bigNumberishArrayToHexadecimalStringArray(data) {
+  return data.map(x => toHex(x));
+}
+function isStringWholeNumber(str) {
+  return /^\d+$/.test(str);
+}
+function getDecimalString(str) {
+  if (isHex(str)) {
+    return hexToDecimalString(str);
+  }
+  if (isStringWholeNumber(str)) {
+    return str;
+  }
+  throw new Error(`${str} needs to be a hex-string or whole-number-string`);
+}
+function getHexString(str) {
+  if (isHex(str)) {
+    return str;
+  }
+  if (isStringWholeNumber(str)) {
+    return toHexString(str);
+  }
+  throw new Error(`${str} needs to be a hex-string or whole-number-string`);
+}
+function getHexStringArray(array) {
+  return array.map(getHexString);
+}
+function toCairoBool(value) {
+  return (+value).toString();
+}
+function hexToBytes(str) {
+  if (!isHex(str)) throw new Error(`${str} needs to be a hex-string`);
+  let adaptedValue = (0, _encode.removeHexPrefix)(str);
+  if (adaptedValue.length % 2 !== 0) {
+    adaptedValue = `0${adaptedValue}`;
+  }
+  return (0, _utils.hexToBytes)(adaptedValue);
+}
+function addPercent(number, percent) {
+  const bigIntNum = BigInt(number);
+  return bigIntNum + bigIntNum * BigInt(percent) / 100n;
+}
+function isNumber(value) {
+  return typeof value === "number";
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}