starknet 5.19.5 → 5.19.6

package/dist/index.d.ts

@@ -5,27 +5,82 @@ import * as json$1 from 'lossless-json';
 import * as starknet from '@scure/starknet';
 
 declare const IS_BROWSER: boolean;
+/**
+ * Some functions recreated from https://github.com/pedrouid/enc-utils/blob/master/src/index.ts
+ * enc-utils is not a dependency to avoid using `Buffer` which only works in node and not browsers
+ */
+/**
+ * Convert array buffer to string
+ *
+ * *[internal usage]*
+ */
 declare function arrayBufferToString(array: ArrayBuffer): string;
+/**
+ * Convert string to array buffer
+ *
+ * *[internal usage]*
+ */
 declare function stringToArrayBuffer(s: string): Uint8Array;
+/**
+ * Convert string to array buffer (browser and node compatible)
+ */
 declare function atobUniversal(a: string): Uint8Array;
+/**
+ * Convert array buffer to string (browser and node compatible)
+ */
 declare function btoaUniversal(b: ArrayBuffer): string;
+/**
+ * Convert array buffer to hex-string
+ * @returns format: hex-string
+ */
 declare function buf2hex(buffer: Uint8Array): string;
 /**
- * Some function imported from https://github.com/pedrouid/enc-utils/blob/master/src/index.ts
- * enc-utils is no dependency to avoid using `Buffer` which just works in node and no browsers
+ * Remove hex prefix '0x' from hex-string
+ * @param hex hex-string
+ * @returns format: base16-string
  */
 declare function removeHexPrefix(hex: string): string;
+/**
+ * Add hex prefix '0x' to base16-string
+ * @param hex base16-string
+ * @returns format: hex-string
+ */
 declare function addHexPrefix(hex: string): string;
+/**
+ * Prepend string (default with '0')
+ */
 declare function padLeft(str: string, length: number, padding?: string): string;
-declare function calcByteLength(length: number, byteSize?: number): number;
+/**
+ * Calculate byte length of string
+ *
+ * *[no internal usage]*
+ */
+declare function calcByteLength(str: string, byteSize?: number): number;
+/**
+ * Prepend '0' to string bytes
+ *
+ * *[no internal usage]*
+ */
 declare function sanitizeBytes(str: string, byteSize?: number, padding?: string): string;
+/**
+ * Prepend '0' to hex-string bytes
+ *
+ * *[no internal usage]*
+ * @param hex hex-string
+ * @returns format: hex-string
+ */
 declare function sanitizeHex(hex: string): string;
+/**
+ * Convert utf8-string to Uint8Array
+ *
+ * Implemented using TextEncoder to make it isomorphic
+ * @param str utf8-string
+ */
 declare function utf8ToArray(str: string): Uint8Array;
 /**
  * String transformation util
- * pascal case to screaming snake case
- * @param text string
- * @returns string
+ *
+ * Pascal case to screaming snake case
  */
 declare const pascalToSnake: (text: string) => string;
 
@@ -62,8 +117,16 @@ declare namespace encode {
   };
 }
 
+/**
+ * Cairo Felt support storing max 31 character
+ */
+declare const TEXT_TO_FELT_MAX_LEN = 31;
 declare const HEX_STR_TRANSACTION_VERSION_1 = "0x1";
 declare const HEX_STR_TRANSACTION_VERSION_2 = "0x2";
+declare const BN_TRANSACTION_VERSION_1 = 1n;
+declare const BN_TRANSACTION_VERSION_2 = 2n;
+declare const BN_FEE_TRANSACTION_VERSION_1: bigint;
+declare const BN_FEE_TRANSACTION_VERSION_2: bigint;
 declare const ZERO = 0n;
 declare const MASK_250: bigint;
 declare const MASK_251: bigint;
@@ -94,62 +157,44 @@ declare const UDC: {
     ADDRESS: string;
     ENTRYPOINT: string;
 };
-/**
- * The following is taken from https://github.com/starkware-libs/starkex-resources/blob/master/crypto/starkware/crypto/signature/pedersen_params.json but converted to hex, because JS is very bad handling big integers by default
- * Please do not edit until the JSON changes.
- */
-declare const FIELD_PRIME = "800000000000011000000000000000000000000000000000000000000000001";
-declare const FIELD_GEN = "3";
-declare const FIELD_SIZE = 251;
-declare const EC_ORDER = "800000000000010FFFFFFFFFFFFFFFFB781126DCAE7B2321E66A241ADC64D2F";
-declare const ALPHA = "1";
-declare const BETA = "6F21413EFBE40DE150E596D72F7A8C5609AD26C15C915C1F4CDFCB99CEE9E89";
-declare const MAX_ECDSA_VAL = "800000000000000000000000000000000000000000000000000000000000000";
-declare const CONSTANT_POINTS: string[][];
 
-declare const constants_ALPHA: typeof ALPHA;
 declare const constants_API_VERSION: typeof API_VERSION;
-declare const constants_BETA: typeof BETA;
+declare const constants_BN_FEE_TRANSACTION_VERSION_1: typeof BN_FEE_TRANSACTION_VERSION_1;
+declare const constants_BN_FEE_TRANSACTION_VERSION_2: typeof BN_FEE_TRANSACTION_VERSION_2;
+declare const constants_BN_TRANSACTION_VERSION_1: typeof BN_TRANSACTION_VERSION_1;
+declare const constants_BN_TRANSACTION_VERSION_2: typeof BN_TRANSACTION_VERSION_2;
 type constants_BaseUrl = BaseUrl;
 declare const constants_BaseUrl: typeof BaseUrl;
-declare const constants_CONSTANT_POINTS: typeof CONSTANT_POINTS;
-declare const constants_EC_ORDER: typeof EC_ORDER;
-declare const constants_FIELD_GEN: typeof FIELD_GEN;
-declare const constants_FIELD_PRIME: typeof FIELD_PRIME;
-declare const constants_FIELD_SIZE: typeof FIELD_SIZE;
 declare const constants_HEX_STR_TRANSACTION_VERSION_1: typeof HEX_STR_TRANSACTION_VERSION_1;
 declare const constants_HEX_STR_TRANSACTION_VERSION_2: typeof HEX_STR_TRANSACTION_VERSION_2;
 declare const constants_IS_BROWSER: typeof IS_BROWSER;
 declare const constants_MASK_250: typeof MASK_250;
 declare const constants_MASK_251: typeof MASK_251;
-declare const constants_MAX_ECDSA_VAL: typeof MAX_ECDSA_VAL;
 type constants_NetworkName = NetworkName;
 declare const constants_NetworkName: typeof NetworkName;
 type constants_StarknetChainId = StarknetChainId;
 declare const constants_StarknetChainId: typeof StarknetChainId;
+declare const constants_TEXT_TO_FELT_MAX_LEN: typeof TEXT_TO_FELT_MAX_LEN;
 type constants_TransactionHashPrefix = TransactionHashPrefix;
 declare const constants_TransactionHashPrefix: typeof TransactionHashPrefix;
 declare const constants_UDC: typeof UDC;
 declare const constants_ZERO: typeof ZERO;
 declare namespace constants {
   export {
-    constants_ALPHA as ALPHA,
     constants_API_VERSION as API_VERSION,
-    constants_BETA as BETA,
+    constants_BN_FEE_TRANSACTION_VERSION_1 as BN_FEE_TRANSACTION_VERSION_1,
+    constants_BN_FEE_TRANSACTION_VERSION_2 as BN_FEE_TRANSACTION_VERSION_2,
+    constants_BN_TRANSACTION_VERSION_1 as BN_TRANSACTION_VERSION_1,
+    constants_BN_TRANSACTION_VERSION_2 as BN_TRANSACTION_VERSION_2,
     constants_BaseUrl as BaseUrl,
-    constants_CONSTANT_POINTS as CONSTANT_POINTS,
-    constants_EC_ORDER as EC_ORDER,
-    constants_FIELD_GEN as FIELD_GEN,
-    constants_FIELD_PRIME as FIELD_PRIME,
-    constants_FIELD_SIZE as FIELD_SIZE,
     constants_HEX_STR_TRANSACTION_VERSION_1 as HEX_STR_TRANSACTION_VERSION_1,
     constants_HEX_STR_TRANSACTION_VERSION_2 as HEX_STR_TRANSACTION_VERSION_2,
     constants_IS_BROWSER as IS_BROWSER,
     constants_MASK_250 as MASK_250,
     constants_MASK_251 as MASK_251,
-    constants_MAX_ECDSA_VAL as MAX_ECDSA_VAL,
     constants_NetworkName as NetworkName,
     constants_StarknetChainId as StarknetChainId,
+    constants_TEXT_TO_FELT_MAX_LEN as TEXT_TO_FELT_MAX_LEN,
     constants_TransactionHashPrefix as TransactionHashPrefix,
     constants_UDC as UDC,
     constants_ZERO as ZERO,
@@ -3510,9 +3555,7 @@ declare class Account extends Provider implements AccountInterface {
      * First check if contract is already declared, if not declare it
      * If contract already declared returned transaction_hash is ''.
      * Method will pass even if contract is already declared
-     * @param payload DeclareContractPayload
-     * @param transactionsDetail (optional) InvocationsDetails = \{\}
-     * @returns DeclareContractResponse
+     * @param transactionsDetail (optional)
      */
     declareIfNot(payload: DeclareContractPayload, transactionsDetail?: InvocationsDetails): Promise<DeclareContractResponse>;
     declare(payload: DeclareContractPayload, transactionsDetail?: InvocationsDetails): Promise<DeclareContractResponse>;
@@ -3640,9 +3683,6 @@ declare const splitArgsAndOptions: (args: ArgsOrCalldataWithOptions) => {
     options?: undefined;
 };
 declare function getCalldata(args: RawArgs, callback: Function): Calldata;
-/**
- * Not used at the moment
- */
 declare class Contract implements ContractInterface {
     abi: Abi;
     address: string;
@@ -3714,55 +3754,56 @@ declare class ContractFactory {
     constructor(params: ContractFactoryParams);
     /**
      * Deploys contract and returns new instance of the Contract
-     * If contract is not declared it will first declare it, and then deploy
      *
-     * @param args - Array of the constructor arguments for deployment
-     * @param options (optional) Object - parseRequest, parseResponse, addressSalt
-     * @returns deployed Contract
+     * If contract is not declared it will first declare it, and then deploy
      */
     deploy(...args: ArgsOrCalldataWithOptions): Promise<Contract>;
     /**
      * Attaches to new Account
      *
-     * @param account - new Provider or Account to attach to
-     * @returns ContractFactory
+     * @param account - new Account to attach to
      */
     connect(account: AccountInterface): ContractFactory;
     /**
      * Attaches current abi and account to the new address
-     *
-     * @param address - Contract address
-     * @returns Contract
      */
     attach(address: string): Contract;
 }
 
 /**
- * Keccak hash BigNumberish value
- * @param value BigNumberish
- * @returns string - hexadecimal string
+ * Calculate hex-string keccak hash for a given BigNumberish
+ *
+ * BigNumberish -> hex-string keccak hash
+ * @returns format: hex-string
  */
 declare function keccakBn(value: BigNumberish): string;
 /**
- * Function to get the starknet keccak hash from a string
+ * Calculate bigint keccak hash for a given string
+ *
+ * String -> bigint keccak hash
  *
  * [Reference](https://github.com/starkware-libs/cairo-lang/blob/master/src/starkware/starknet/public/abi.py#L17-L22)
- * @param value - string you want to get the starknetKeccak hash from
- * @returns starknet keccak hash as BigNumber
+ * @param str the value you want to get the keccak hash from
+ * @returns starknet keccak hash as BigInt
  */
-declare function starknetKeccak(value: string): bigint;
+declare function starknetKeccak(str: string): bigint;
 /**
- * Function to get the hex selector from a given function name
+ * Calculate hex-string selector for a given abi-function-name
+ *
+ * Abi-function-name -> hex-string selector
  *
  * [Reference](https://github.com/starkware-libs/cairo-lang/blob/master/src/starkware/starknet/public/abi.py#L25-L26)
- * @param funcName - selectors abi function name
- * @returns hex selector of given abi function name
+ * @param funcName ascii-string of 'abi function name'
+ * @returns format: hex-string; selector for 'abi function name'
  */
 declare function getSelectorFromName(funcName: string): string;
 /**
- * Function to get hex selector from function name, decimal string or hex string
- * @param value hex string | decimal string | string
- * @returns Hex selector
+ * Calculate hex-string selector from abi-function-name, decimal string or hex string
+ *
+ * ('abi-function-name' or dec-string or hex-string) -> hex-string selector
+ *
+ * @param value hex-string | dec-string | ascii-string
+ * @returns format: hex-string
  */
 declare function getSelector(value: string): string;
 
@@ -3784,30 +3825,80 @@ declare const transactionVersion_2 = 2n;
 declare const feeTransactionVersion: bigint;
 declare const feeTransactionVersion_2: bigint;
 /**
- * Return versions based on version type, default transaction versions
- * @param versionType 'fee' | 'transaction'
- * @returns versions { v1: bigint; v2: bigint; }
+ * Return transaction versions based on version type, default version type is 'transaction'
  */
 declare function getVersionsByType(versionType?: 'fee' | 'transaction'): {
     v1: bigint;
     v2: bigint;
 };
+/**
+ * Compute pedersen hash from data
+ * @returns format: hex-string - pedersen hash
+ */
 declare function computeHashOnElements(data: BigNumberish[]): string;
+/**
+ * Calculate transaction pedersen hash for common properties
+ *
+ * Following implementation is based on this python [implementation #](https://github.com/starkware-libs/cairo-lang/blob/b614d1867c64f3fb2cf4a4879348cfcf87c3a5a7/src/starkware/starknet/core/os/transaction_hash/transaction_hash.py)
+ * @returns format: hex-string
+ */
 declare function calculateTransactionHashCommon(txHashPrefix: TransactionHashPrefix, version: BigNumberish, contractAddress: BigNumberish, entryPointSelector: BigNumberish, calldata: RawCalldata, maxFee: BigNumberish, chainId: StarknetChainId, additionalData?: BigNumberish[]): string;
+/**
+ * Calculate deploy transaction hash
+ * @returns format: hex-string
+ */
 declare function calculateDeployTransactionHash(contractAddress: BigNumberish, constructorCalldata: RawCalldata, version: BigNumberish, chainId: StarknetChainId, constructorName?: string): string;
+/**
+ * Calculate declare transaction hash
+ * @param classHash hex-string
+ * @param compiledClassHash hex-string
+ * @returns format: hex-string
+ */
 declare function calculateDeclareTransactionHash(classHash: string, senderAddress: BigNumberish, version: BigNumberish, maxFee: BigNumberish, chainId: StarknetChainId, nonce: BigNumberish, compiledClassHash?: string): string;
+/**
+ * Calculate deploy_account transaction hash
+ * @returns format: hex-string
+ */
 declare function calculateDeployAccountTransactionHash(contractAddress: BigNumberish, classHash: BigNumberish, constructorCalldata: RawCalldata, salt: BigNumberish, version: BigNumberish, maxFee: BigNumberish, chainId: StarknetChainId, nonce: BigNumberish): string;
+/**
+ * Calculate invoke transaction hash
+ * @returns format: hex-string
+ */
 declare function calculateTransactionHash(contractAddress: BigNumberish, version: BigNumberish, calldata: RawCalldata, maxFee: BigNumberish, chainId: StarknetChainId, nonce: BigNumberish): string;
+/**
+ * Calculate contract address from class hash
+ * @returns format: hex-string
+ */
 declare function calculateContractAddressFromHash(salt: BigNumberish, classHash: BigNumberish, constructorCalldata: RawArgs, deployerAddress: BigNumberish): string;
+/**
+ * Format json-string to conform starknet json-string
+ * @param json json-string
+ * @returns format: json-string
+ */
 declare function formatSpaces(json: string): string;
+/**
+ * Compute hinted class hash for legacy compiled contract (Cairo 0)
+ * @returns format: hex-string
+ */
 declare function computeHintedClassHash(compiledContract: LegacyCompiledContract): string;
+/**
+ * Computes the class hash for legacy compiled contract (Cairo 0)
+ * @returns format: hex-string
+ */
 declare function computeLegacyContractClassHash(contract: LegacyCompiledContract | string): string;
+/**
+ * Compute compiled class hash for contract (Cairo 1)
+ * @returns format: hex-string
+ */
 declare function computeCompiledClassHash(casm: CompiledSierraCasm): string;
+/**
+ * Compute sierra contract class hash (Cairo 1)
+ * @returns format: hex-string
+ */
 declare function computeSierraContractClassHash(sierra: CompiledSierra): string;
 /**
  * Compute ClassHash (sierra or legacy) based on provided contract
- * @param contract CompiledContract | CompiledSierra | string
- * @returns HexString ClassHash
+ * @returns format: hex-string
  */
 declare function computeContractClassHash(contract: CompiledContract | string): string;
 
@@ -3861,8 +3952,26 @@ declare namespace hash {
   };
 }
 
+/**
+ * Convert JSON string to JSON object
+ *
+ * NOTE: the String() wrapping is used so the behavior conforms to JSON.parse()
+ * which can accept simple data types but is not represented in the default typing
+ * @param x JSON string
+ */
 declare const parse: (x: string) => any;
+/**
+ * Convert JSON string to JSON object with all numbers as bigint
+ * @param x JSON string
+ */
 declare const parseAlwaysAsBig: (x: string) => any;
+/**
+ * Convert JSON object to JSON string
+ *
+ * NOTE: the not-null assertion is used so the return type conforms to JSON.stringify()
+ * which can also return undefined but is not represented in the default typing
+ * @returns JSON string
+ */
 declare const stringify: (value: json$1.JavaScriptValue, replacer?: any, space?: string | number | undefined, numberStringifiers?: json$1.NumberStringifier[] | undefined) => string;
 /** @deprecated equivalent to 'stringify', alias will be removed */
 declare const stringifyAlwaysAsBig: (value: json$1.JavaScriptValue, replacer?: any, space?: string | number | undefined, numberStringifiers?: json$1.NumberStringifier[] | undefined) => string;
@@ -3880,37 +3989,93 @@ declare namespace json {
   };
 }
 
+/**
+ * Test if string is hex-string
+ * @param hex hex-string
+ */
 declare function isHex(hex: string): boolean;
+/**
+ * Convert BigNumberish to bigint
+ */
 declare function toBigInt(value: BigNumberish): bigint;
+/**
+ * Test if value is bigint
+ */
 declare function isBigInt(value: any): value is bigint;
+/**
+ * Convert BigNumberish to hex-string
+ * @returns format: hex-string
+ */
 declare function toHex(number: BigNumberish): string;
 /**
- * Convert BigNumberish to STORAGE_KEY
- * Same as toHex but conforming pattern STORAGE_KEY pattern ^0x0[0-7]{1}[a-fA-F0-9]{0,62}$
- * A storage key. Represented as up to 62 hex digits, 3 bits, and 5 leading zeroes.
- * 0x0 + [0-7] + 62 hex = 0x + 64 hex
- * @param number BigNumberish
+ * Alias of ToHex
+ */
+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
  */
 declare function toStorageKey(number: BigNumberish): string;
+/**
+ * Convert hexadecimal string to decimal string
+ * @param hex hex-string
+ * @returns format: decimal string
+ */
 declare function hexToDecimalString(hex: string): string;
 /**
- * Remove hex string leading zero and lower case '0x01A'.. -> '0x1a..'
- * @param hex string
+ * Remove hex string leading zero and lowercase it
+ * @example '0x01A...' -> '0x1a..'
+ * @param hex hex-string
+ * @returns format: hex-string
  */
 declare const 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.
+ */
 declare function assertInRange(input: BigNumberish, lowerBound: BigNumberish, upperBound: BigNumberish, inputName?: string): void;
+/**
+ * Convert BigNumberish array to decimal string array
+ * @returns format: decimal string array
+ */
 declare function bigNumberishArrayToDecimalStringArray(rawCalldata: BigNumberish[]): string[];
+/**
+ * Convert BigNumberish array to hexadecimal string array
+ * @returns format: hex-string array
+ */
 declare function bigNumberishArrayToHexadecimalStringArray(rawCalldata: BigNumberish[]): string[];
+/**
+ * Test if string is whole number (0,1,2,3...)
+ */
 declare const isStringWholeNumber: (value: string) => boolean;
-declare const toHexString: (value: string) => string;
+/**
+ * Convert string to decimal string
+ * @returns format: decimal string
+ */
 declare function getDecimalString(value: string): string;
+/**
+ * Convert string to hexadecimal string
+ * @returns format: hex-string
+ */
 declare function getHexString(value: string): string;
+/**
+ * Convert string array to hex-string array
+ * @returns format: hex-string array
+ */
 declare function getHexStringArray(value: Array<string>): string[];
+/**
+ * Convert boolean to "0" or "1"
+ */
 declare const toCairoBool: (value: boolean) => string;
 /**
- * Convert a hex string to an array of Bytes (Uint8Array)
- * @param value hex string
- * @returns an array of Bytes
+ * Convert hex-string to an array of Bytes (Uint8Array)
+ * @param value hex-string
  */
 declare function hexToBytes(value: string): Uint8Array;
 
@@ -3958,39 +4123,33 @@ declare namespace num {
 /**
  * Transforms a list of Calls, each with their own calldata, into
  * two arrays: one with the entrypoints, and one with the concatenated calldata.
- * @param calls
- * @returns
  */
 declare const transformCallsToMulticallArrays: (calls: Call[]) => {
     callArray: ParsedStruct[];
     calldata: Calldata;
 };
 /**
- * Transforms a list of calls in the full flattened calldata expected
- * by the __execute__ protocol.
- * @param calls
- * @returns
+ * Transforms a list of calls into the Cairo 0 `__execute__` calldata.
  */
 declare const fromCallsToExecuteCalldata: (calls: Call[]) => Calldata;
+/**
+ * Transforms a list of calls into the Cairo 0 `__execute__` calldata including nonce.
+ *
+ * @deprecated
+ */
 declare const fromCallsToExecuteCalldataWithNonce: (calls: Call[], nonce: BigNumberish) => Calldata;
 /**
  * Format Data inside Calls
- * @param calls Call[]
- * @returns CallStruct
+ *
+ * @deprecated Not required for getting execute Calldata
  */
 declare const transformCallsToMulticallArrays_cairo1: (calls: Call[]) => CallStruct[];
 /**
- * Transforms a list of calls in the full flattened calldata expected
- * by the __execute__ protocol.
- * @param calls
- * @returns Calldata
+ * Transforms a list of calls into the Cairo 1 `__execute__` calldata.
  */
 declare const fromCallsToExecuteCalldata_cairo1: (calls: Call[]) => Calldata;
 /**
- *
- * @param calls Call array
- * @param cairoVersion Defaults to 0
- * @returns string[] of calldata
+ * Create `__execute__` Calldata from Calls based on Cairo versions
  */
 declare const getExecuteCalldata: (calls: Call[], cairoVersion?: CairoVersion) => Calldata;
 
@@ -4012,25 +4171,44 @@ declare namespace transaction {
 }
 
 /**
- * Function to compress compiled cairo program
+ * Compress compiled Cairo program
  *
  * [Reference](https://github.com/starkware-libs/cairo-lang/blob/master/src/starkware/starknet/services/api/gateway/transaction.py#L54-L58)
- * @param jsonProgram - json file representing the compiled cairo program
- * @returns Compressed cairo program
+ * @param jsonProgram Representing the compiled cairo program
  */
 declare function compressProgram(jsonProgram: Program | string): CompressedProgram;
 /**
- * Function to decompress compressed compiled cairo program
- *
- * @param base64 CompressedProgram
- * @returns parsed decompressed compiled cairo program
+ * Decompress compressed compiled Cairo program
+ * @param base64 Compressed program
+ * @returns Parsed decompressed compiled Cairo program
  */
 declare function decompressProgram(base64: CompressedProgram): any;
+/**
+ * Random Address based on random keyPair
+ */
 declare function randomAddress(): string;
+/**
+ * Lowercase and hex prefix string
+ *
+ * @deprecated Not used internally, naming is confusing based on functionality
+ */
 declare function makeAddress(input: string): string;
+/**
+ * Format Signature to standard type (hex array)
+ * @returns Custom hex array or weierstrass.SignatureType hex array
+ */
 declare function formatSignature(sig?: Signature): ArraySignatureType;
+/**
+ * Format Signature to decimal string array
+ */
 declare function signatureToDecimalArray(sig?: Signature): ArraySignatureType;
+/**
+ * Format Signature to hex string array
+ */
 declare function signatureToHexArray(sig?: Signature): ArraySignatureType;
+/**
+ * Convert estimated fee to max fee with overhead
+ */
 declare function estimatedFeeToMaxFee(estimatedFee: BigNumberish, overhead?: number): bigint;
 
 declare const stark_compressProgram: typeof compressProgram;
@@ -4059,10 +4237,32 @@ declare class MerkleTree {
     branches: string[][];
     root: string;
     constructor(leafHashes: string[]);
+    /**
+     * Create Merkle tree
+     * @param leaves hex-string array
+     * @returns format: hex-string; Merkle tree root
+     */
     private build;
+    /**
+     * Create pedersen hash from a and b
+     * @returns format: hex-string
+     */
     static hash(a: string, b: string): string;
+    /**
+     * Return path to leaf
+     * @param leaf hex-string
+     * @param branch hex-string array
+     * @param hashPath hex-string array
+     * @returns format: hex-string array
+     */
     getProof(leaf: string, branch?: string[], hashPath?: string[]): string[];
 }
+/**
+ * Test Merkle tree path
+ * @param root hex-string
+ * @param leaf hex-string
+ * @param path hex-string array
+ */
 declare function proofMerklePath(root: string, leaf: string, path: string[]): boolean;
 
 type merkle_MerkleTree = MerkleTree;
@@ -4075,11 +4275,20 @@ declare namespace merkle {
   };
 }
 
-declare function uint256ToBN(uint256: Uint256): bigint;
 declare const UINT_128_MAX: bigint;
 declare const UINT_256_MAX: bigint;
+/**
+ * Convert Uint256 to bigint
+ */
+declare function uint256ToBN(uint256: Uint256): bigint;
+/**
+ * Test BigNumberish is smaller or equal 2**256-1
+ */
 declare function isUint256(bn: BigNumberish): boolean;
-declare function bnToUint256(bignumber: BigNumberish): Uint256;
+/**
+ * Convert BigNumberish (string | number | bigint) to Uint256 (hex)
+ */
+declare function bnToUint256(bn: BigNumberish): Uint256;
 
 declare const uint256$1_UINT_128_MAX: typeof UINT_128_MAX;
 declare const uint256$1_UINT_256_MAX: typeof UINT_256_MAX;
@@ -4098,41 +4307,54 @@ declare namespace uint256$1 {
   };
 }
 
+/**
+ * Test if string contains only ASCII characters (string can be ascii text)
+ */
 declare function isASCII(str: string): boolean;
+/**
+ * Test if string is a Cairo short string (string has less or equal 31 characters)
+ */
 declare function isShortString(str: string): boolean;
-declare function isDecimalString(decim: string): boolean;
 /**
- * check if value is string text, and not string-hex, string-number
- * @param val any
- * @returns boolean
+ * Test if string contains only numbers (string can be converted to decimal number)
+ */
+declare function isDecimalString(str: string): boolean;
+/**
+ * Test if value is a free-from string text, and not a hex string or number string
  */
 declare function isText(val: any): boolean;
+/**
+ * Test if value is short text
+ */
 declare const isShortText: (val: any) => boolean;
+/**
+ * Test if value is long text
+ */
 declare const isLongText: (val: any) => boolean;
+/**
+ * Split long text into short strings
+ */
 declare function splitLongString(longStr: string): string[];
 /**
- * Convert an ASCII string to an hexadecimal string.
- * @param str - ASCII string -
- * 31 characters maxi. Ex : "uri/item23.jpg"
- * @returns a string representing an Hex number 248 bits max.
- * @Example
+ * Convert an ASCII string to a hexadecimal string.
+ * @param str short string (ASCII string, 31 characters max)
+ * @returns format: hex-string; 248 bits max
+ * @example
  * ```typescript
  * const myEncodedString: string = encodeShortString("uri/pict/t38.jpg");
+ * // return hex string (ex."0x7572692f706963742f7433382e6a7067")
  * ```
- * returns : string : "0x7572692f706963742f7433382e6a7067"
  */
 declare function encodeShortString(str: string): string;
 /**
- * Convert an hexadecimal or decimal string to an ASCII string.
- * @param str - string - representing a 248 bits max number.
- *
- * Ex : hex : "0x1A4F64EA56" or decimal : "236942575435676423"
- * @returns a string with 31 characters max.
- * @Example
+ * Convert a hexadecimal or decimal string to an ASCII string.
+ * @param str representing a 248 bit max number (ex. "0x1A4F64EA56" or "236942575435676423")
+ * @returns format: short string; 31 characters max
+ * @example
  * ```typescript
  * const myDecodedString: string = decodeShortString("0x7572692f706963742f7433382e6a7067");
+ * // return string (ex."uri/pict/t38.jpg")
  * ```
- * return : string : "uri/pict/t38.jpg"
  */
 declare function decodeShortString(str: string): string;
 
@@ -4177,55 +4399,29 @@ interface Context {
 declare const getDependencies: (types: TypedData['types'], type: string, dependencies?: string[]) => string[];
 /**
  * Encode a type to a string. All dependant types are alphabetically sorted.
- *
- * @param {TypedData} typedData
- * @param {string} type
- * @return {string}
  */
 declare const encodeType: (types: TypedData['types'], type: string) => string;
 /**
  * Get a type string as hash.
- *
- * @param {TypedData} typedData
- * @param {string} type
- * @return {string}
  */
 declare const getTypeHash: (types: TypedData['types'], type: string) => 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.
- *
- * @param {TypedData} typedData
- * @param {string} type
- * @param {any} data
- * @returns {[string, string]}
  */
 declare const encodeValue: (types: TypedData['types'], type: string, data: unknown, ctx?: Context) => [string, string];
 /**
  * Encode the data to an ABI encoded Buffer. The data should be a key -> value object with all the required values. All
  * dependant types are automatically encoded.
- *
- * @param {TypedData} typedData
- * @param {string} type
- * @param {Record<string, any>} data
  */
 declare const encodeData: <T extends TypedData>(types: T["types"], type: string, data: T["message"]) => string[][];
 /**
  * Get encoded data as a hash. The data should be a key -> value object with all the required values. All dependant
  * types are automatically encoded.
- *
- * @param {TypedData} typedData
- * @param {string} type
- * @param {Record<string, any>} data
- * @return {Buffer}
  */
 declare const getStructHash: <T extends TypedData>(types: T["types"], type: string, data: T["message"]) => string;
 /**
  * Get the EIP-191 encoded message to sign, from the typedData object.
- *
- * @param {TypedData} typedData
- * @param {BigNumberish} account
- * @return {string}
  */
 declare const getMessageHash: (typedData: TypedData, account: BigNumberish) => string;
 
@@ -4282,8 +4478,21 @@ declare namespace starknetId {
   };
 }
 
+/**
+ * Helper - Async Sleep for 'delay' time
+ */
 declare function wait(delay: number): Promise<unknown>;
+/**
+ * Create Sierra Contract Class from a given Compiled Sierra
+ *
+ * CompiledSierra -> SierraContractClass
+ */
 declare function createSierraContractClass(contract: CompiledSierra): SierraContractClass;
+/**
+ * Create Contract Class from a given CompiledContract or string
+ *
+ * (CompiledContract or string) -> ContractClass
+ */
 declare function parseContract(contract: CompiledContract | string): ContractClass$1;
 
 declare const provider_createSierraContractClass: typeof createSierraContractClass;
@@ -4323,8 +4532,6 @@ declare function validateChecksumAddress(address: string): boolean;
 
 /**
  * Loosely validate a URL `string`.
- * @param {String} s
- * @return {Boolean}
  */
 declare function isUrl(s?: string): boolean;
 declare function buildUrl(baseUrl: string, defaultPath: string, urlOrPath?: string): string;
@@ -4367,8 +4574,7 @@ declare const isTypeEthAddress: (type: string) => boolean;
 declare const isCairo1Type: (type: string) => boolean;
 declare const getArrayType: (type: string) => string;
 /**
- * tells if an ABI comes from a Cairo 1 contract
- *
+ * Test if an ABI comes from a Cairo 1 contract
  * @param abi representing the interface of a Cairo contract
  * @returns TRUE if it is an ABI from a Cairo1 contract
  * @example
@@ -4378,20 +4584,29 @@ declare const getArrayType: (type: string) => string;
  */
 declare function isCairo1Abi(abi: Abi): boolean;
 /**
- * named tuple are described as js object {}
- * struct types are described as js object {}
- * array types are described as js array []
+ * named tuple cairo type is described as js object {}
+ * struct cairo type are described as js object {}
+ * array cairo type are described as js array []
  */
 /**
- * Uint256 cairo type (helper for common struct type)
+ * Create Uint256 Cairo type (helper for common struct type)
+ * @example
+ * ```typescript
+ * uint256('892349863487563453485768723498');
+ * ```
  */
 declare const uint256: (it: BigNumberish) => Uint256;
 /**
- * unnamed tuple cairo type (helper same as common struct type)
+ * Create unnamed tuple Cairo type (helper same as common struct type)
+ * @example
+ * ```typescript
+ * tuple(1,'0x101',16);
+ * ```
  */
 declare const tuple: (...args: (BigNumberish | object | boolean)[]) => Record<number, BigNumberish | object | boolean>;
 /**
- * felt cairo type
+ * Create felt Cairo type (cairo type helper)
+ * @returns format: felt-string
  */
 declare function felt(it: BigNumberish): string;
 
@@ -4521,16 +4736,13 @@ declare function isSierra(contract: CairoContract | string): contract is SierraC
 declare function extractContractHashes(payload: DeclareContractPayload): CompleteDeclareContractPayload;
 /**
  * Helper to redeclare response Cairo0 contract
- * @param ccr ContractClassResponse
- * @returns LegacyCompiledContract
  */
 declare function contractClassResponseToLegacyCompiledContract(ccr: ContractClassResponse): LegacyCompiledContract;
 
 /**
  * Parse Transaction Receipt Event from UDC invoke transaction and
- * create DeployContractResponse compatibile response with adition of UDC Event data
+ * create DeployContractResponse compatible response with addition of the UDC Event data
  *
- * @param txReceipt
  * @returns DeployContractResponse | UDC Event Response data
  */
 declare function parseUDCEvent(txReceipt: InvokeTransactionReceiptResponse): {