starknet 6.11.0 → 6.12.0

package/dist/index.d.ts

@@ -5,6 +5,7 @@ import * as weierstrass from '@noble/curves/abstract/weierstrass';
 import { RecoveredSignatureType } from '@noble/curves/abstract/weierstrass';
 import * as ts_mixer_dist_types_types from 'ts-mixer/dist/types/types';
 import { Abi as Abi$1, TypedContract } from 'abi-wan-kanabi';
+import Transport from '@ledgerhq/hw-transport';
 import * as poseidon from '@noble/curves/abstract/poseidon';
 import * as json$1 from 'lossless-json';
 import * as starknet from '@scure/starknet';
@@ -1558,6 +1559,20 @@ declare function sanitizeHex(hex: string): string;
  * ```
  */
 declare const pascalToSnake: (text: string) => string;
+/**
+ * Combine multiple Uint8Arrays into one.
+ * Useful for wallet path creation.
+ * @param {Uint8Array[]} uint8arrays An array of Uint8Array.
+ * @returns {Uint8Array} all the Uint8Arrays joined.
+ * @example
+ * ```typescript
+ * const path0buff = new Uint8Array([128, 0, 10, 85]);
+ * const path1buff = new Uint8Array([71, 65, 233, 201]);
+ * const result = encode.concatenateArrayBuffer([path0buff, path1buff]);
+ * // result = Uint8Array(8) [128, 0, 10, 85, 71, 65, 233, 201]
+ * ```
+ */
+declare function concatenateArrayBuffer(uint8arrays: Uint8Array[]): Uint8Array;
 
 declare const encode_IS_BROWSER: typeof IS_BROWSER;
 declare const encode_addHexPrefix: typeof addHexPrefix;
@@ -1566,6 +1581,7 @@ declare const encode_atobUniversal: typeof atobUniversal;
 declare const encode_btoaUniversal: typeof btoaUniversal;
 declare const encode_buf2hex: typeof buf2hex;
 declare const encode_calcByteLength: typeof calcByteLength;
+declare const encode_concatenateArrayBuffer: typeof concatenateArrayBuffer;
 declare const encode_padLeft: typeof padLeft;
 declare const encode_pascalToSnake: typeof pascalToSnake;
 declare const encode_removeHexPrefix: typeof removeHexPrefix;
@@ -1574,7 +1590,7 @@ declare const encode_sanitizeHex: typeof sanitizeHex;
 declare const encode_stringToArrayBuffer: typeof stringToArrayBuffer;
 declare const encode_utf8ToArray: typeof utf8ToArray;
 declare namespace encode {
-  export { encode_IS_BROWSER as IS_BROWSER, encode_addHexPrefix as addHexPrefix, encode_arrayBufferToString as arrayBufferToString, encode_atobUniversal as atobUniversal, encode_btoaUniversal as btoaUniversal, encode_buf2hex as buf2hex, encode_calcByteLength as calcByteLength, encode_padLeft as padLeft, encode_pascalToSnake as pascalToSnake, encode_removeHexPrefix as removeHexPrefix, encode_sanitizeBytes as sanitizeBytes, encode_sanitizeHex as sanitizeHex, encode_stringToArrayBuffer as stringToArrayBuffer, encode_utf8ToArray as utf8ToArray };
+  export { encode_IS_BROWSER as IS_BROWSER, encode_addHexPrefix as addHexPrefix, encode_arrayBufferToString as arrayBufferToString, encode_atobUniversal as atobUniversal, encode_btoaUniversal as btoaUniversal, encode_buf2hex as buf2hex, encode_calcByteLength as calcByteLength, encode_concatenateArrayBuffer as concatenateArrayBuffer, encode_padLeft as padLeft, encode_pascalToSnake as pascalToSnake, encode_removeHexPrefix as removeHexPrefix, encode_sanitizeBytes as sanitizeBytes, encode_sanitizeHex as sanitizeHex, encode_stringToArrayBuffer as stringToArrayBuffer, encode_utf8ToArray as utf8ToArray };
 }
 
 /**
@@ -1584,6 +1600,7 @@ declare const TEXT_TO_FELT_MAX_LEN = 31;
 
 declare const ZERO = 0n;
 declare const MASK_250: bigint;
+declare const MASK_31: bigint;
 declare const API_VERSION = 0n;
 declare const PRIME: bigint;
 declare const MAX_STORAGE_ITEM_SIZE = 256n;
@@ -1642,6 +1659,7 @@ type constants_FeeMarginPercentage = FeeMarginPercentage;
 declare const constants_FeeMarginPercentage: typeof FeeMarginPercentage;
 declare const constants_IS_BROWSER: typeof IS_BROWSER;
 declare const constants_MASK_250: typeof MASK_250;
+declare const constants_MASK_31: typeof MASK_31;
 declare const constants_MAX_STORAGE_ITEM_SIZE: typeof MAX_STORAGE_ITEM_SIZE;
 type constants_NetworkName = NetworkName;
 declare const constants_NetworkName: typeof NetworkName;
@@ -1659,7 +1677,7 @@ declare const constants_TransactionHashPrefix: typeof TransactionHashPrefix;
 declare const constants_UDC: typeof UDC;
 declare const constants_ZERO: typeof ZERO;
 declare namespace constants {
-  export { constants_ADDR_BOUND as ADDR_BOUND, constants_API_VERSION as API_VERSION, constants_BaseUrl as BaseUrl, constants_FeeMarginPercentage as FeeMarginPercentage, constants_IS_BROWSER as IS_BROWSER, constants_MASK_250 as MASK_250, constants_MAX_STORAGE_ITEM_SIZE as MAX_STORAGE_ITEM_SIZE, constants_NetworkName as NetworkName, constants_PRIME as PRIME, constants_RANGE_FELT as RANGE_FELT, constants_RANGE_I128 as RANGE_I128, constants_RANGE_U128 as RANGE_U128, constants_RPC_DEFAULT_VERSION as RPC_DEFAULT_VERSION, constants_RPC_NODES as RPC_NODES, constants_StarknetChainId as StarknetChainId, constants_TEXT_TO_FELT_MAX_LEN as TEXT_TO_FELT_MAX_LEN, ETransactionVersion$1 as TRANSACTION_VERSION, constants_TransactionHashPrefix as TransactionHashPrefix, constants_UDC as UDC, constants_ZERO as ZERO };
+  export { constants_ADDR_BOUND as ADDR_BOUND, constants_API_VERSION as API_VERSION, constants_BaseUrl as BaseUrl, constants_FeeMarginPercentage as FeeMarginPercentage, constants_IS_BROWSER as IS_BROWSER, constants_MASK_250 as MASK_250, constants_MASK_31 as MASK_31, constants_MAX_STORAGE_ITEM_SIZE as MAX_STORAGE_ITEM_SIZE, constants_NetworkName as NetworkName, constants_PRIME as PRIME, constants_RANGE_FELT as RANGE_FELT, constants_RANGE_I128 as RANGE_I128, constants_RANGE_U128 as RANGE_U128, constants_RPC_DEFAULT_VERSION as RPC_DEFAULT_VERSION, constants_RPC_NODES as RPC_NODES, constants_StarknetChainId as StarknetChainId, constants_TEXT_TO_FELT_MAX_LEN as TEXT_TO_FELT_MAX_LEN, ETransactionVersion$1 as TRANSACTION_VERSION, constants_TransactionHashPrefix as TransactionHashPrefix, constants_UDC as UDC, constants_ZERO as ZERO };
 }
 
 declare const ec_weierstrass: typeof weierstrass;
@@ -2217,6 +2235,7 @@ type RpcProviderOptions = {
         l1BoundMaxPricePerUnit: number;
         maxFee: number;
     };
+    batch?: false | number;
 };
 
 type Simplify<T> = {
@@ -2746,6 +2765,7 @@ declare class RpcChannel$1 {
     private chainId?;
     private specVersion?;
     readonly waitMode: Boolean;
+    private batchClient?;
     constructor(optionsOrProvider?: RpcProviderOptions);
     setChainId(chainId: StarknetChainId): void;
     fetch(method: string, params?: object, id?: string | number): Promise<Response>;
@@ -2827,6 +2847,7 @@ declare class RpcChannel {
     private specVersion?;
     private transactionRetryIntervalFallback?;
     readonly waitMode: Boolean;
+    private batchClient?;
     constructor(optionsOrProvider?: RpcProviderOptions);
     private get transactionRetryIntervalDefault();
     setChainId(chainId: StarknetChainId): void;
@@ -3249,7 +3270,7 @@ declare class RpcProvider$1 implements ProviderInterface {
     getBlockWithTxs(blockIdentifier?: BlockIdentifier): Promise<BlockWithTxs>;
     /**
      * Pause the execution of the script until a specified block is created.
-     * @param {BlockIdentifier} blockIdentifier bloc number (BigNumberisk) or 'pending' or 'latest'.
+     * @param {BlockIdentifier} blockIdentifier bloc number (BigNumberish) or 'pending' or 'latest'.
      * Use of 'latest" or of a block already created will generate no pause.
      * @param {number} [retryInterval] number of milliseconds between 2 requests to the node
      * @example
@@ -3515,6 +3536,68 @@ declare class EthSigner implements SignerInterface {
     protected formatEthSignature(ethSignature: RecoveredSignatureType): ArraySignatureType;
 }
 
+/**
+ * Signer for accounts using a Ledger Nano S+/X signature
+ */
+declare class LedgerSigner implements SignerInterface {
+    readonly transporter: Transport;
+    readonly accountID: number;
+    readonly eip2645applicationName: string;
+    readonly pathBuffer: Uint8Array;
+    private appVersion;
+    protected pubKey: string;
+    protected fullPubKey: string;
+    /**
+     * constructor of the LedgerSigner class.
+     * @param {Transport} transport 5 transports are available to handle USB, bluetooth, Node, Web, Mobile.
+     * See Guides for more details.
+     * @param {number} accountID ID of Ledger Nano (can handle 2**31 accounts).
+     * @param {string} [eip2645application='LedgerW'] A wallet is defined by an ERC2645 derivation path (6 items).
+     * One item is the `application`. Default value is `LedgerW`.
+     * @example
+     * ```typescript
+     * import TransportNodeHid from "@ledgerhq/hw-transport-node-hid";
+     * const myNodeTransport = await TransportNodeHid.create();
+     * const myLedgerSigner = new LedgerSigner(myNodeTransport, 0);
+     * ```
+     */
+    constructor(transport: Transport, accountID: number, eip2645application?: string);
+    /**
+     * provides the Starknet public key
+     * @returns an hex string : 64 characters are Point X coordinate.
+     */
+    getPubKey(): Promise<string>;
+    /**
+     * provides the full public key (with parity prefix)
+     * @returns an hex string : 2 first characters are the parity, the 64 following characters are Point X coordinate. 64 last characters are Point Y coordinate.
+     */
+    getFullPubKey(): Promise<string>;
+    /**
+     * Returns the version of the Starknet APP implemented in the Ledger.
+     * @returns {string} version.
+     * @example
+     * ```typescript
+     * const result = await myLedgerSigner.getAppVersion();
+     * // result= "1.1.1"
+     * ```
+     */
+    getAppVersion(): Promise<string>;
+    signMessage(typedDataToHash: TypedData, accountAddress: string): Promise<Signature>;
+    signTransaction(transactions: Call[], transactionsDetail: InvocationsSignerDetails): Promise<Signature>;
+    signDeployAccountTransaction(details: DeployAccountSignerDetails): Promise<Signature>;
+    signDeclareTransaction(details: DeclareSignerDetails): Promise<Signature>;
+    private signRaw;
+    private getPublicKeys;
+}
+/**
+ * format the Ledger wallet path to an Uint8Array.
+ * EIP2645 path = 2645'/starknet'/application'/0'/accountId'/0
+ * @param {number} accountId Id of account. < 2**31.
+ * @param {string} [applicationName='LedgerW'] utf8 string of application name.
+ * @returns an Uint8array of 24 bytes.
+ */
+declare function getLedgerPathBuffer(accountId: number, applicationName: string): Uint8Array;
+
 declare abstract class AccountInterface extends ProviderInterface {
     abstract address: string;
     abstract signer: SignerInterface;
@@ -4123,7 +4206,7 @@ declare class ContractFactory {
 }
 
 /**
- * Calculate the hex-string Keccak hash for a given BigNumberish
+ * Calculate the hex-string Starknet Keccak hash for a given BigNumberish
  *
  * @param value value to hash
  * @returns hex-string Keccak hash
@@ -4161,9 +4244,9 @@ declare function starknetKeccak(str: string): bigint;
  */
 declare function getSelectorFromName(funcName: string): string;
 /**
- * Calculate the hex-string selector from a given abi function name, decimal string or hex string
+ * Calculate the hex-string selector from a given abi function name or of any representation of number.
  *
- * @param value hex-string | dec-string | ascii-string
+ * @param value ascii-string | hex-string | dec-string | number | BigInt
  * @returns hex-string selector
  * @example
  * ```typescript
@@ -4175,16 +4258,125 @@ declare function getSelectorFromName(funcName: string): string;
  *
  * const selector3: string = getSelector("123456");
  * // selector3 = "0x1e240"
+ *
+ * const selector4: string = getSelector(123456n);
+ * // selector4 = "0x1e240"
+ * ```
+ */
+declare function getSelector(value: string | BigNumberish): string;
+/**
+ * Solidity hash of an array of uint256
+ * @param {BigNumberish[]} params an array of uint256 numbers
+ * @returns the hash of the array of Solidity uint256
+ * @example
+ * ```typescript
+ * const result = hash.solidityUint256PackedKeccak256(['0x100', '200', 300, 400n]);
+ * // result = '0xd1e6cb422b65269603c491b0c85463295edabebfb2a6844e4fdc389ff1dcdd97'
+ * ```
+ */
+declare function solidityUint256PackedKeccak256(params: BigNumberish[]): string;
+/**
+ * Calculate the L2 message hash related by a message L1->L2
+ * @param {BigNumberish} l1FromAddress L1 account address that paid the message.
+ * @param {BigNumberish} l2ToAddress L2 contract address to execute.
+ * @param {string | BigNumberish} l2Selector can be a function name ("bridge_withdraw") or a number (BigNumberish).
+ * @param {RawCalldata} l2Calldata an array of BigNumberish of the raw parameters passed to the above function.
+ * @param {BigNumberish} l1Nonce The nonce of the L1 account.
+ * @returns {string} hex-string of the L2 transaction hash
+ * @example
+ * ```typescript
+ * const l1FromAddress = "0x0000000000000000000000008453fc6cd1bcfe8d4dfc069c400b433054d47bdc";
+ * const l2ToAddress = 2158142789748719025684046545159279785659305214176670733242887773692203401023n;
+ * const l2Selector = 774397379524139446221206168840917193112228400237242521560346153613428128537n;
+ * const payload = [
+ *     4543560n,
+ *    829565602143178078434185452406102222830667255948n,
+ *     3461886633118033953192540141609307739580461579986333346825796013261542798665n,
+ *     9000000000000000n,
+ *     0n,
+ * ];
+ * const l1Nonce = 8288n;
+ * const result = hash.getL2MessageHash(l1FromAddress, l2ToAddress, l2Selector, payload, l1Nonce);
+ * // result = "0x2e350fa9d830482605cb68be4fdb9f0cb3e1f95a0c51623ac1a5d1bd997c2090"
  * ```
  */
-declare function getSelector(value: string): string;
+declare function getL2MessageHash(l1FromAddress: BigNumberish, l2ToAddress: BigNumberish, l2Selector: string | BigNumberish, l2Calldata: BigNumberish[], l1Nonce: BigNumberish): string;
 
+declare const selector_getL2MessageHash: typeof getL2MessageHash;
 declare const selector_getSelector: typeof getSelector;
 declare const selector_getSelectorFromName: typeof getSelectorFromName;
 declare const selector_keccakBn: typeof keccakBn;
+declare const selector_solidityUint256PackedKeccak256: typeof solidityUint256PackedKeccak256;
 declare const selector_starknetKeccak: typeof starknetKeccak;
 declare namespace selector {
-  export { selector_getSelector as getSelector, selector_getSelectorFromName as getSelectorFromName, selector_keccakBn as keccakBn, selector_starknetKeccak as starknetKeccak };
+  export { selector_getL2MessageHash as getL2MessageHash, selector_getSelector as getSelector, selector_getSelectorFromName as getSelectorFromName, selector_keccakBn as keccakBn, selector_solidityUint256PackedKeccak256 as solidityUint256PackedKeccak256, selector_starknetKeccak as starknetKeccak };
+}
+
+/**
+ * Calculate Hashes for v0 - v2 transactions
+ */
+
+/**
+ * Compute pedersen hash from data
+ * @returns format: hex-string - pedersen hash
+ */
+declare function computeHashOnElements$1(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$1(txHashPrefix: TransactionHashPrefix, version: BigNumberish, contractAddress: BigNumberish, entryPointSelector: BigNumberish, calldata: RawCalldata, maxFee: BigNumberish, chainId: StarknetChainId, additionalData?: BigNumberish[]): string;
+/**
+ * Calculate declare transaction hash
+ * @param classHash hex-string
+ * @param compiledClassHash hex-string
+ * @returns format: hex-string
+ */
+declare function calculateDeclareTransactionHash$2(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$2(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 the L2 transaction hash generated by a message L1->L2
+ * @param {BigNumberish} l1FromAddress L1 account address that paid the message.
+ * @param {BigNumberish} l2ToAddress L2 contract address to execute.
+ * @param {string | BigNumberish} l2Selector can be a function name ("bridge_withdraw") or a number (BigNumberish).
+ * @param {RawCalldata} l2Calldata an array of BigNumberish of the raw parameters passed to the above function.
+ * @param {BigNumberish} l2ChainId L2 chain ID : from constants.StarknetChainId.xxx
+ * @param {BigNumberish} l1Nonce The nonce of the L1 account.
+ * @returns {string} hex-string of the L2 transaction hash
+ * @example
+ * ```typescript
+ * const l1FromAddress = "0x0000000000000000000000008453fc6cd1bcfe8d4dfc069c400b433054d47bdc";
+ * const l2ToAddress = 2158142789748719025684046545159279785659305214176670733242887773692203401023n;
+ * const l2Selector = 774397379524139446221206168840917193112228400237242521560346153613428128537n;
+ * const payload = [
+ *     4543560n,
+ *    829565602143178078434185452406102222830667255948n,
+ *     3461886633118033953192540141609307739580461579986333346825796013261542798665n,
+ *     9000000000000000n,
+ *     0n,
+ * ];
+ * const l1Nonce = 8288n;
+ * const result = hash.calculateL2MessageTxHash(l1FromAddress, l2ToAddress, l2Selector, payload, constants.StarknetChainId.SN_SEPOLIA, l1Nonce);
+ * // result = "0x67d959200d65d4ad293aa4b0da21bb050a1f669bce37d215c6edbf041269c07"
+ * ```
+ */
+declare function calculateL2MessageTxHash(l1FromAddress: BigNumberish, l2ToAddress: BigNumberish, l2Selector: string | BigNumberish, l2Calldata: RawCalldata, l2ChainId: StarknetChainId, l1Nonce: BigNumberish): string;
+
+declare const v2_calculateL2MessageTxHash: typeof calculateL2MessageTxHash;
+declare const v2_calculateTransactionHash: typeof calculateTransactionHash;
+declare namespace v2 {
+  export { calculateDeclareTransactionHash$2 as calculateDeclareTransactionHash, calculateDeployAccountTransactionHash$2 as calculateDeployAccountTransactionHash, v2_calculateL2MessageTxHash as calculateL2MessageTxHash, v2_calculateTransactionHash as calculateTransactionHash, calculateTransactionHashCommon$1 as calculateTransactionHashCommon, computeHashOnElements$1 as computeHashOnElements };
 }
 
 /**
@@ -4238,7 +4430,7 @@ type CalcV3DeclareTxHashArgs = {
     paymasterData: BigNumberish[];
 };
 type CalcDeclareTxHashArgs = CalcV2DeclareTxHashArgs | CalcV3DeclareTxHashArgs;
-declare function calculateDeclareTransactionHash$2(args: CalcDeclareTxHashArgs): string;
+declare function calculateDeclareTransactionHash$1(args: CalcDeclareTxHashArgs): string;
 type CalcV2DeployAccountTxHashArgs = {
     contractAddress: BigNumberish;
     classHash: BigNumberish;
@@ -4264,7 +4456,7 @@ type CalcV3DeployAccountTxHashArgs = {
     paymasterData: BigNumberish[];
 };
 type CalcDeployAccountTxHashArgs = CalcV2DeployAccountTxHashArgs | CalcV3DeployAccountTxHashArgs;
-declare function calculateDeployAccountTransactionHash$2(args: CalcDeployAccountTxHashArgs): string;
+declare function calculateDeployAccountTransactionHash$1(args: CalcDeployAccountTxHashArgs): string;
 
 /**
  * Class Hash
@@ -4284,8 +4476,8 @@ declare function computePoseidonHash(a: BigNumberish, b: BigNumberish): string;
  * // result = 0x148141e8f7db29d005a0187669a56f0790d7e8c2c5b2d780e4d8b9e436a5521
  * ```
  */
-declare function computeHashOnElements$1(data: BigNumberish[]): string;
-declare const computePedersenHashOnElements: typeof computeHashOnElements$1;
+declare function computeHashOnElements(data: BigNumberish[]): string;
+declare const computePedersenHashOnElements: typeof computeHashOnElements;
 declare function computePoseidonHashOnElements(data: BigNumberish[]): string;
 /**
  * Calculate contract address from class hash
@@ -4392,8 +4584,10 @@ declare function computeContractClassHash(contract: CompiledContract | string):
  */
 
 declare const index$1_calculateContractAddressFromHash: typeof calculateContractAddressFromHash;
+declare const index$1_calculateL2MessageTxHash: typeof calculateL2MessageTxHash;
 declare const index$1_computeCompiledClassHash: typeof computeCompiledClassHash;
 declare const index$1_computeContractClassHash: typeof computeContractClassHash;
+declare const index$1_computeHashOnElements: typeof computeHashOnElements;
 declare const index$1_computeHintedClassHash: typeof computeHintedClassHash;
 declare const index$1_computeLegacyContractClassHash: typeof computeLegacyContractClassHash;
 declare const index$1_computePedersenHash: typeof computePedersenHash;
@@ -4402,14 +4596,16 @@ declare const index$1_computePoseidonHash: typeof computePoseidonHash;
 declare const index$1_computePoseidonHashOnElements: typeof computePoseidonHashOnElements;
 declare const index$1_computeSierraContractClassHash: typeof computeSierraContractClassHash;
 declare const index$1_formatSpaces: typeof formatSpaces;
+declare const index$1_getL2MessageHash: typeof getL2MessageHash;
 declare const index$1_getSelector: typeof getSelector;
 declare const index$1_getSelectorFromName: typeof getSelectorFromName;
 declare const index$1_hashByteCodeSegments: typeof hashByteCodeSegments;
 declare const index$1_keccakBn: typeof keccakBn;
 declare const index$1_poseidon: typeof poseidon;
+declare const index$1_solidityUint256PackedKeccak256: typeof solidityUint256PackedKeccak256;
 declare const index$1_starknetKeccak: typeof starknetKeccak;
 declare namespace index$1 {
-  export { index$1_calculateContractAddressFromHash as calculateContractAddressFromHash, calculateDeclareTransactionHash$2 as calculateDeclareTransactionHash, calculateDeployAccountTransactionHash$2 as calculateDeployAccountTransactionHash, calculateInvokeTransactionHash$1 as calculateInvokeTransactionHash, index$1_computeCompiledClassHash as computeCompiledClassHash, index$1_computeContractClassHash as computeContractClassHash, computeHashOnElements$1 as computeHashOnElements, index$1_computeHintedClassHash as computeHintedClassHash, index$1_computeLegacyContractClassHash as computeLegacyContractClassHash, index$1_computePedersenHash as computePedersenHash, index$1_computePedersenHashOnElements as computePedersenHashOnElements, index$1_computePoseidonHash as computePoseidonHash, index$1_computePoseidonHashOnElements as computePoseidonHashOnElements, index$1_computeSierraContractClassHash as computeSierraContractClassHash, index$1_formatSpaces as formatSpaces, index$1_getSelector as getSelector, index$1_getSelectorFromName as getSelectorFromName, index$1_hashByteCodeSegments as hashByteCodeSegments, index$1_keccakBn as keccakBn, index$1_poseidon as poseidon, index$1_starknetKeccak as starknetKeccak };
+  export { index$1_calculateContractAddressFromHash as calculateContractAddressFromHash, calculateDeclareTransactionHash$1 as calculateDeclareTransactionHash, calculateDeployAccountTransactionHash$1 as calculateDeployAccountTransactionHash, calculateInvokeTransactionHash$1 as calculateInvokeTransactionHash, index$1_calculateL2MessageTxHash as calculateL2MessageTxHash, index$1_computeCompiledClassHash as computeCompiledClassHash, index$1_computeContractClassHash as computeContractClassHash, index$1_computeHashOnElements as computeHashOnElements, index$1_computeHintedClassHash as computeHintedClassHash, index$1_computeLegacyContractClassHash as computeLegacyContractClassHash, index$1_computePedersenHash as computePedersenHash, index$1_computePedersenHashOnElements as computePedersenHashOnElements, index$1_computePoseidonHash as computePoseidonHash, index$1_computePoseidonHashOnElements as computePoseidonHashOnElements, index$1_computeSierraContractClassHash as computeSierraContractClassHash, index$1_formatSpaces as formatSpaces, index$1_getL2MessageHash as getL2MessageHash, index$1_getSelector as getSelector, index$1_getSelectorFromName as getSelectorFromName, index$1_hashByteCodeSegments as hashByteCodeSegments, index$1_keccakBn as keccakBn, index$1_poseidon as poseidon, index$1_solidityUint256PackedKeccak256 as solidityUint256PackedKeccak256, index$1_starknetKeccak as starknetKeccak };
 }
 
 /**
@@ -4418,71 +4614,31 @@ declare namespace index$1 {
 
 declare function hashDAMode(nonceDAMode: BigNumberish, feeDAMode: BigNumberish): bigint;
 declare function hashFeeField(tip: BigNumberish, bounds: ResourceBounds$2): bigint;
-declare function calculateTransactionHashCommon$1(txHashPrefix: TransactionHashPrefix, version: BigNumberish, senderAddress: BigNumberish, chainId: StarknetChainId, nonce: BigNumberish, tip: BigNumberish, paymasterData: BigNumberish[], nonceDataAvailabilityMode: EDAMode$1, feeDataAvailabilityMode: EDAMode$1, resourceBounds: ResourceBounds$2, additionalData?: BigNumberish[]): string;
+declare function calculateTransactionHashCommon(txHashPrefix: TransactionHashPrefix, version: BigNumberish, senderAddress: BigNumberish, chainId: StarknetChainId, nonce: BigNumberish, tip: BigNumberish, paymasterData: BigNumberish[], nonceDataAvailabilityMode: EDAMode$1, feeDataAvailabilityMode: EDAMode$1, resourceBounds: ResourceBounds$2, additionalData?: BigNumberish[]): string;
 /**
  * Calculate v3 deploy_account transaction hash
  * @returns format: hex-string
  */
-declare function calculateDeployAccountTransactionHash$1(contractAddress: BigNumberish, classHash: BigNumberish, compiledConstructorCalldata: Calldata, salt: BigNumberish, version: BigNumberish, chainId: StarknetChainId, nonce: BigNumberish, nonceDataAvailabilityMode: EDAMode$1, feeDataAvailabilityMode: EDAMode$1, resourceBounds: ResourceBounds$2, tip: BigNumberish, paymasterData: BigNumberish[]): string;
+declare function calculateDeployAccountTransactionHash(contractAddress: BigNumberish, classHash: BigNumberish, compiledConstructorCalldata: Calldata, salt: BigNumberish, version: BigNumberish, chainId: StarknetChainId, nonce: BigNumberish, nonceDataAvailabilityMode: EDAMode$1, feeDataAvailabilityMode: EDAMode$1, resourceBounds: ResourceBounds$2, tip: BigNumberish, paymasterData: BigNumberish[]): string;
 /**
  * Calculate v3 declare transaction hash
  * @returns format: hex-string
  */
-declare function calculateDeclareTransactionHash$1(classHash: string, compiledClassHash: string, senderAddress: BigNumberish, version: BigNumberish, chainId: StarknetChainId, nonce: BigNumberish, accountDeploymentData: BigNumberish[], nonceDataAvailabilityMode: EDAMode$1, feeDataAvailabilityMode: EDAMode$1, resourceBounds: ResourceBounds$2, tip: BigNumberish, paymasterData: BigNumberish[]): string;
+declare function calculateDeclareTransactionHash(classHash: string, compiledClassHash: string, senderAddress: BigNumberish, version: BigNumberish, chainId: StarknetChainId, nonce: BigNumberish, accountDeploymentData: BigNumberish[], nonceDataAvailabilityMode: EDAMode$1, feeDataAvailabilityMode: EDAMode$1, resourceBounds: ResourceBounds$2, tip: BigNumberish, paymasterData: BigNumberish[]): string;
 /**
  * Calculate v3 invoke transaction hash
  * @returns format: hex-string
  */
 declare function calculateInvokeTransactionHash(senderAddress: BigNumberish, version: BigNumberish, compiledCalldata: Calldata, chainId: StarknetChainId, nonce: BigNumberish, accountDeploymentData: BigNumberish[], nonceDataAvailabilityMode: EDAMode$1, feeDataAvailabilityMode: EDAMode$1, resourceBounds: ResourceBounds$2, tip: BigNumberish, paymasterData: BigNumberish[]): string;
 
+declare const v3_calculateDeclareTransactionHash: typeof calculateDeclareTransactionHash;
+declare const v3_calculateDeployAccountTransactionHash: typeof calculateDeployAccountTransactionHash;
 declare const v3_calculateInvokeTransactionHash: typeof calculateInvokeTransactionHash;
+declare const v3_calculateTransactionHashCommon: typeof calculateTransactionHashCommon;
 declare const v3_hashDAMode: typeof hashDAMode;
 declare const v3_hashFeeField: typeof hashFeeField;
 declare namespace v3 {
-  export { calculateDeclareTransactionHash$1 as calculateDeclareTransactionHash, calculateDeployAccountTransactionHash$1 as calculateDeployAccountTransactionHash, v3_calculateInvokeTransactionHash as calculateInvokeTransactionHash, calculateTransactionHashCommon$1 as calculateTransactionHashCommon, v3_hashDAMode as hashDAMode, v3_hashFeeField as hashFeeField };
-}
-
-/**
- * Calculate Hashes for v0 - v2 transactions
- */
-
-/**
- * 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 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;
-
-declare const v2_calculateDeclareTransactionHash: typeof calculateDeclareTransactionHash;
-declare const v2_calculateDeployAccountTransactionHash: typeof calculateDeployAccountTransactionHash;
-declare const v2_calculateTransactionHash: typeof calculateTransactionHash;
-declare const v2_calculateTransactionHashCommon: typeof calculateTransactionHashCommon;
-declare const v2_computeHashOnElements: typeof computeHashOnElements;
-declare namespace v2 {
-  export { v2_calculateDeclareTransactionHash as calculateDeclareTransactionHash, v2_calculateDeployAccountTransactionHash as calculateDeployAccountTransactionHash, v2_calculateTransactionHash as calculateTransactionHash, v2_calculateTransactionHashCommon as calculateTransactionHashCommon, v2_computeHashOnElements as computeHashOnElements };
+  export { v3_calculateDeclareTransactionHash as calculateDeclareTransactionHash, v3_calculateDeployAccountTransactionHash as calculateDeployAccountTransactionHash, v3_calculateInvokeTransactionHash as calculateInvokeTransactionHash, v3_calculateTransactionHashCommon as calculateTransactionHashCommon, v3_hashDAMode as hashDAMode, v3_hashFeeField as hashFeeField };
 }
 
 /**
@@ -4823,6 +4979,20 @@ declare function isNumber(value: unknown): value is number;
  * @return {boolean} - True if the value is of boolean type, false otherwise.
  */
 declare function isBoolean(value: unknown): value is boolean;
+/**
+ * Calculate the sha256 hash of an utf8 string, then encode the
+ * result in an uint8Array of 4 elements.
+ * Useful in wallet path calculation.
+ * @param {string} str utf8 string (hex string not handled).
+ * @returns a uint8Array of 4 bytes.
+ * @example
+ * ```typescript
+ * const ledgerPathApplicationName = 'LedgerW';
+ * const path2Buffer = num.stringToSha256ToArrayBuff4(ledgerPathApplicationName);
+ * // path2Buffer = Uint8Array(4) [43, 206, 231, 219]
+ * ```
+ */
+declare function stringToSha256ToArrayBuff4(str: string): Uint8Array;
 
 type num_BigNumberish = BigNumberish;
 declare const num_addPercent: typeof addPercent;
@@ -4840,13 +5010,14 @@ declare const num_isBoolean: typeof isBoolean;
 declare const num_isHex: typeof isHex;
 declare const num_isNumber: typeof isNumber;
 declare const num_isStringWholeNumber: typeof isStringWholeNumber;
+declare const num_stringToSha256ToArrayBuff4: typeof stringToSha256ToArrayBuff4;
 declare const num_toBigInt: typeof toBigInt;
 declare const num_toCairoBool: typeof toCairoBool;
 declare const num_toHex: typeof toHex;
 declare const num_toHexString: typeof toHexString;
 declare const num_toStorageKey: typeof toStorageKey;
 declare namespace num {
-  export { type num_BigNumberish as BigNumberish, num_addPercent as addPercent, num_assertInRange as assertInRange, num_bigNumberishArrayToDecimalStringArray as bigNumberishArrayToDecimalStringArray, num_bigNumberishArrayToHexadecimalStringArray as bigNumberishArrayToHexadecimalStringArray, num_cleanHex as cleanHex, num_getDecimalString as getDecimalString, num_getHexString as getHexString, num_getHexStringArray as getHexStringArray, num_hexToBytes as hexToBytes, num_hexToDecimalString as hexToDecimalString, num_isBigInt as isBigInt, num_isBoolean as isBoolean, num_isHex as isHex, num_isNumber as isNumber, num_isStringWholeNumber as isStringWholeNumber, num_toBigInt as toBigInt, num_toCairoBool as toCairoBool, num_toHex as toHex, num_toHexString as toHexString, num_toStorageKey as toStorageKey };
+  export { type num_BigNumberish as BigNumberish, num_addPercent as addPercent, num_assertInRange as assertInRange, num_bigNumberishArrayToDecimalStringArray as bigNumberishArrayToDecimalStringArray, num_bigNumberishArrayToHexadecimalStringArray as bigNumberishArrayToHexadecimalStringArray, num_cleanHex as cleanHex, num_getDecimalString as getDecimalString, num_getHexString as getHexString, num_getHexStringArray as getHexStringArray, num_hexToBytes as hexToBytes, num_hexToDecimalString as hexToDecimalString, num_isBigInt as isBigInt, num_isBoolean as isBoolean, num_isHex as isHex, num_isNumber as isNumber, num_isStringWholeNumber as isStringWholeNumber, num_stringToSha256ToArrayBuff4 as stringToSha256ToArrayBuff4, num_toBigInt as toBigInt, num_toCairoBool as toCairoBool, num_toHex as toHex, num_toHexString as toHexString, num_toStorageKey as toStorageKey };
 }
 
 /**
@@ -5665,10 +5836,20 @@ interface Context {
     key?: string;
 }
 /**
- * Prepares the selector for use.
+ * Prepares the selector for later use, if it's not already in correct format.
+ * The selector in correct format is the starknet_keccak hash of the function name, encoded in ASCII.
  *
  * @param {string} selector - The selector to be prepared.
  * @returns {string} The prepared selector.
+ *
+ * @example
+ * ```typescript
+ * const result1 = prepareSelector('0xc14cfe23f3fa7ce7b1f8db7d7682305b1692293f71a61cc06637f0d8d8b6c8');
+ * // result1 = '0xc14cfe23f3fa7ce7b1f8db7d7682305b1692293f71a61cc06637f0d8d8b6c8'
+ *
+ * const result2 =  prepareSelector('myFunction');
+ * // result2 = '0xc14cfe23f3fa7ce7b1f8db7d7682305b1692293f71a61cc06637f0d8d8b6c8'
+ * ```
  */
 declare function prepareSelector(selector: string): string;
 /**
@@ -5677,38 +5858,186 @@ declare function prepareSelector(selector: string): string;
  * @param {StarknetType} type - The StarkNet type to check.
  *
  * @returns {boolean} - True if the type is a Merkle tree type, false otherwise.
+ *
+ * @example
+ * ```typescript
+ * const type = { name: 'test', type: 'merkletree',};
+ * const result1 = isMerkleTreeType(type);
+ * // result1 = true
+ *
+ * const type2 = {name: 'test', type: 'non-merkletree',};
+ * const result2 =  isMerkleTreeType(type2);
+ * // result2 = false
+ * ```
  */
 declare function isMerkleTreeType(type: StarknetType): type is StarknetMerkleType;
 /**
  * Get the dependencies of a struct type. If a struct has the same dependency multiple times, it's only included once
  * in the resulting array.
+ *
+ * @param {TypedData['types']} types - The types object containing all defined types.
+ * @param {string} type - The name of the type to get dependencies for.
+ * @param {string[]} [dependencies=[]] - The array to store dependencies.
+ * @param {string} [contains=''] - The type contained within the struct.
+ * @param {Revision} [revision=Revision.Legacy] - The revision of the TypedData.
+ *
+ * @returns {string[]} The array of dependencies.
  */
 declare function getDependencies(types: TypedData['types'], type: string, dependencies?: string[], contains?: string, revision?: TypedDataRevision): string[];
 /**
  * Encode a type to a string. All dependent types are alphabetically sorted.
+ *
+ * @param {TypedData['types']} types - The types object containing all defined types.
+ * @param {string} type - The name of the type to encode.
+ * @param {Revision} [revision=Revision.Legacy] - The revision of the TypedData.
+ *
+ * @returns {string} The encoded string.
+ *
+ * @example
+ * ```typescript
+ * import typedDataExample from '../../__mocks__/typedData/baseExample.json';
+ *
+ * const result = encodeType(typedDataExample.types, 'Mail');
+ * // result = "Mail(from:Person,to:Person,contents:felt)Person(name:felt,wallet:felt)";
+ * ```
  */
 declare function encodeType(types: TypedData['types'], type: string, revision?: TypedDataRevision): string;
 /**
  * Get a type string as hash.
+ *
+ * @param {TypedData['types']} types - The types object containing all defined types.
+ * @param {string} type - The name of the type to hash.
+ * @param {Revision} [revision=Revision.Legacy] - The revision of the TypedData.
+ *
+ * @returns {string} The hash.
+ *
+ * @example
+ * ```typescript
+ * import typedDataExample from '../../__mocks__/typedData/baseExample.json';
+ *
+ * const result = getTypeHash(typedDataExample.types, 'StarkNetDomain');
+ * // result = "0x1bfc207425a47a5dfa1a50a4f5241203f50624ca5fdf5e18755765416b8e288";
+ * ```
  */
 declare function getTypeHash(types: TypedData['types'], type: string, revision?: TypedDataRevision): string;
 /**
- * Encodes a single value to an ABI serialisable string, number or Buffer. Returns the data as tuple, which consists of
+ * Encodes a single value to an ABI serialisable string, number or Buffer. Returns the data as a tuple, which consists of
  * an array of ABI compatible types, and an array of corresponding values.
+ *
+ * @param {TypedData['types']} types - The types object containing all defined types.
+ * @param {string} type - The name of the type to encode.
+ * @param {unknown} data - The data to encode.
+ * @param {Context} [ctx={}] - The context of the encoding process.
+ * @param {Revision} [revision=Revision.Legacy] - The revision of the TypedData.
+ *
+ * @returns {[string, string]} The ABI compatible type and corresponding value.
+ *
+ * @example
+ * ```typescript
+ * import { getSelectorFromName } from '../../src/utils/hash';
+ *
+ * const selector = 'transfer';
+ * const selectorHash = getSelectorFromName(selector);
+ * const result1 = encodeValue({}, 'felt', selectorHash);
+ *
+ * // result1 = ['felt', '0x83afd3f4caedc6eebf44246fe54e38c95e3179a5ec9ea81740eca5b482d12e']
+ * ```
  */
 declare function encodeValue(types: TypedData['types'], type: string, data: unknown, ctx?: Context, revision?: TypedDataRevision): [string, string];
 /**
  * Encode the data to an ABI encoded Buffer. The data should be a key -> value object with all the required values.
  * All dependent types are automatically encoded.
+ *
+ * @param {TypedData['types']} types - The types object containing all defined types.
+ * @param {string} type - The name of the type to encode.
+ * @param {TypedData['message']} data - The data to encode.
+ * @param {Revision} [revision=Revision.Legacy] - The revision of the TypedData.
+ *
+ * @returns {[string[], string[]]} The ABI compatible types and corresponding values.
  */
 declare function encodeData<T extends TypedData>(types: T['types'], type: string, data: T['message'], revision?: TypedDataRevision): string[][];
 /**
  * Get encoded data as a hash. The data should be a key -> value object with all the required values.
  * All dependent types are automatically encoded.
+ *
+ * @param {TypedData['types']} types - The types object containing all defined types.
+ * @param {string} type - The name of the type to hash.
+ * @param {TypedData['message']} data - The data to hash.
+ * @param {Revision} [revision=Revision.Legacy] - The revision of the TypedData.
+ *
+ * @returns {string} The hash of the encoded data.
+ *
+ * @example
+ * ```typescript
+ * import exampleBaseTypes from '../../__mocks__/typedData/example_baseTypes.json';
+ *
+ * const result = getStructHash(
+ *    exampleBaseTypes.types,
+ *    'StarknetDomain',
+ *    exampleBaseTypes.domain as StarknetDomain,
+ *    TypedDataRevision.ACTIVE
+ *  );
+ *  // result = "0x555f72e550b308e50c1a4f8611483a174026c982a9893a05c185eeb85399657";
+ * ```
  */
 declare function getStructHash<T extends TypedData>(types: T['types'], type: string, data: T['message'], revision?: TypedDataRevision): string;
 /**
  * Get the SNIP-12 encoded message to sign, from the typedData object.
+ *
+ * @param {TypedData} typedData - The TypedData object.
+ * @param {BigNumberish} account - The account to sign the message.
+ *
+ * @returns {string} The hash of the message to sign.
+ * @throws Will throw an error if the typedData does not match the JSON schema.
+ *
+ * @example
+ * ```typescript
+ * const exampleAddress = "0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826";
+ * const typedDataStringExample = {
+ *  types: {
+ *    StarkNetDomain: [
+ *      { name: 'name', type: 'felt' },
+ *      { name: 'version', type: 'felt' },
+ *      { name: 'chainId', type: 'felt' },
+ *    ],
+ *    Person: [
+ *      { name: 'name', type: 'felt' },
+ *      { name: 'wallet', type: 'felt' },
+ *    ],
+ *    String: [
+ *      { name: 'len', type: 'felt' },
+ *      { name: 'data', type: 'felt*' },
+ *    ],
+ *    Mail: [
+ *      { name: 'from', type: 'Person' },
+ *      { name: 'to', type: 'Person' },
+ *      { name: 'contents', type: 'String' },
+ *    ],
+ *  },
+ *  primaryType: 'Mail',
+ *  domain: {
+ *    name: 'StarkNet Mail',
+ *    version: '1',
+ *    chainId: 1,
+ *  },
+ *  message: {
+ *    from: {
+ *      name: 'Cow',
+ *      wallet: exampleAddress,
+ *    },
+ *    to: {
+ *      name: 'Bob',
+ *      wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
+ *    },
+ *    contents: stringToStringStruct(
+ *      'this is way longer than just 32 characters, to test if that is possible within a typedData struct.'
+ *    ),
+ *  },
+ * };
+ *
+ * const result = getMessageHash(typedDataStringExample, exampleAddress);
+ * // result = "0x70338fb11b8f70b68b261de8a322bcb004bd85e88ac47d9147982c7f5ac66fd"
+ * ```
  */
 declare function getMessageHash(typedData: TypedData, account: BigNumberish): string;
 
@@ -6946,4 +7275,4 @@ declare namespace connect {
 /** @deprecated prefer the 'num' naming */
 declare const number: typeof num;
 
-export { type Abi, type AbiEntry, type AbiEnum, type AbiEnums, type AbiEvent, type AbiEvents, type AbiInterfaces, type AbiStruct, type AbiStructs, Account, AccountInterface, type AccountInvocationItem, type AccountInvocations, type AccountInvocationsFactoryDetails, type AllowArray, type Args, type ArgsOrCalldata, type ArgsOrCalldataWithOptions, type ArraySignatureType, type AsyncContractFunction, type BigNumberish, type Block$1 as Block, type BlockIdentifier, type BlockNumber, BlockStatus, BlockTag, type BlockWithTxHashes, type Builtins, type ByteArray, type ByteCode, type CairoAssembly, type CairoContract, CairoCustomEnum, type CairoEnum, type CairoEnumRaw, type CairoEvent, type CairoEventDefinition, type CairoEventVariant, CairoOption, CairoOptionVariant, CairoResult, CairoResultVariant, CairoUint256, CairoUint512, type CairoVersion, type Call, type CallContractResponse, CallData, type CallDetails, type CallOptions, type CallStruct, type Calldata, type CompiledContract, type CompiledSierra, type CompiledSierraCasm, type CompilerVersion, type CompleteDeclareContractPayload, type CompressedProgram, Contract, type ContractClass, type ContractClassPayload, type ContractClassResponse, type ContractEntryPointFields, ContractFactory, type ContractFactoryParams, type ContractFunction, ContractInterface, type ContractOptions, type ContractVersion, CustomError, type DeclareAndDeployContractPayload, type DeclareContractPayload, type DeclareContractResponse, type DeclareContractTransaction, type DeclareDeployUDCResponse, type DeclareSignerDetails, type DeclareTransactionReceiptResponse, type DeployAccountContractPayload, type DeployAccountContractTransaction, type DeployAccountSignerDetails, type DeployAccountTransactionReceiptResponse, type DeployContractResponse, type DeployContractUDCResponse, type DeployTransactionReceiptResponse, type Details, EntryPointType, type EntryPointsByType, type EstimateFee, type EstimateFeeAction, type EstimateFeeBulk, type EstimateFeeDetails, type EstimateFeeResponse, type EstimateFeeResponseBulk, EthSigner, type EventEntry, type FeeEstimate, type FunctionAbi, GatewayError, type GetBlockResponse, type GetTransactionReceiptResponse, type GetTransactionResponse, type GetTxReceiptResponseWithoutHelper, type HexCalldata, HttpError, type InterfaceAbi, type Invocation, type Invocations, type InvocationsDetails, type InvocationsDetailsWithNonce, type InvocationsSignerDetails, type InvokeFunctionResponse, type InvokeOptions, type InvokeTransactionReceiptResponse, type L1HandlerTransactionReceiptResponse, type LegacyCompiledContract, type LegacyContractClass, type LegacyEvent, LibraryError, Literal, type MessageToL1, type MultiDeployContractResponse, type MultiType, type Nonce, type OptionalPayload, type ParsedEvent, type ParsedEvents, type ParsedStruct, type PendingBlock, type PendingStateUpdate, type Program, RpcProvider as Provider, ProviderInterface, type ProviderOptions, type PythonicHints, index$3 as RPC, rpc_0_6 as RPC06, rpc_0_7 as RPC07, RPCResponseParser, type RawArgs, type RawArgsArray, type RawArgsObject, type RawCalldata, ReceiptTx, type RejectedTransactionReceiptResponse, ResponseParser, type Result, type RevertedTransactionReceiptResponse, RpcChannel, RpcProvider, type RpcProviderOptions, type SIMULATION_FLAG, type SierraContractClass, type SierraContractEntryPointFields, type SierraEntryPointsByType, type SierraProgramDebugInfo, type Signature, Signer, SignerInterface, type SimulateTransactionDetails, type SimulateTransactionResponse, type SimulatedTransaction, type SimulationFlags, type StarkProfile, type StateUpdate, type StateUpdateResponse, type Storage, type SuccessfulTransactionReceiptResponse, TransactionExecutionStatus, TransactionFinalityStatus, type TransactionReceipt, type TransactionReceiptCallbacks, type TransactionReceiptCallbacksDefault, type TransactionReceiptCallbacksDefined, type TransactionReceiptStatus, type TransactionReceiptUtilityInterface, type TransactionReceiptValue, TransactionStatus, type TransactionStatusReceiptSets, TransactionType, type Tupled, type TypedContractV2, UINT_128_MAX, UINT_128_MIN, UINT_256_HIGH_MAX, UINT_256_HIGH_MIN, UINT_256_LOW_MAX, UINT_256_LOW_MIN, UINT_256_MAX, UINT_256_MIN, UINT_512_MAX, UINT_512_MIN, Uint, type Uint256, type Uint512, type UniversalDeployerContractPayload, type UniversalDetails, type V2DeclareSignerDetails, type V2DeployAccountSignerDetails, type V2InvocationsSignerDetails, type V3DeclareSignerDetails, type V3DeployAccountSignerDetails, type V3InvocationsSignerDetails, type V3TransactionDetails, ValidateType, WalletAccount, type WeierstrassSignatureType, addAddressPadding, buildUrl, byteArray, cairo, constants, contractClassResponseToLegacyCompiledContract, defaultProvider, ec, encode, eth, index as events, extractContractHashes, fixProto, fixStack, getCalldata, getChecksumAddress, type getContractVersionOptions, type getEstimateFeeBulkOptions, type getSimulateTransactionOptions, index$1 as hash, isSierra, isUrl, json, merkle, num, number, parseCalldataField, provider, selector, shortString, splitArgsAndOptions, stark, starknetId, transaction, typedData, index$2 as types, uint256$1 as uint256, v2 as v2hash, v3 as v3hash, validateAndParseAddress, validateChecksumAddress, type waitForTransactionOptions, connect as wallet };
+export { type Abi, type AbiEntry, type AbiEnum, type AbiEnums, type AbiEvent, type AbiEvents, type AbiInterfaces, type AbiStruct, type AbiStructs, Account, AccountInterface, type AccountInvocationItem, type AccountInvocations, type AccountInvocationsFactoryDetails, type AllowArray, type Args, type ArgsOrCalldata, type ArgsOrCalldataWithOptions, type ArraySignatureType, type AsyncContractFunction, type BigNumberish, type Block$1 as Block, type BlockIdentifier, type BlockNumber, BlockStatus, BlockTag, type BlockWithTxHashes, type Builtins, type ByteArray, type ByteCode, type CairoAssembly, type CairoContract, CairoCustomEnum, type CairoEnum, type CairoEnumRaw, type CairoEvent, type CairoEventDefinition, type CairoEventVariant, CairoOption, CairoOptionVariant, CairoResult, CairoResultVariant, CairoUint256, CairoUint512, type CairoVersion, type Call, type CallContractResponse, CallData, type CallDetails, type CallOptions, type CallStruct, type Calldata, type CompiledContract, type CompiledSierra, type CompiledSierraCasm, type CompilerVersion, type CompleteDeclareContractPayload, type CompressedProgram, Contract, type ContractClass, type ContractClassPayload, type ContractClassResponse, type ContractEntryPointFields, ContractFactory, type ContractFactoryParams, type ContractFunction, ContractInterface, type ContractOptions, type ContractVersion, CustomError, type DeclareAndDeployContractPayload, type DeclareContractPayload, type DeclareContractResponse, type DeclareContractTransaction, type DeclareDeployUDCResponse, type DeclareSignerDetails, type DeclareTransactionReceiptResponse, type DeployAccountContractPayload, type DeployAccountContractTransaction, type DeployAccountSignerDetails, type DeployAccountTransactionReceiptResponse, type DeployContractResponse, type DeployContractUDCResponse, type DeployTransactionReceiptResponse, type Details, EntryPointType, type EntryPointsByType, type EstimateFee, type EstimateFeeAction, type EstimateFeeBulk, type EstimateFeeDetails, type EstimateFeeResponse, type EstimateFeeResponseBulk, EthSigner, type EventEntry, type FeeEstimate, type FunctionAbi, GatewayError, type GetBlockResponse, type GetTransactionReceiptResponse, type GetTransactionResponse, type GetTxReceiptResponseWithoutHelper, type HexCalldata, HttpError, type InterfaceAbi, type Invocation, type Invocations, type InvocationsDetails, type InvocationsDetailsWithNonce, type InvocationsSignerDetails, type InvokeFunctionResponse, type InvokeOptions, type InvokeTransactionReceiptResponse, type L1HandlerTransactionReceiptResponse, LedgerSigner, type LegacyCompiledContract, type LegacyContractClass, type LegacyEvent, LibraryError, Literal, type MessageToL1, type MultiDeployContractResponse, type MultiType, type Nonce, type OptionalPayload, type ParsedEvent, type ParsedEvents, type ParsedStruct, type PendingBlock, type PendingStateUpdate, type Program, RpcProvider as Provider, ProviderInterface, type ProviderOptions, type PythonicHints, index$3 as RPC, rpc_0_6 as RPC06, rpc_0_7 as RPC07, RPCResponseParser, type RawArgs, type RawArgsArray, type RawArgsObject, type RawCalldata, ReceiptTx, type RejectedTransactionReceiptResponse, ResponseParser, type Result, type RevertedTransactionReceiptResponse, RpcChannel, RpcProvider, type RpcProviderOptions, type SIMULATION_FLAG, type SierraContractClass, type SierraContractEntryPointFields, type SierraEntryPointsByType, type SierraProgramDebugInfo, type Signature, Signer, SignerInterface, type SimulateTransactionDetails, type SimulateTransactionResponse, type SimulatedTransaction, type SimulationFlags, type StarkProfile, type StateUpdate, type StateUpdateResponse, type Storage, type SuccessfulTransactionReceiptResponse, TransactionExecutionStatus, TransactionFinalityStatus, type TransactionReceipt, type TransactionReceiptCallbacks, type TransactionReceiptCallbacksDefault, type TransactionReceiptCallbacksDefined, type TransactionReceiptStatus, type TransactionReceiptUtilityInterface, type TransactionReceiptValue, TransactionStatus, type TransactionStatusReceiptSets, TransactionType, type Tupled, type TypedContractV2, UINT_128_MAX, UINT_128_MIN, UINT_256_HIGH_MAX, UINT_256_HIGH_MIN, UINT_256_LOW_MAX, UINT_256_LOW_MIN, UINT_256_MAX, UINT_256_MIN, UINT_512_MAX, UINT_512_MIN, Uint, type Uint256, type Uint512, type UniversalDeployerContractPayload, type UniversalDetails, type V2DeclareSignerDetails, type V2DeployAccountSignerDetails, type V2InvocationsSignerDetails, type V3DeclareSignerDetails, type V3DeployAccountSignerDetails, type V3InvocationsSignerDetails, type V3TransactionDetails, ValidateType, WalletAccount, type WeierstrassSignatureType, addAddressPadding, buildUrl, byteArray, cairo, constants, contractClassResponseToLegacyCompiledContract, defaultProvider, ec, encode, eth, index as events, extractContractHashes, fixProto, fixStack, getCalldata, getChecksumAddress, type getContractVersionOptions, type getEstimateFeeBulkOptions, getLedgerPathBuffer, type getSimulateTransactionOptions, index$1 as hash, isSierra, isUrl, json, merkle, num, number, parseCalldataField, provider, selector, shortString, splitArgsAndOptions, stark, starknetId, transaction, typedData, index$2 as types, uint256$1 as uint256, v2 as v2hash, v3 as v3hash, validateAndParseAddress, validateChecksumAddress, type waitForTransactionOptions, connect as wallet };