starknet 6.9.0 → 6.10.1

package/dist/utils/num.d.ts

@@ -0,0 +1,283 @@
+import { BigNumberish } from '../types';
+/** @deprecated prefer importing from 'types' over 'num' */
+export type { BigNumberish };
+/**
+ * Test if string is hex-string
+ *
+ * @param hex hex-string
+ * @returns {boolean} true if the input string is a hexadecimal string, false otherwise
+ * @example
+ * ```typescript
+ * const hexString1 = "0x2fd23d9182193775423497fc0c472e156c57c69e4089a1967fb288a2d84e914";
+ * const result1 = isHex(hexString1);
+ * // result1 = true
+ *
+ * const hexString2 = "2fd23d9182193775423497fc0c472e156c57c69e4089a1967fb288a2d84e914";
+ * const result2 = isHex(hexString2);
+ * // result2 = false
+ * ```
+ */
+export declare function isHex(hex: string): boolean;
+/**
+ * Convert BigNumberish to bigint
+ *
+ * @param {BigNumberish} value value to convert
+ * @returns {BigInt} converted value
+ * @example
+ * ```typescript
+ * const str = '123';
+ * const result = toBigInt(str);
+ * // result = 123n
+ * ```
+ */
+export declare function toBigInt(value: BigNumberish): bigint;
+/**
+ * Test if value is bigint
+ *
+ * @param value value to test
+ * @returns {boolean} true if value is bigint, false otherwise
+ * @example
+ * ```typescript
+ * isBigInt(10n); // true
+ * isBigInt(BigInt('10')); // true
+ * isBigInt(10); // false
+ * isBigInt('10'); // false
+ * isBigInt(null); // false
+ * ```
+ */
+export declare function isBigInt(value: any): value is bigint;
+/**
+ * Convert BigNumberish to hex-string
+ *
+ * @param {BigNumberish} value value to convert
+ * @returns {string} converted number in hex-string format
+ * @example
+ * ```typescript
+ * toHex(100); // '0x64'
+ * toHex('200'); // '0xc8'
+ * ```
+ */
+export declare function toHex(value: BigNumberish): string;
+/**
+ * Alias of ToHex
+ */
+export declare const toHexString: typeof toHex;
+/**
+ * Convert BigNumberish to storage-key-string
+ *
+ * Same as toHex but conforming to the STORAGE_KEY pattern `^0x0[0-7]{1}[a-fA-F0-9]{0,62}$`.
+ *
+ * A storage key is represented as up to 62 hex digits, 3 bits, and 5 leading zeroes:
+ * `0x0 + [0-7] + 62 hex = 0x + 64 hex`
+ * @returns format: storage-key-string
+ */
+export declare function toStorageKey(number: BigNumberish): string;
+/**
+ * Convert hexadecimal string to decimal string
+ *
+ * @param {string} hex hex-string to convert
+ * @returns {string} converted number in decimal string format
+ * @example
+ * ```typescript
+ * hexToDecimalString('64'); // '100'
+ * hexToDecimalString('c8'); // '200'
+ * ```
+ */
+export declare function hexToDecimalString(hex: string): string;
+/**
+ * Remove hex-string leading zeroes and lowercase it
+ *
+ * @param {string} hex hex-string
+ * @returns {string} updated string in hex-string format
+ * @example
+ * ```typescript
+ * cleanHex('0x00023AB'); // '0x23ab'
+ * ```
+ */
+export declare function cleanHex(hex: string): string;
+/**
+ * Asserts input is equal to or greater then lowerBound and lower then upperBound.
+ *
+ * The `inputName` parameter is used in the assertion message.
+ * @param input Value to check
+ * @param lowerBound Lower bound value
+ * @param upperBound Upper bound value
+ * @param inputName Name of the input for error message
+ * @throws Error if input is out of range
+ * @example
+ * ```typescript
+ * const input1:BigNumberish = 10;
+ * assertInRange(input1, 5, 20, 'value')
+ *
+ * const input2: BigNumberish = 25;
+ * assertInRange(input2, 5, 20, 'value');
+ * // throws Error: Message not signable, invalid value length.
+ * ```
+ */
+export declare function assertInRange(input: BigNumberish, lowerBound: BigNumberish, upperBound: BigNumberish, inputName?: string): void;
+/**
+ * Convert BigNumberish array to decimal string array
+ *
+ * @param {BigNumberish[]} data array of big-numberish elements
+ * @returns {string[]} array of decimal strings
+ * @example
+ * ```typescript
+ * const data = [100, 200n];
+ * const result = bigNumberishArrayToDecimalStringArray(data);
+ * // result = ['100', '200']
+ * ```
+ */
+export declare function bigNumberishArrayToDecimalStringArray(data: BigNumberish[]): string[];
+/**
+ * Convert BigNumberish array to hexadecimal string array
+ *
+ * @param {BigNumberish[]} data array of big-numberish elements
+ * @returns array of hex-strings
+ * @example
+ * ```typescript
+ * const data = [100, 200n];
+ * const result = bigNumberishArrayToHexadecimalStringArray(data);
+ * // result = ['0x64', '0xc8']
+ * ```
+ */
+export declare function bigNumberishArrayToHexadecimalStringArray(data: BigNumberish[]): string[];
+/**
+ * Test if string is a whole number (0, 1, 2, 3...)
+ *
+ * @param {string} str string to test
+ * @returns {boolean}: true if string is a whole number, false otherwise
+ * @example
+ * ```typescript
+ * isStringWholeNumber('100'); // true
+ * isStringWholeNumber('10.0'); // false
+ * isStringWholeNumber('test'); // false
+ * ```
+ */
+export declare function isStringWholeNumber(str: string): boolean;
+/**
+ * Convert string to decimal string
+ *
+ * @param {string} str string to convert
+ * @returns converted string in decimal format
+ * @throws str needs to be a number string in hex or whole number format
+ * @example
+ * ```typescript
+ * const result = getDecimalString("0x1a");
+ * // result = "26"
+ *
+ * const result2 = getDecimalString("Hello");
+ * // throws Error: "Hello needs to be a hex-string or whole-number-string"
+ * ```
+ */
+export declare function getDecimalString(str: string): string;
+/**
+ * Convert string to hexadecimal string
+ *
+ * @param {string} str string to convert
+ * @returns converted hex-string
+ * @throws str needs to be a number string in hex or whole number format
+ * @example
+ * ```typescript
+ * const result = getHexString("123");
+ * // result = "0x7b"
+ *
+ * const result2 = getHexString("Hello");
+ * // throws Error: Hello needs to be a hex-string or whole-number-string
+ * ```
+ */
+export declare function getHexString(str: string): string;
+/**
+ * Convert string array to hex-string array
+ *
+ * @param {Array<string>} array array of string elements
+ * @returns array of converted elements in hex-string format
+ * @example
+ * ```typescript
+ * const data = ['100', '200', '0xaa'];
+ * const result = getHexStringArray(data);
+ * // result = ['0x64', '0xc8', '0xaa']
+ * ```
+ */
+export declare function getHexStringArray(array: Array<string>): string[];
+/**
+ * Convert boolean to "0" or "1"
+ *
+ * @param value The boolean value to be converted.
+ * @returns {boolean} Returns true if the value is a number, otherwise returns false.
+ * @example
+ * ```typescript
+ * const result = toCairoBool(true);
+ * // result ="1"
+ *
+ * const result2 = toCairoBool(false);
+ * // result2 = "0"
+ * ```
+ */
+export declare function toCairoBool(value: boolean): string;
+/**
+ * Convert hex-string to an array of Bytes (Uint8Array)
+ *
+ * @param {string} str hex-string
+ * @returns {Uint8Array} array containing the converted elements
+ * @throws str must be a hex-string
+ * @example
+ * ```typescript
+ * let result;
+ *
+ * result = hexToBytes('0x64');
+ * // result = [100]
+ *
+ * result = hexToBytes('test');
+ * // throws Error: test needs to be a hex-string
+ * ```
+ */
+export declare function hexToBytes(str: string): Uint8Array;
+/**
+ * Adds a percentage amount to the value
+ *
+ * @param number value to be modified
+ * @param percent integer as percent ex. 50 for 50%
+ * @returns {BigInt} modified value
+ * @example
+ * ```typescript
+ * addPercent(100, 50); // 150n
+ * addPercent(100, 100); // 200n
+ * addPercent(200, 50); // 300n
+ * addPercent(200, -50); // 100n
+ * addPercent(200, -100); // 0n
+ * addPercent(200, -150); // -100n
+ * ```
+ */
+export declare function addPercent(number: BigNumberish, percent: number): bigint;
+/**
+ * Check if a value is a number.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} Returns true if the value is a number, otherwise returns false.
+ * @example
+ * ```typescript
+ * const result = isNumber(123);
+ * // result = true
+ *
+ * const result2 = isNumber("123");
+ * // result2 = false
+ * ```
+ * @return {boolean} Returns true if the value is a number, otherwise returns false.
+ */
+export declare function isNumber(value: unknown): value is number;
+/**
+ * Checks if a given value is of boolean type.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} - True if the value is of boolean type, false otherwise.
+ * @example
+ * ```typescript
+ * const result = isBoolean(true);
+ * // result = true
+ *
+ * const result2 = isBoolean(false);
+ * // result2 = false
+ * ```
+ * @return {boolean} - True if the value is of boolean type, false otherwise.
+ */
+export declare function isBoolean(value: unknown): value is boolean;

package/dist/utils/num.mjs

@@ -0,0 +1,86 @@
+import { hexToBytes as hexToBytesNoble } from "@noble/curves/abstract/utils";
+import assert from "./assert.mjs";
+import { addHexPrefix, removeHexPrefix } from "./encode.mjs";
+export function isHex(hex) {
+  return /^0x[0-9a-f]*$/i.test(hex);
+}
+export function toBigInt(value) {
+  return BigInt(value);
+}
+export function isBigInt(value) {
+  return typeof value === "bigint";
+}
+export function toHex(value) {
+  return addHexPrefix(toBigInt(value).toString(16));
+}
+export const toHexString = toHex;
+export function toStorageKey(number) {
+  return addHexPrefix(toBigInt(number).toString(16).padStart(64, "0"));
+}
+export function hexToDecimalString(hex) {
+  return BigInt(addHexPrefix(hex)).toString(10);
+}
+export function cleanHex(hex) {
+  return hex.toLowerCase().replace(/^(0x)0+/, "$1");
+}
+export function assertInRange(input, lowerBound, upperBound, inputName = "") {
+  const messageSuffix = inputName === "" ? "invalid length" : `invalid ${inputName} length`;
+  const inputBigInt = BigInt(input);
+  const lowerBoundBigInt = BigInt(lowerBound);
+  const upperBoundBigInt = BigInt(upperBound);
+  assert(
+    inputBigInt >= lowerBoundBigInt && inputBigInt <= upperBoundBigInt,
+    `Message not signable, ${messageSuffix}.`
+  );
+}
+export function bigNumberishArrayToDecimalStringArray(data) {
+  return data.map((x) => toBigInt(x).toString(10));
+}
+export function bigNumberishArrayToHexadecimalStringArray(data) {
+  return data.map((x) => toHex(x));
+}
+export function isStringWholeNumber(str) {
+  return /^\d+$/.test(str);
+}
+export 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`);
+}
+export 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`);
+}
+export function getHexStringArray(array) {
+  return array.map(getHexString);
+}
+export function toCairoBool(value) {
+  return (+value).toString();
+}
+export function hexToBytes(str) {
+  if (!isHex(str)) throw new Error(`${str} needs to be a hex-string`);
+  let adaptedValue = removeHexPrefix(str);
+  if (adaptedValue.length % 2 !== 0) {
+    adaptedValue = `0${adaptedValue}`;
+  }
+  return hexToBytesNoble(adaptedValue);
+}
+export function addPercent(number, percent) {
+  const bigIntNum = BigInt(number);
+  return bigIntNum + bigIntNum * BigInt(percent) / 100n;
+}
+export function isNumber(value) {
+  return typeof value === "number";
+}
+export function isBoolean(value) {
+  return typeof value === "boolean";
+}

package/dist/utils/provider.cjs

@@ -0,0 +1,182 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Block = void 0;
+exports.createSierraContractClass = createSierraContractClass;
+exports.getDefaultNodeUrl = void 0;
+exports.isPendingBlock = isPendingBlock;
+exports.isPendingStateUpdate = isPendingStateUpdate;
+exports.isPendingTransaction = isPendingTransaction;
+exports.isV3Tx = isV3Tx;
+exports.isVersion = isVersion;
+exports.parseContract = parseContract;
+exports.validBlockTags = void 0;
+exports.wait = wait;
+var _constants = require("../constants.cjs");
+var _types = require("../types/index.cjs");
+var _api = require("../types/api/index.cjs");
+var _contract = require("./contract.cjs");
+var _hash = require("./hash/index.cjs");
+var _json = require("./json.cjs");
+var _num = require("./num.cjs");
+var _shortString = require("./shortString.cjs");
+var _stark = require("./stark.cjs");
+function wait(delay) {
+  return new Promise(res => {
+    setTimeout(res, delay);
+  });
+}
+function createSierraContractClass(contract) {
+  const result = {
+    ...contract
+  };
+  delete result.sierra_program_debug_info;
+  result.abi = (0, _hash.formatSpaces)((0, _json.stringify)(contract.abi));
+  result.sierra_program = (0, _hash.formatSpaces)((0, _json.stringify)(contract.sierra_program));
+  result.sierra_program = (0, _stark.compressProgram)(result.sierra_program);
+  return result;
+}
+function parseContract(contract) {
+  const parsedContract = (0, _shortString.isString)(contract) ? (0, _json.parse)(contract) : contract;
+  if (!(0, _contract.isSierra)(contract)) {
+    return {
+      ...parsedContract,
+      ...("program" in parsedContract && {
+        program: (0, _stark.compressProgram)(parsedContract.program)
+      })
+    };
+  }
+  return createSierraContractClass(parsedContract);
+}
+const getDefaultNodeUrl = (networkName, mute = false) => {
+  if (!mute) {
+    console.warn("Using default public node url, please provide nodeUrl in provider options!");
+  }
+  const nodes = _constants.RPC_NODES[networkName ?? _constants.NetworkName.SN_SEPOLIA];
+  const randIdx = Math.floor(Math.random() * nodes.length);
+  return nodes[randIdx];
+};
+exports.getDefaultNodeUrl = getDefaultNodeUrl;
+const validBlockTags = exports.validBlockTags = Object.values(_types.BlockTag);
+class Block {
+  /**
+   * @param {BlockIdentifier} hash if not null, contains the block hash
+   */
+  hash = null;
+  /**
+   * @param {BlockIdentifier} number if not null, contains the block number
+   */
+  number = null;
+  /**
+   * @param {BlockIdentifier} tag if not null, contains "pending" or "latest"
+   */
+  tag = null;
+  setIdentifier(__identifier) {
+    if ((0, _shortString.isString)(__identifier)) {
+      if ((0, _shortString.isDecimalString)(__identifier)) {
+        this.number = parseInt(__identifier, 10);
+      } else if ((0, _num.isHex)(__identifier)) {
+        this.hash = __identifier;
+      } else if (validBlockTags.includes(__identifier)) {
+        this.tag = __identifier;
+      } else {
+        throw TypeError(`Block identifier unmanaged: ${__identifier}`);
+      }
+    } else if ((0, _num.isBigInt)(__identifier)) {
+      this.hash = (0, _num.toHex)(__identifier);
+    } else if ((0, _num.isNumber)(__identifier)) {
+      this.number = __identifier;
+    } else {
+      this.tag = _types.BlockTag.PENDING;
+    }
+    if ((0, _num.isNumber)(this.number) && this.number < 0) {
+      throw TypeError(`Block number (${this.number}) can't be negative`);
+    }
+  }
+  /**
+   * Create a Block instance
+   * @param {BlockIdentifier} _identifier  hex string and BigInt are detected as block hashes.
+   * decimal string and number are detected as block numbers.
+   * text string are detected as block tag.
+   * null is considered as a 'pending' block tag.
+   */
+  constructor(_identifier) {
+    this.setIdentifier(_identifier);
+  }
+  // TODO: fix any
+  /**
+   * @returns {any} the identifier as a string
+   * @example
+   * ```typescript
+   * const result = new provider.Block(123456n).queryIdentifier;
+   * // result = "blockHash=0x1e240"
+   * ```
+   */
+  get queryIdentifier() {
+    if (this.number !== null) {
+      return `blockNumber=${this.number}`;
+    }
+    if (this.hash !== null) {
+      return `blockHash=${this.hash}`;
+    }
+    return `blockNumber=${this.tag}`;
+  }
+  // TODO: fix any
+  /**
+   * @returns {any} the identifier as an object
+   * @example
+   * ```typescript
+   * const result = new provider.Block(56789).identifier;
+   * // result = { block_number: 56789 }
+   * ```
+   */
+  get identifier() {
+    if (this.number !== null) {
+      return {
+        block_number: this.number
+      };
+    }
+    if (this.hash !== null) {
+      return {
+        block_hash: this.hash
+      };
+    }
+    return this.tag;
+  }
+  /**
+   * change the identifier of an existing Block instance
+   * @example
+   * ```typescript
+   * const myBlock = new provider.Block("latest");
+   * myBlock.identifier ="0x3456789abc";
+   * const result = myBlock.identifier;
+   * // result = { block_hash: '0x3456789abc' }
+   * ```
+   */
+  set identifier(_identifier) {
+    this.setIdentifier(_identifier);
+  }
+  valueOf = () => this.number;
+  toString = () => this.hash;
+}
+exports.Block = Block;
+function isV3Tx(details) {
+  const version = details.version ? (0, _num.toHex)(details.version) : _api.ETransactionVersion.V3;
+  return version === _api.ETransactionVersion.V3 || version === _api.ETransactionVersion.F3;
+}
+function isVersion(version, response) {
+  const [majorS, minorS] = version.split(".");
+  const [majorR, minorR] = response.split(".");
+  return majorS === majorR && minorS === minorR;
+}
+function isPendingBlock(response) {
+  return response.status === "PENDING";
+}
+function isPendingTransaction(response) {
+  return !("block_hash" in response);
+}
+function isPendingStateUpdate(response) {
+  return !("block_hash" in response);
+}