starknet 5.11.1 → 5.12.0

package/dist/index.d.ts

@@ -141,99 +141,6 @@ declare namespace ec {
   };
 }
 
-type BigNumberish = string | number | bigint;
-declare function isHex(hex: string): boolean;
-declare function toBigInt(value: BigNumberish): bigint;
-declare function isBigInt(value: any): value is bigint;
-declare function toHex(number: BigNumberish): string;
-declare function hexToDecimalString(hex: string): string;
-/**
- * Remove hex string leading zero and lower case '0x01A'.. -> '0x1a..'
- * @param hex string
- */
-declare const cleanHex: (hex: string) => string;
-declare function assertInRange(input: BigNumberish, lowerBound: BigNumberish, upperBound: BigNumberish, inputName?: string): void;
-declare function bigNumberishArrayToDecimalStringArray(rawCalldata: BigNumberish[]): string[];
-declare function bigNumberishArrayToHexadecimalStringArray(rawCalldata: BigNumberish[]): string[];
-declare const isStringWholeNumber: (value: string) => boolean;
-declare const toHexString: (value: string) => string;
-declare function getDecimalString(value: string): string;
-declare function getHexString(value: string): string;
-declare function getHexStringArray(value: Array<string>): string[];
-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
- */
-declare function hexToBytes(value: string): Uint8Array;
-
-type num_BigNumberish = BigNumberish;
-declare const num_assertInRange: typeof assertInRange;
-declare const num_bigNumberishArrayToDecimalStringArray: typeof bigNumberishArrayToDecimalStringArray;
-declare const num_bigNumberishArrayToHexadecimalStringArray: typeof bigNumberishArrayToHexadecimalStringArray;
-declare const num_cleanHex: typeof cleanHex;
-declare const num_getDecimalString: typeof getDecimalString;
-declare const num_getHexString: typeof getHexString;
-declare const num_getHexStringArray: typeof getHexStringArray;
-declare const num_hexToBytes: typeof hexToBytes;
-declare const num_hexToDecimalString: typeof hexToDecimalString;
-declare const num_isBigInt: typeof isBigInt;
-declare const num_isHex: typeof isHex;
-declare const num_isStringWholeNumber: typeof isStringWholeNumber;
-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 namespace num {
-  export {
-    num_BigNumberish as BigNumberish,
-    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_isHex as isHex,
-    num_isStringWholeNumber as isStringWholeNumber,
-    num_toBigInt as toBigInt,
-    num_toCairoBool as toCairoBool,
-    num_toHex as toHex,
-    num_toHexString as toHexString,
-  };
-}
-
-interface Uint256 {
-    low: BigNumberish;
-    high: BigNumberish;
-}
-declare function uint256ToBN(uint256: Uint256): bigint;
-declare const UINT_128_MAX: bigint;
-declare const UINT_256_MAX: bigint;
-declare function isUint256(bn: BigNumberish): boolean;
-declare function bnToUint256(bignumber: BigNumberish): Uint256;
-
-declare const uint256$1_UINT_128_MAX: typeof UINT_128_MAX;
-declare const uint256$1_UINT_256_MAX: typeof UINT_256_MAX;
-type uint256$1_Uint256 = Uint256;
-declare const uint256$1_bnToUint256: typeof bnToUint256;
-declare const uint256$1_isUint256: typeof isUint256;
-declare const uint256$1_uint256ToBN: typeof uint256ToBN;
-declare namespace uint256$1 {
-  export {
-    uint256$1_UINT_128_MAX as UINT_128_MAX,
-    uint256$1_UINT_256_MAX as UINT_256_MAX,
-    uint256$1_Uint256 as Uint256,
-    uint256$1_bnToUint256 as bnToUint256,
-    uint256$1_isUint256 as isUint256,
-    uint256$1_uint256ToBN as uint256ToBN,
-  };
-}
-
 /** ABI */
 type Abi = Array<FunctionAbi | EventAbi | StructAbi>;
 type AbiEntry = {
@@ -342,6 +249,14 @@ declare enum EntryPointType {
 type WeierstrassSignatureType = weierstrass.SignatureType;
 type ArraySignatureType = string[];
 type Signature = ArraySignatureType | WeierstrassSignatureType;
+type BigNumberish = string | number | bigint;
+/**
+ * Represents an integer in the range [0, 2^256)
+ */
+interface Uint256 {
+    low: BigNumberish;
+    high: BigNumberish;
+}
 /**
  * BigNumberish array
  * use CallData.compile() to convert to Calldata
@@ -475,6 +390,7 @@ type Tupled = {
 };
 type BlockTag = 'pending' | 'latest';
 type BlockNumber = BlockTag | null | number;
+type BlockIdentifier = BlockNumber | BigNumberish;
 type Struct = {
     type: 'struct';
     [k: string]: BigNumberish;
@@ -495,55 +411,29 @@ interface CallStruct {
     calldata: string[];
 }
 
-interface InvocationsSignerDetails extends Required<InvocationsDetails> {
-    walletAddress: string;
-    chainId: StarknetChainId;
-    cairoVersion: CairoVersion;
-}
-interface DeclareSignerDetails {
-    classHash: string;
-    senderAddress: string;
-    chainId: StarknetChainId;
-    maxFee: BigNumberish;
-    version: BigNumberish;
-    nonce: BigNumberish;
-    compiledClassHash?: string;
+interface ProviderOptions {
+    sequencer?: SequencerProviderOptions;
+    rpc?: RpcProviderOptions;
 }
-type DeployAccountSignerDetails = Required<DeployAccountContractPayload> & Required<InvocationsDetails> & {
-    contractAddress: BigNumberish;
-    chainId: StarknetChainId;
-};
-
-type BlockIdentifier = BlockNumber | BigNumberish;
-
-type AsyncContractFunction<T = any> = (...args: ArgsOrCalldataWithOptions) => Promise<T>;
-type ContractFunction = (...args: ArgsOrCalldataWithOptions) => any;
-type Result = {
-    [key: string]: any;
-} | Result[] | bigint | string | boolean;
-/**
- * Compiled calldata ready to be sent
- * decimal-string array
- */
-type Calldata = string[] & {
-    readonly __compiled__?: boolean;
-};
-type ArgsOrCalldata = RawArgsArray | [Calldata] | Calldata;
-type ArgsOrCalldataWithOptions = ArgsOrCalldata & ContractOptions;
-type ContractOptions = {
+type RpcProviderOptions = {
+    nodeUrl: string;
+    retries?: number;
+    headers?: object;
     blockIdentifier?: BlockIdentifier;
-    parseRequest?: boolean;
-    parseResponse?: boolean;
-    formatResponse?: {
-        [key: string]: any;
-    };
-    maxFee?: BigNumberish;
-    nonce?: BigNumberish;
-    signature?: Signature;
-    addressSalt?: string;
+    chainId?: StarknetChainId;
 };
-type CallOptions = Pick<ContractOptions, 'blockIdentifier' | 'parseRequest' | 'parseResponse' | 'formatResponse'>;
-type InvokeOptions = Pick<ContractOptions, 'maxFee' | 'nonce' | 'signature' | 'parseRequest'>;
+type SequencerHttpMethod = 'POST' | 'GET';
+type SequencerProviderOptions = {
+    headers?: Record<string, string>;
+    blockIdentifier?: BlockIdentifier;
+    chainId?: StarknetChainId;
+} & ({
+    network: NetworkName | StarknetChainId;
+} | {
+    baseUrl: string;
+    feederGatewayUrl?: string;
+    gatewayUrl?: string;
+});
 
 /**
  * Starknet RPC version 0.2.1
@@ -1748,95 +1638,440 @@ interface TransactionSimulation extends TransactionSimulationResponse {
     fee_estimation: EstimateFee;
 }
 
-declare abstract class ProviderInterface {
-    /**
-     * Gets the Starknet chain Id
-     *
-     * @returns the chain Id
-     */
-    abstract getChainId(): Promise<StarknetChainId>;
-    /**
-     * Calls a function on the Starknet contract.
-     *
-     * @param call transaction to be called
-     * @param blockIdentifier block identifier
-     * @returns the result of the function on the smart contract.
-     */
-    abstract callContract(call: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;
-    /**
-     * Gets the block information
-     *
-     * @param blockIdentifier block identifier
-     * @returns the block object
-     */
-    abstract getBlock(blockIdentifier: BlockIdentifier): Promise<GetBlockResponse>;
-    /**
-     * @deprecated The method should not be used
-     */
-    abstract getCode(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;
-    /**
-     * Gets the contract class of the deployed contract.
-     *
-     * @param contractAddress - contract address
-     * @param blockIdentifier - block identifier
-     * @returns Contract class of compiled contract
-     */
-    abstract getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<ContractClass | RPC.ContractClass>;
-    /**
-     * Returns the class hash deployed under the given address.
-     *
-     * @param contractAddress - contract address
-     * @param blockIdentifier - block identifier
-     * @returns Class hash
-     */
-    abstract getClassHashAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<string>;
-    /**
-     * Returns the contract class deployed under the given class hash.
-     *
-     * @param classHash - class hash
-     * @returns Contract class of compiled contract
-     */
-    abstract getClassByHash(classHash: string): Promise<ContractClass | RPC.ContractClass>;
-    /**
-     * Gets the nonce of a contract with respect to a specific block
-     *
-     * @param contractAddress - contract address
-     * @returns the hex nonce
-     */
-    abstract getNonceForAddress(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<Nonce>;
-    /**
-     * Gets the contract's storage variable at a specific key.
-     *
-     * @param contractAddress
-     * @param key - from getStorageVarAddress('<STORAGE_VARIABLE_NAME>') (WIP)
-     * @param blockIdentifier - block identifier
-     * @returns the value of the storage variable
-     */
-    abstract getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<Storage>;
-    /**
-     * Gets the transaction information from a tx id.
-     *
-     * @param txHash
-     * @returns the transaction object \{ transaction_id, status, transaction, block_number?, block_number?, transaction_index?, transaction_failure_reason? \}
-     */
-    abstract getTransaction(transactionHash: BigNumberish): Promise<GetTransactionResponse>;
-    /**
-     * Gets the transaction receipt from a tx hash.
-     *
-     * @param txHash
-     * @returns the transaction receipt object
-     */
-    abstract getTransactionReceipt(transactionHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
-    /**
-     * Deploys a given compiled Account contract (json) to starknet
-     *
-     * @param payload payload to be deployed containing:
-     * - compiled contract code
-     * - constructor calldata
-     * - address salt
-     * @returns a confirmation of sending a transaction on the starknet contract
-     */
-    abstract deployAccountContract(payload: DeployAccountContractPayload, details: InvocationsDetailsWithNonce): Promise<DeployContractResponse>;
+type AsyncContractFunction<T = any> = (...args: ArgsOrCalldataWithOptions) => Promise<T>;
+type ContractFunction = (...args: ArgsOrCalldataWithOptions) => any;
+type Result = {
+    [key: string]: any;
+} | Result[] | bigint | string | boolean;
+/**
+ * Compiled calldata ready to be sent
+ * decimal-string array
+ */
+type Calldata = string[] & {
+    readonly __compiled__?: boolean;
+};
+type ArgsOrCalldata = RawArgsArray | [Calldata] | Calldata;
+type ArgsOrCalldataWithOptions = ArgsOrCalldata & ContractOptions;
+type ContractOptions = {
+    blockIdentifier?: BlockIdentifier;
+    parseRequest?: boolean;
+    parseResponse?: boolean;
+    formatResponse?: {
+        [key: string]: any;
+    };
+    maxFee?: BigNumberish;
+    nonce?: BigNumberish;
+    signature?: Signature;
+    addressSalt?: string;
+};
+type CallOptions = Pick<ContractOptions, 'blockIdentifier' | 'parseRequest' | 'parseResponse' | 'formatResponse'>;
+type InvokeOptions = Pick<ContractOptions, 'maxFee' | 'nonce' | 'signature' | 'parseRequest'>;
+
+interface InvocationsSignerDetails extends Required<InvocationsDetails> {
+    walletAddress: string;
+    chainId: StarknetChainId;
+    cairoVersion: CairoVersion;
+}
+interface DeclareSignerDetails {
+    classHash: string;
+    senderAddress: string;
+    chainId: StarknetChainId;
+    maxFee: BigNumberish;
+    version: BigNumberish;
+    nonce: BigNumberish;
+    compiledClassHash?: string;
+}
+type DeployAccountSignerDetails = Required<DeployAccountContractPayload> & Required<InvocationsDetails> & {
+    contractAddress: BigNumberish;
+    chainId: StarknetChainId;
+};
+
+type StarkNetMerkleType = {
+    name: string;
+    type: 'merkletree';
+    contains: string;
+};
+/**
+ * A single type, as part of a struct. The `type` field can be any of the EIP-712 supported types.
+ *
+ * Note that the `uint` and `int` aliases like in Solidity, and fixed point numbers are not supported by the EIP-712
+ * standard.
+ */
+type StarkNetType = {
+    name: string;
+    type: string;
+} | StarkNetMerkleType;
+/**
+ * The EIP712 domain struct. Any of these fields are optional, but it must contain at least one field.
+ */
+interface StarkNetDomain extends Record<string, unknown> {
+    name?: string;
+    version?: string;
+    chainId?: string | number;
+}
+/**
+ * The complete typed data, with all the structs, domain data, primary type of the message, and the message itself.
+ */
+interface TypedData {
+    types: Record<string, StarkNetType[]>;
+    primaryType: string;
+    domain: StarkNetDomain;
+    message: Record<string, unknown>;
+}
+
+type index_Abi = Abi;
+type index_AbiEntry = AbiEntry;
+type index_AbiStructs = AbiStructs;
+type index_AllowArray<T> = AllowArray<T>;
+type index_Args = Args;
+type index_ArgsOrCalldata = ArgsOrCalldata;
+type index_ArgsOrCalldataWithOptions = ArgsOrCalldataWithOptions;
+type index_ArraySignatureType = ArraySignatureType;
+type index_AsyncContractFunction<T = any> = AsyncContractFunction<T>;
+type index_BigNumberish = BigNumberish;
+type index_BlockIdentifier = BlockIdentifier;
+type index_BlockNumber = BlockNumber;
+type index_BlockTag = BlockTag;
+type index_Builtins = Builtins;
+type index_ByteCode = ByteCode;
+type index_CairoAssembly = CairoAssembly;
+type index_CairoContract = CairoContract;
+type index_CairoVersion = CairoVersion;
+type index_Call = Call;
+type index_CallContractResponse = CallContractResponse;
+type index_CallDetails = CallDetails;
+type index_CallL1Handler = CallL1Handler;
+type index_CallOptions = CallOptions;
+type index_CallStruct = CallStruct;
+type index_Calldata = Calldata;
+type index_CommonTransactionReceiptResponse = CommonTransactionReceiptResponse;
+type index_CommonTransactionResponse = CommonTransactionResponse;
+type index_CompiledContract = CompiledContract;
+type index_CompiledSierra = CompiledSierra;
+type index_CompiledSierraCasm = CompiledSierraCasm;
+type index_CompleteDeclareContractPayload = CompleteDeclareContractPayload;
+type index_CompressedProgram = CompressedProgram;
+type index_ContractClass = ContractClass;
+type index_ContractEntryPoint = ContractEntryPoint;
+type index_ContractEntryPointFields = ContractEntryPointFields;
+type index_ContractFunction = ContractFunction;
+type index_ContractOptions = ContractOptions;
+type index_DeclareAndDeployContractPayload = DeclareAndDeployContractPayload;
+type index_DeclareContractPayload = DeclareContractPayload;
+type index_DeclareContractResponse = DeclareContractResponse;
+type index_DeclareContractTransaction = DeclareContractTransaction;
+type index_DeclareDeployUDCResponse = DeclareDeployUDCResponse;
+type index_DeclareSignerDetails = DeclareSignerDetails;
+type index_DeclareTransactionReceiptResponse = DeclareTransactionReceiptResponse;
+type index_DeclareTransactionResponse = DeclareTransactionResponse;
+type index_DeployAccountContractPayload = DeployAccountContractPayload;
+type index_DeployAccountContractTransaction = DeployAccountContractTransaction;
+type index_DeployAccountSignerDetails = DeployAccountSignerDetails;
+type index_DeployContractPayload = DeployContractPayload;
+type index_DeployContractResponse = DeployContractResponse;
+type index_DeployContractUDCResponse = DeployContractUDCResponse;
+type index_DeployedContractItem = DeployedContractItem;
+type index_Details = Details;
+type index_EntryPointType = EntryPointType;
+declare const index_EntryPointType: typeof EntryPointType;
+type index_EntryPointsByType = EntryPointsByType;
+type index_EstimateFee = EstimateFee;
+type index_EstimateFeeAction = EstimateFeeAction;
+type index_EstimateFeeBulk = EstimateFeeBulk;
+type index_EstimateFeeDetails = EstimateFeeDetails;
+type index_EstimateFeeResponse = EstimateFeeResponse;
+type index_EstimateFeeResponseBulk = EstimateFeeResponseBulk;
+type index_Event = Event;
+type index_ExecutionResources = ExecutionResources;
+type index_FunctionAbi = FunctionAbi;
+type index_FunctionInvocation = FunctionInvocation;
+type index_GetBlockResponse = GetBlockResponse;
+type index_GetCodeResponse = GetCodeResponse;
+type index_GetContractAddressesResponse = GetContractAddressesResponse;
+type index_GetTransactionReceiptResponse = GetTransactionReceiptResponse;
+type index_GetTransactionResponse = GetTransactionResponse;
+type index_GetTransactionStatusResponse = GetTransactionStatusResponse;
+type index_HexCalldata = HexCalldata;
+type index_Invocation = Invocation;
+type index_InvocationBulk = InvocationBulk;
+type index_InvocationsDetails = InvocationsDetails;
+type index_InvocationsDetailsWithNonce = InvocationsDetailsWithNonce;
+type index_InvocationsSignerDetails = InvocationsSignerDetails;
+type index_InvokeFunctionResponse = InvokeFunctionResponse;
+type index_InvokeOptions = InvokeOptions;
+type index_InvokeTransactionReceiptResponse = InvokeTransactionReceiptResponse;
+type index_InvokeTransactionResponse = InvokeTransactionResponse;
+type index_LegacyCompiledContract = LegacyCompiledContract;
+type index_LegacyContractClass = LegacyContractClass;
+type index_MessageToL1 = MessageToL1;
+type index_MessageToL2 = MessageToL2;
+type index_MultiDeployContractResponse = MultiDeployContractResponse;
+type index_MultiType = MultiType;
+type index_Nonce = Nonce;
+type index_ParsedStruct = ParsedStruct;
+type index_Program = Program;
+type index_ProviderOptions = ProviderOptions;
+type index_PythonicHints = PythonicHints;
+declare const index_RPC: typeof RPC;
+type index_RawArgs = RawArgs;
+type index_RawArgsArray = RawArgsArray;
+type index_RawArgsObject = RawArgsObject;
+type index_RawCalldata = RawCalldata;
+type index_Result = Result;
+type index_RpcProviderOptions = RpcProviderOptions;
+declare const index_Sequencer: typeof Sequencer;
+type index_SequencerHttpMethod = SequencerHttpMethod;
+type index_SequencerIdentifier = SequencerIdentifier;
+type index_SequencerProviderOptions = SequencerProviderOptions;
+type index_SierraContractClass = SierraContractClass;
+type index_SierraContractEntryPointFields = SierraContractEntryPointFields;
+type index_SierraEntryPointsByType = SierraEntryPointsByType;
+type index_SierraProgramDebugInfo = SierraProgramDebugInfo;
+type index_Signature = Signature;
+type index_StarkNetDomain = StarkNetDomain;
+type index_StarkNetMerkleType = StarkNetMerkleType;
+type index_StarkNetType = StarkNetType;
+type index_StateUpdateResponse = StateUpdateResponse;
+type index_Status = Status;
+type index_Storage = Storage;
+type index_Struct = Struct;
+type index_StructAbi = StructAbi;
+type index_TransactionBulk = TransactionBulk;
+type index_TransactionSimulation = TransactionSimulation;
+type index_TransactionSimulationResponse = TransactionSimulationResponse;
+type index_TransactionStatus = TransactionStatus;
+declare const index_TransactionStatus: typeof TransactionStatus;
+type index_TransactionTraceResponse = TransactionTraceResponse;
+type index_TransactionType = TransactionType;
+declare const index_TransactionType: typeof TransactionType;
+type index_Tupled = Tupled;
+type index_TypedData = TypedData;
+type index_Uint256 = Uint256;
+type index_UniversalDeployerContractPayload = UniversalDeployerContractPayload;
+type index_WeierstrassSignatureType = WeierstrassSignatureType;
+type index_waitForTransactionOptions = waitForTransactionOptions;
+declare namespace index {
+  export {
+    index_Abi as Abi,
+    index_AbiEntry as AbiEntry,
+    index_AbiStructs as AbiStructs,
+    index_AllowArray as AllowArray,
+    index_Args as Args,
+    index_ArgsOrCalldata as ArgsOrCalldata,
+    index_ArgsOrCalldataWithOptions as ArgsOrCalldataWithOptions,
+    index_ArraySignatureType as ArraySignatureType,
+    index_AsyncContractFunction as AsyncContractFunction,
+    index_BigNumberish as BigNumberish,
+    index_BlockIdentifier as BlockIdentifier,
+    index_BlockNumber as BlockNumber,
+    index_BlockTag as BlockTag,
+    index_Builtins as Builtins,
+    index_ByteCode as ByteCode,
+    index_CairoAssembly as CairoAssembly,
+    index_CairoContract as CairoContract,
+    index_CairoVersion as CairoVersion,
+    index_Call as Call,
+    index_CallContractResponse as CallContractResponse,
+    index_CallDetails as CallDetails,
+    index_CallL1Handler as CallL1Handler,
+    index_CallOptions as CallOptions,
+    index_CallStruct as CallStruct,
+    index_Calldata as Calldata,
+    index_CommonTransactionReceiptResponse as CommonTransactionReceiptResponse,
+    index_CommonTransactionResponse as CommonTransactionResponse,
+    index_CompiledContract as CompiledContract,
+    index_CompiledSierra as CompiledSierra,
+    index_CompiledSierraCasm as CompiledSierraCasm,
+    index_CompleteDeclareContractPayload as CompleteDeclareContractPayload,
+    index_CompressedProgram as CompressedProgram,
+    index_ContractClass as ContractClass,
+    index_ContractEntryPoint as ContractEntryPoint,
+    index_ContractEntryPointFields as ContractEntryPointFields,
+    index_ContractFunction as ContractFunction,
+    index_ContractOptions as ContractOptions,
+    index_DeclareAndDeployContractPayload as DeclareAndDeployContractPayload,
+    index_DeclareContractPayload as DeclareContractPayload,
+    index_DeclareContractResponse as DeclareContractResponse,
+    index_DeclareContractTransaction as DeclareContractTransaction,
+    index_DeclareDeployUDCResponse as DeclareDeployUDCResponse,
+    index_DeclareSignerDetails as DeclareSignerDetails,
+    index_DeclareTransactionReceiptResponse as DeclareTransactionReceiptResponse,
+    index_DeclareTransactionResponse as DeclareTransactionResponse,
+    index_DeployAccountContractPayload as DeployAccountContractPayload,
+    index_DeployAccountContractTransaction as DeployAccountContractTransaction,
+    index_DeployAccountSignerDetails as DeployAccountSignerDetails,
+    index_DeployContractPayload as DeployContractPayload,
+    index_DeployContractResponse as DeployContractResponse,
+    index_DeployContractUDCResponse as DeployContractUDCResponse,
+    index_DeployedContractItem as DeployedContractItem,
+    index_Details as Details,
+    index_EntryPointType as EntryPointType,
+    index_EntryPointsByType as EntryPointsByType,
+    index_EstimateFee as EstimateFee,
+    index_EstimateFeeAction as EstimateFeeAction,
+    index_EstimateFeeBulk as EstimateFeeBulk,
+    index_EstimateFeeDetails as EstimateFeeDetails,
+    index_EstimateFeeResponse as EstimateFeeResponse,
+    index_EstimateFeeResponseBulk as EstimateFeeResponseBulk,
+    index_Event as Event,
+    index_ExecutionResources as ExecutionResources,
+    index_FunctionAbi as FunctionAbi,
+    index_FunctionInvocation as FunctionInvocation,
+    index_GetBlockResponse as GetBlockResponse,
+    index_GetCodeResponse as GetCodeResponse,
+    index_GetContractAddressesResponse as GetContractAddressesResponse,
+    index_GetTransactionReceiptResponse as GetTransactionReceiptResponse,
+    index_GetTransactionResponse as GetTransactionResponse,
+    index_GetTransactionStatusResponse as GetTransactionStatusResponse,
+    index_HexCalldata as HexCalldata,
+    index_Invocation as Invocation,
+    index_InvocationBulk as InvocationBulk,
+    index_InvocationsDetails as InvocationsDetails,
+    index_InvocationsDetailsWithNonce as InvocationsDetailsWithNonce,
+    index_InvocationsSignerDetails as InvocationsSignerDetails,
+    index_InvokeFunctionResponse as InvokeFunctionResponse,
+    index_InvokeOptions as InvokeOptions,
+    index_InvokeTransactionReceiptResponse as InvokeTransactionReceiptResponse,
+    index_InvokeTransactionResponse as InvokeTransactionResponse,
+    index_LegacyCompiledContract as LegacyCompiledContract,
+    index_LegacyContractClass as LegacyContractClass,
+    index_MessageToL1 as MessageToL1,
+    index_MessageToL2 as MessageToL2,
+    index_MultiDeployContractResponse as MultiDeployContractResponse,
+    index_MultiType as MultiType,
+    index_Nonce as Nonce,
+    index_ParsedStruct as ParsedStruct,
+    index_Program as Program,
+    index_ProviderOptions as ProviderOptions,
+    index_PythonicHints as PythonicHints,
+    index_RPC as RPC,
+    index_RawArgs as RawArgs,
+    index_RawArgsArray as RawArgsArray,
+    index_RawArgsObject as RawArgsObject,
+    index_RawCalldata as RawCalldata,
+    index_Result as Result,
+    index_RpcProviderOptions as RpcProviderOptions,
+    index_Sequencer as Sequencer,
+    index_SequencerHttpMethod as SequencerHttpMethod,
+    index_SequencerIdentifier as SequencerIdentifier,
+    index_SequencerProviderOptions as SequencerProviderOptions,
+    index_SierraContractClass as SierraContractClass,
+    index_SierraContractEntryPointFields as SierraContractEntryPointFields,
+    index_SierraEntryPointsByType as SierraEntryPointsByType,
+    index_SierraProgramDebugInfo as SierraProgramDebugInfo,
+    index_Signature as Signature,
+    index_StarkNetDomain as StarkNetDomain,
+    index_StarkNetMerkleType as StarkNetMerkleType,
+    index_StarkNetType as StarkNetType,
+    index_StateUpdateResponse as StateUpdateResponse,
+    index_Status as Status,
+    index_Storage as Storage,
+    index_Struct as Struct,
+    index_StructAbi as StructAbi,
+    index_TransactionBulk as TransactionBulk,
+    index_TransactionSimulation as TransactionSimulation,
+    index_TransactionSimulationResponse as TransactionSimulationResponse,
+    index_TransactionStatus as TransactionStatus,
+    index_TransactionTraceResponse as TransactionTraceResponse,
+    index_TransactionType as TransactionType,
+    index_Tupled as Tupled,
+    index_TypedData as TypedData,
+    index_Uint256 as Uint256,
+    index_UniversalDeployerContractPayload as UniversalDeployerContractPayload,
+    index_WeierstrassSignatureType as WeierstrassSignatureType,
+    index_waitForTransactionOptions as waitForTransactionOptions,
+  };
+}
+
+declare abstract class ProviderInterface {
+    /**
+     * Gets the Starknet chain Id
+     *
+     * @returns the chain Id
+     */
+    abstract getChainId(): Promise<StarknetChainId>;
+    /**
+     * Calls a function on the Starknet contract.
+     *
+     * @param call transaction to be called
+     * @param blockIdentifier block identifier
+     * @returns the result of the function on the smart contract.
+     */
+    abstract callContract(call: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;
+    /**
+     * Gets the block information
+     *
+     * @param blockIdentifier block identifier
+     * @returns the block object
+     */
+    abstract getBlock(blockIdentifier: BlockIdentifier): Promise<GetBlockResponse>;
+    /**
+     * @deprecated The method should not be used
+     */
+    abstract getCode(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;
+    /**
+     * Gets the contract class of the deployed contract.
+     *
+     * @param contractAddress - contract address
+     * @param blockIdentifier - block identifier
+     * @returns Contract class of compiled contract
+     */
+    abstract getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<ContractClass | RPC.ContractClass>;
+    /**
+     * Returns the class hash deployed under the given address.
+     *
+     * @param contractAddress - contract address
+     * @param blockIdentifier - block identifier
+     * @returns Class hash
+     */
+    abstract getClassHashAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<string>;
+    /**
+     * Returns the contract class deployed under the given class hash.
+     *
+     * @param classHash - class hash
+     * @returns Contract class of compiled contract
+     */
+    abstract getClassByHash(classHash: string): Promise<ContractClass | RPC.ContractClass>;
+    /**
+     * Gets the nonce of a contract with respect to a specific block
+     *
+     * @param contractAddress - contract address
+     * @returns the hex nonce
+     */
+    abstract getNonceForAddress(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<Nonce>;
+    /**
+     * Gets the contract's storage variable at a specific key.
+     *
+     * @param contractAddress
+     * @param key - from getStorageVarAddress('<STORAGE_VARIABLE_NAME>') (WIP)
+     * @param blockIdentifier - block identifier
+     * @returns the value of the storage variable
+     */
+    abstract getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<Storage>;
+    /**
+     * Gets the transaction information from a tx id.
+     *
+     * @param txHash
+     * @returns the transaction object \{ transaction_id, status, transaction, block_number?, block_number?, transaction_index?, transaction_failure_reason? \}
+     */
+    abstract getTransaction(transactionHash: BigNumberish): Promise<GetTransactionResponse>;
+    /**
+     * Gets the transaction receipt from a tx hash.
+     *
+     * @param txHash
+     * @returns the transaction receipt object
+     */
+    abstract getTransactionReceipt(transactionHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
+    /**
+     * Deploys a given compiled Account contract (json) to starknet
+     *
+     * @param payload payload to be deployed containing:
+     * - compiled contract code
+     * - constructor calldata
+     * - address salt
+     * @returns a confirmation of sending a transaction on the starknet contract
+     */
+    abstract deployAccountContract(payload: DeployAccountContractPayload, details: InvocationsDetailsWithNonce): Promise<DeployContractResponse>;
     /**
      * Invokes a function on starknet
      * @deprecated This method wont be supported as soon as fees are mandatory. Should not be used outside of Account class
@@ -1979,102 +2214,52 @@ declare abstract class ProviderInterface {
     abstract getStateUpdate(blockIdentifier?: BlockIdentifier): Promise<StateUpdateResponse>;
 }
 
-type RpcProviderOptions = {
-    nodeUrl: string;
-    retries?: number;
-    headers?: object;
-    blockIdentifier?: BlockIdentifier;
-    chainId?: StarknetChainId;
-};
-declare class RpcProvider implements ProviderInterface {
-    nodeUrl: string;
-    headers: object;
-    private responseParser;
-    private retries;
-    private blockIdentifier;
-    private chainId?;
-    constructor(optionsOrProvider: RpcProviderOptions);
-    fetch(method: any, params: any): Promise<any>;
-    protected errorHandler(error: any): void;
-    protected fetchEndpoint<T extends keyof RPC.Methods>(method: T, params?: RPC.Methods[T]['params']): Promise<RPC.Methods[T]['result']>;
+declare class Provider implements ProviderInterface {
+    private provider;
+    constructor(providerOrOptions?: ProviderOptions | ProviderInterface);
     getChainId(): Promise<StarknetChainId>;
-    getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
-    getBlockHashAndNumber(): Promise<RPC.BlockHashAndNumber>;
-    getBlockWithTxHashes(blockIdentifier?: BlockIdentifier): Promise<RPC.GetBlockWithTxHashesResponse>;
-    getBlockWithTxs(blockIdentifier?: BlockIdentifier): Promise<RPC.GetBlockWithTxs>;
-    getClassHashAt(contractAddress: RPC.ContractAddress, blockIdentifier?: BlockIdentifier): Promise<RPC.Felt>;
-    getNonceForAddress(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<RPC.Nonce>;
-    getPendingTransactions(): Promise<RPC.PendingTransactions>;
-    getProtocolVersion(): Promise<Error>;
-    getStateUpdate(blockIdentifier?: BlockIdentifier): Promise<RPC.StateUpdate>;
-    getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<RPC.Storage>;
-    getTransaction(txHash: string): Promise<GetTransactionResponse>;
-    getTransactionByHash(txHash: string): Promise<RPC.GetTransactionByHashResponse>;
-    getTransactionByBlockIdAndIndex(blockIdentifier: BlockIdentifier, index: number): Promise<RPC.GetTransactionByBlockIdAndIndex>;
-    getTransactionReceipt(txHash: string): Promise<RPC.TransactionReceipt>;
-    getClassByHash(classHash: RPC.Felt): Promise<RPC.ContractClass>;
-    getClass(classHash: RPC.Felt, blockIdentifier?: BlockIdentifier): Promise<RPC.ContractClass>;
-    getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<RPC.ContractClass>;
-    getCode(_contractAddress: string, _blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;
-    getEstimateFee(invocation: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
-    getInvokeEstimateFee(invocation: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
-    getDeclareEstimateFee({ senderAddress, contractDefinition, signature }: DeclareContractTransaction, details: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
-    getDeployAccountEstimateFee({ classHash, constructorCalldata, addressSalt, signature }: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
-    getEstimateFeeBulk(_invocations: InvocationBulk, _blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponseBulk>;
-    declareContract({ contractDefinition, signature, senderAddress }: DeclareContractTransaction, details: InvocationsDetailsWithNonce): Promise<DeclareContractResponse>;
-    deployAccountContract({ classHash, constructorCalldata, addressSalt, signature }: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce): Promise<DeployContractResponse>;
+    getBlock(blockIdentifier: BlockIdentifier): Promise<GetBlockResponse>;
+    getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<ContractClass | RPC.ContractClass>;
+    getClassHashAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<string>;
+    getClassByHash(classHash: string): Promise<ContractClass | RPC.ContractClass>;
+    getEstimateFee(invocationWithTxType: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier: BlockIdentifier): Promise<EstimateFeeResponse>;
+    getInvokeEstimateFee(invocationWithTxType: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier, skipValidate?: boolean): Promise<EstimateFeeResponse>;
+    getEstimateFeeBulk(invocations: InvocationBulk, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponseBulk>;
+    getNonceForAddress(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<Nonce>;
+    getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<Storage>;
+    getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse>;
+    getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
+    callContract(request: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;
     invokeFunction(functionInvocation: Invocation, details: InvocationsDetailsWithNonce): Promise<InvokeFunctionResponse>;
-    callContract(call: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;
-    traceTransaction(transactionHash: RPC.TransactionHash): Promise<RPC.Trace>;
-    traceBlockTransactions(blockHash: RPC.BlockHash): Promise<RPC.Traces>;
-    waitForTransaction(txHash: string, options?: waitForTransactionOptions): Promise<any>;
-    /**
-     * Gets the transaction count from a block.
-     *
-     *
-     * @param blockIdentifier
-     * @returns Number of transactions
-     */
-    getTransactionCount(blockIdentifier?: BlockIdentifier): Promise<RPC.GetTransactionCountResponse>;
-    /**
-     * Gets the latest block number
-     *
-     *
-     * @returns Number of the latest block
-     */
-    getBlockNumber(): Promise<RPC.GetBlockNumberResponse>;
-    /**
-     * Gets syncing status of the node
-     *
-     *
-     * @returns Object with the stats data
-     */
-    getSyncingStats(): Promise<RPC.GetSyncingStatsResponse>;
-    /**
-     * Gets all the events filtered
-     *
-     *
-     * @returns events and the pagination of the events
-     */
-    getEvents(eventFilter: RPC.EventFilter): Promise<RPC.GetEventsResponse>;
-    getSimulateTransaction(_invocation: Invocation, _invocationDetails: InvocationsDetailsWithNonce, _blockIdentifier?: BlockIdentifier): Promise<TransactionSimulationResponse>;
+    deployAccountContract(payload: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce): Promise<DeployContractResponse>;
+    declareContract(transaction: DeclareContractTransaction, details: InvocationsDetailsWithNonce): Promise<DeclareContractResponse>;
+    getDeclareEstimateFee(transaction: DeclareContractTransaction, details: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier, skipValidate?: boolean): Promise<EstimateFeeResponse>;
+    getDeployAccountEstimateFee(transaction: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier, skipValidate?: boolean): Promise<EstimateFeeResponse>;
+    getCode(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;
+    waitForTransaction(txHash: BigNumberish, options?: waitForTransactionOptions): Promise<GetTransactionReceiptResponse>;
+    getSimulateTransaction(invocation: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier, skipValidate?: boolean): Promise<TransactionSimulationResponse>;
+    getStateUpdate(blockIdentifier?: BlockIdentifier): Promise<StateUpdateResponse>;
     getStarkName(address: BigNumberish, StarknetIdContract?: string): Promise<string>;
     getAddressFromStarkName(name: string, StarknetIdContract?: string): Promise<string>;
 }
 
-type SequencerHttpMethod = 'POST' | 'GET';
-type SequencerProviderOptions = {
-    headers?: Record<string, string>;
-    blockIdentifier?: BlockIdentifier;
-} & ({
-    network: NetworkName | StarknetChainId;
-    chainId?: StarknetChainId;
-} | {
-    baseUrl: string;
-    feederGatewayUrl?: string;
-    gatewayUrl?: string;
-    chainId?: StarknetChainId;
-});
+declare function fixStack(target: Error, fn?: Function): void;
+declare function fixProto(target: Error, prototype: {}): void;
+declare class CustomError extends Error {
+    name: string;
+    constructor(message?: string);
+}
+declare class LibraryError extends CustomError {
+}
+declare class GatewayError extends LibraryError {
+    errorCode: string;
+    constructor(message: string, errorCode: string);
+}
+declare class HttpError extends LibraryError {
+    errorCode: number;
+    constructor(message: string, errorCode: number);
+}
+
 declare class SequencerProvider implements ProviderInterface {
     baseUrl: string;
     feederGatewayUrl: string;
@@ -2140,200 +2325,92 @@ declare class SequencerProvider implements ProviderInterface {
      * @returns the transaction trace
      */
     getTransactionTrace(txHash: BigNumberish): Promise<TransactionTraceResponse>;
-    estimateMessageFee({ from_address, to_address, entry_point_selector, payload }: CallL1Handler, blockIdentifier?: BlockIdentifier): Promise<Sequencer.EstimateFeeResponse>;
-    getSimulateTransaction(invocation: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier, skipValidate?: boolean): Promise<TransactionSimulationResponse>;
-    getStateUpdate(blockIdentifier?: BlockIdentifier): Promise<StateUpdateResponse>;
-    getBlockTraces(blockIdentifier?: BlockIdentifier): Promise<Sequencer.BlockTransactionTracesResponse>;
-    getStarkName(address: BigNumberish, StarknetIdContract?: string): Promise<string>;
-    getAddressFromStarkName(name: string, StarknetIdContract?: string): Promise<string>;
-}
-
-interface ProviderOptions {
-    sequencer?: SequencerProviderOptions;
-    rpc?: RpcProviderOptions;
-}
-declare class Provider implements ProviderInterface {
-    private provider;
-    constructor(providerOrOptions?: ProviderOptions | ProviderInterface);
-    getChainId(): Promise<StarknetChainId>;
-    getBlock(blockIdentifier: BlockIdentifier): Promise<GetBlockResponse>;
-    getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<ContractClass | RPC.ContractClass>;
-    getClassHashAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<string>;
-    getClassByHash(classHash: string): Promise<ContractClass | RPC.ContractClass>;
-    getEstimateFee(invocationWithTxType: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier: BlockIdentifier): Promise<EstimateFeeResponse>;
-    getInvokeEstimateFee(invocationWithTxType: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier, skipValidate?: boolean): Promise<EstimateFeeResponse>;
-    getEstimateFeeBulk(invocations: InvocationBulk, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponseBulk>;
-    getNonceForAddress(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<Nonce>;
-    getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<Storage>;
-    getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse>;
-    getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
-    callContract(request: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;
-    invokeFunction(functionInvocation: Invocation, details: InvocationsDetailsWithNonce): Promise<InvokeFunctionResponse>;
-    deployAccountContract(payload: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce): Promise<DeployContractResponse>;
-    declareContract(transaction: DeclareContractTransaction, details: InvocationsDetailsWithNonce): Promise<DeclareContractResponse>;
-    getDeclareEstimateFee(transaction: DeclareContractTransaction, details: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier, skipValidate?: boolean): Promise<EstimateFeeResponse>;
-    getDeployAccountEstimateFee(transaction: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier, skipValidate?: boolean): Promise<EstimateFeeResponse>;
-    getCode(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;
-    waitForTransaction(txHash: BigNumberish, options?: waitForTransactionOptions): Promise<GetTransactionReceiptResponse>;
-    getSimulateTransaction(invocation: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier, skipValidate?: boolean): Promise<TransactionSimulationResponse>;
-    getStateUpdate(blockIdentifier?: BlockIdentifier): Promise<StateUpdateResponse>;
-    getStarkName(address: BigNumberish, StarknetIdContract?: string): Promise<string>;
-    getAddressFromStarkName(name: string, StarknetIdContract?: string): Promise<string>;
-}
-
-declare function fixStack(target: Error, fn?: Function): void;
-declare function fixProto(target: Error, prototype: {}): void;
-declare class CustomError extends Error {
-    name: string;
-    constructor(message?: string);
-}
-declare class LibraryError extends CustomError {
-}
-declare class GatewayError extends LibraryError {
-    errorCode: string;
-    constructor(message: string, errorCode: string);
-}
-declare class HttpError extends LibraryError {
-    errorCode: number;
-    constructor(message: string, errorCode: number);
-}
-
-declare const defaultProvider: Provider;
-
-type StarkNetMerkleType = {
-    name: string;
-    type: 'merkletree';
-    contains: string;
-};
-/**
- * A single type, as part of a struct. The `type` field can be any of the EIP-712 supported types.
- *
- * Note that the `uint` and `int` aliases like in Solidity, and fixed point numbers are not supported by the EIP-712
- * standard.
- */
-type StarkNetType = {
-    name: string;
-    type: string;
-} | StarkNetMerkleType;
-/**
- * The EIP712 domain struct. Any of these fields are optional, but it must contain at least one field.
- */
-interface StarkNetDomain extends Record<string, unknown> {
-    name?: string;
-    version?: string;
-    chainId?: string | number;
-}
-/**
- * The complete typed data, with all the structs, domain data, primary type of the message, and the message itself.
- */
-interface TypedData {
-    types: Record<string, StarkNetType[]>;
-    primaryType: string;
-    domain: StarkNetDomain;
-    message: Record<string, unknown>;
-}
-
-declare function prepareSelector(selector: string): string;
-declare function isMerkleTreeType(type: StarkNetType): type is StarkNetMerkleType;
-interface Context {
-    parent?: string;
-    key?: string;
-}
-/**
- * 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} typedData
- * @param {string} type
- * @param {string[]} [dependencies]
- * @return {string[]}
- */
-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;
+    estimateMessageFee({ from_address, to_address, entry_point_selector, payload }: CallL1Handler, blockIdentifier?: BlockIdentifier): Promise<Sequencer.EstimateFeeResponse>;
+    getSimulateTransaction(invocation: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier, skipValidate?: boolean): Promise<TransactionSimulationResponse>;
+    getStateUpdate(blockIdentifier?: BlockIdentifier): Promise<StateUpdateResponse>;
+    getBlockTraces(blockIdentifier?: BlockIdentifier): Promise<Sequencer.BlockTransactionTracesResponse>;
+    getStarkName(address: BigNumberish, StarknetIdContract?: string): Promise<string>;
+    getAddressFromStarkName(name: string, StarknetIdContract?: string): Promise<string>;
+}
 
-type index_StarkNetDomain = StarkNetDomain;
-type index_StarkNetMerkleType = StarkNetMerkleType;
-type index_StarkNetType = StarkNetType;
-type index_TypedData = TypedData;
-declare const index_encodeData: typeof encodeData;
-declare const index_encodeType: typeof encodeType;
-declare const index_encodeValue: typeof encodeValue;
-declare const index_getDependencies: typeof getDependencies;
-declare const index_getMessageHash: typeof getMessageHash;
-declare const index_getStructHash: typeof getStructHash;
-declare const index_getTypeHash: typeof getTypeHash;
-declare const index_isMerkleTreeType: typeof isMerkleTreeType;
-declare const index_prepareSelector: typeof prepareSelector;
-declare namespace index {
-  export {
-    index_StarkNetDomain as StarkNetDomain,
-    index_StarkNetMerkleType as StarkNetMerkleType,
-    index_StarkNetType as StarkNetType,
-    index_TypedData as TypedData,
-    index_encodeData as encodeData,
-    index_encodeType as encodeType,
-    index_encodeValue as encodeValue,
-    index_getDependencies as getDependencies,
-    index_getMessageHash as getMessageHash,
-    index_getStructHash as getStructHash,
-    index_getTypeHash as getTypeHash,
-    index_isMerkleTreeType as isMerkleTreeType,
-    index_prepareSelector as prepareSelector,
-  };
+declare class RpcProvider implements ProviderInterface {
+    nodeUrl: string;
+    headers: object;
+    private responseParser;
+    private retries;
+    private blockIdentifier;
+    private chainId?;
+    constructor(optionsOrProvider: RpcProviderOptions);
+    fetch(method: any, params: any): Promise<any>;
+    protected errorHandler(error: any): void;
+    protected fetchEndpoint<T extends keyof RPC.Methods>(method: T, params?: RPC.Methods[T]['params']): Promise<RPC.Methods[T]['result']>;
+    getChainId(): Promise<StarknetChainId>;
+    getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
+    getBlockHashAndNumber(): Promise<RPC.BlockHashAndNumber>;
+    getBlockWithTxHashes(blockIdentifier?: BlockIdentifier): Promise<RPC.GetBlockWithTxHashesResponse>;
+    getBlockWithTxs(blockIdentifier?: BlockIdentifier): Promise<RPC.GetBlockWithTxs>;
+    getClassHashAt(contractAddress: RPC.ContractAddress, blockIdentifier?: BlockIdentifier): Promise<RPC.Felt>;
+    getNonceForAddress(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<RPC.Nonce>;
+    getPendingTransactions(): Promise<RPC.PendingTransactions>;
+    getProtocolVersion(): Promise<Error>;
+    getStateUpdate(blockIdentifier?: BlockIdentifier): Promise<RPC.StateUpdate>;
+    getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<RPC.Storage>;
+    getTransaction(txHash: string): Promise<GetTransactionResponse>;
+    getTransactionByHash(txHash: string): Promise<RPC.GetTransactionByHashResponse>;
+    getTransactionByBlockIdAndIndex(blockIdentifier: BlockIdentifier, index: number): Promise<RPC.GetTransactionByBlockIdAndIndex>;
+    getTransactionReceipt(txHash: string): Promise<RPC.TransactionReceipt>;
+    getClassByHash(classHash: RPC.Felt): Promise<RPC.ContractClass>;
+    getClass(classHash: RPC.Felt, blockIdentifier?: BlockIdentifier): Promise<RPC.ContractClass>;
+    getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<RPC.ContractClass>;
+    getCode(_contractAddress: string, _blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;
+    getEstimateFee(invocation: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
+    getInvokeEstimateFee(invocation: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
+    getDeclareEstimateFee({ senderAddress, contractDefinition, signature }: DeclareContractTransaction, details: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
+    getDeployAccountEstimateFee({ classHash, constructorCalldata, addressSalt, signature }: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
+    getEstimateFeeBulk(_invocations: InvocationBulk, _blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponseBulk>;
+    declareContract({ contractDefinition, signature, senderAddress }: DeclareContractTransaction, details: InvocationsDetailsWithNonce): Promise<DeclareContractResponse>;
+    deployAccountContract({ classHash, constructorCalldata, addressSalt, signature }: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce): Promise<DeployContractResponse>;
+    invokeFunction(functionInvocation: Invocation, details: InvocationsDetailsWithNonce): Promise<InvokeFunctionResponse>;
+    callContract(call: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;
+    traceTransaction(transactionHash: RPC.TransactionHash): Promise<RPC.Trace>;
+    traceBlockTransactions(blockHash: RPC.BlockHash): Promise<RPC.Traces>;
+    waitForTransaction(txHash: string, options?: waitForTransactionOptions): Promise<any>;
+    /**
+     * Gets the transaction count from a block.
+     *
+     *
+     * @param blockIdentifier
+     * @returns Number of transactions
+     */
+    getTransactionCount(blockIdentifier?: BlockIdentifier): Promise<RPC.GetTransactionCountResponse>;
+    /**
+     * Gets the latest block number
+     *
+     *
+     * @returns Number of the latest block
+     */
+    getBlockNumber(): Promise<RPC.GetBlockNumberResponse>;
+    /**
+     * Gets syncing status of the node
+     *
+     *
+     * @returns Object with the stats data
+     */
+    getSyncingStats(): Promise<RPC.GetSyncingStatsResponse>;
+    /**
+     * Gets all the events filtered
+     *
+     *
+     * @returns events and the pagination of the events
+     */
+    getEvents(eventFilter: RPC.EventFilter): Promise<RPC.GetEventsResponse>;
+    getSimulateTransaction(_invocation: Invocation, _invocationDetails: InvocationsDetailsWithNonce, _blockIdentifier?: BlockIdentifier): Promise<TransactionSimulationResponse>;
+    getStarkName(address: BigNumberish, StarknetIdContract?: string): Promise<string>;
+    getAddressFromStarkName(name: string, StarknetIdContract?: string): Promise<string>;
 }
 
+declare const defaultProvider: Provider;
+
 declare abstract class SignerInterface {
     /**
      * Method to get the public key of the signer
@@ -2774,7 +2851,7 @@ declare const splitArgsAndOptions: (args: ArgsOrCalldataWithOptions) => {
     args: ArgsOrCalldata;
     options?: undefined;
 };
-declare function getCalldata(args: ArgsOrCalldata, callback: Function): Calldata;
+declare function getCalldata(args: RawArgs, callback: Function): Calldata;
 /**
  * Not used at the moment
  */
@@ -2814,7 +2891,7 @@ declare class Contract implements ContractInterface {
     call(method: string, args?: ArgsOrCalldata, { parseRequest, parseResponse, formatResponse, blockIdentifier, }?: CallOptions): Promise<Result>;
     invoke(method: string, args?: ArgsOrCalldata, { parseRequest, maxFee, nonce, signature }?: InvokeOptions): Promise<InvokeFunctionResponse>;
     estimate(method: string, args?: ArgsOrCalldata): Promise<EstimateFeeResponse>;
-    populate(method: string, args?: ArgsOrCalldata): Call;
+    populate(method: string, args?: RawArgs): Call;
 }
 
 declare class ContractFactory {
@@ -2948,7 +3025,7 @@ declare namespace hash {
 declare const parse: (x: string) => any;
 declare const parseAlwaysAsBig: (x: string) => any;
 declare const stringify: (value: JavaScriptValue, replacer?: any, space?: string | number | undefined, numberStringifiers?: NumberStringifier[] | undefined) => string;
-/** @deprecated */
+/** @deprecated equivalent to 'stringify', alias will be removed */
 declare const stringifyAlwaysAsBig: (value: JavaScriptValue, replacer?: any, space?: string | number | undefined, numberStringifiers?: NumberStringifier[] | undefined) => string;
 
 declare const json_parse: typeof parse;
@@ -2964,6 +3041,71 @@ declare namespace json {
   };
 }
 
+declare function isHex(hex: string): boolean;
+declare function toBigInt(value: BigNumberish): bigint;
+declare function isBigInt(value: any): value is bigint;
+declare function toHex(number: BigNumberish): string;
+declare function hexToDecimalString(hex: string): string;
+/**
+ * Remove hex string leading zero and lower case '0x01A'.. -> '0x1a..'
+ * @param hex string
+ */
+declare const cleanHex: (hex: string) => string;
+declare function assertInRange(input: BigNumberish, lowerBound: BigNumberish, upperBound: BigNumberish, inputName?: string): void;
+declare function bigNumberishArrayToDecimalStringArray(rawCalldata: BigNumberish[]): string[];
+declare function bigNumberishArrayToHexadecimalStringArray(rawCalldata: BigNumberish[]): string[];
+declare const isStringWholeNumber: (value: string) => boolean;
+declare const toHexString: (value: string) => string;
+declare function getDecimalString(value: string): string;
+declare function getHexString(value: string): string;
+declare function getHexStringArray(value: Array<string>): string[];
+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
+ */
+declare function hexToBytes(value: string): Uint8Array;
+
+type num_BigNumberish = BigNumberish;
+declare const num_assertInRange: typeof assertInRange;
+declare const num_bigNumberishArrayToDecimalStringArray: typeof bigNumberishArrayToDecimalStringArray;
+declare const num_bigNumberishArrayToHexadecimalStringArray: typeof bigNumberishArrayToHexadecimalStringArray;
+declare const num_cleanHex: typeof cleanHex;
+declare const num_getDecimalString: typeof getDecimalString;
+declare const num_getHexString: typeof getHexString;
+declare const num_getHexStringArray: typeof getHexStringArray;
+declare const num_hexToBytes: typeof hexToBytes;
+declare const num_hexToDecimalString: typeof hexToDecimalString;
+declare const num_isBigInt: typeof isBigInt;
+declare const num_isHex: typeof isHex;
+declare const num_isStringWholeNumber: typeof isStringWholeNumber;
+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 namespace num {
+  export {
+    num_BigNumberish as BigNumberish,
+    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_isHex as isHex,
+    num_isStringWholeNumber as isStringWholeNumber,
+    num_toBigInt as toBigInt,
+    num_toCairoBool as toCairoBool,
+    num_toHex as toHex,
+    num_toHexString as toHexString,
+  };
+}
+
 /**
  * Transforms a list of Calls, each with their own calldata, into
  * two arrays: one with the entrypoints, and one with the concatenated calldata.
@@ -3075,6 +3217,29 @@ declare namespace merkle {
   };
 }
 
+declare function uint256ToBN(uint256: Uint256): bigint;
+declare const UINT_128_MAX: bigint;
+declare const UINT_256_MAX: bigint;
+declare function isUint256(bn: BigNumberish): boolean;
+declare function bnToUint256(bignumber: BigNumberish): Uint256;
+
+declare const uint256$1_UINT_128_MAX: typeof UINT_128_MAX;
+declare const uint256$1_UINT_256_MAX: typeof UINT_256_MAX;
+type uint256$1_Uint256 = Uint256;
+declare const uint256$1_bnToUint256: typeof bnToUint256;
+declare const uint256$1_isUint256: typeof isUint256;
+declare const uint256$1_uint256ToBN: typeof uint256ToBN;
+declare namespace uint256$1 {
+  export {
+    uint256$1_UINT_128_MAX as UINT_128_MAX,
+    uint256$1_UINT_256_MAX as UINT_256_MAX,
+    uint256$1_Uint256 as Uint256,
+    uint256$1_bnToUint256 as bnToUint256,
+    uint256$1_isUint256 as isUint256,
+    uint256$1_uint256ToBN as uint256ToBN,
+  };
+}
+
 declare function isASCII(str: string): boolean;
 declare function isShortString(str: string): boolean;
 declare function isDecimalString(decim: string): boolean;
@@ -3136,6 +3301,107 @@ declare namespace shortString {
   };
 }
 
+declare function prepareSelector(selector: string): string;
+declare function isMerkleTreeType(type: StarkNetType): type is StarkNetMerkleType;
+interface Context {
+    parent?: string;
+    key?: string;
+}
+/**
+ * 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} typedData
+ * @param {string} type
+ * @param {string[]} [dependencies]
+ * @return {string[]}
+ */
+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;
+
+type typedData_StarkNetDomain = StarkNetDomain;
+type typedData_StarkNetMerkleType = StarkNetMerkleType;
+type typedData_StarkNetType = StarkNetType;
+type typedData_TypedData = TypedData;
+declare const typedData_encodeData: typeof encodeData;
+declare const typedData_encodeType: typeof encodeType;
+declare const typedData_encodeValue: typeof encodeValue;
+declare const typedData_getDependencies: typeof getDependencies;
+declare const typedData_getMessageHash: typeof getMessageHash;
+declare const typedData_getStructHash: typeof getStructHash;
+declare const typedData_getTypeHash: typeof getTypeHash;
+declare const typedData_isMerkleTreeType: typeof isMerkleTreeType;
+declare const typedData_prepareSelector: typeof prepareSelector;
+declare namespace typedData {
+  export {
+    typedData_StarkNetDomain as StarkNetDomain,
+    typedData_StarkNetMerkleType as StarkNetMerkleType,
+    typedData_StarkNetType as StarkNetType,
+    typedData_TypedData as TypedData,
+    typedData_encodeData as encodeData,
+    typedData_encodeType as encodeType,
+    typedData_encodeValue as encodeValue,
+    typedData_getDependencies as getDependencies,
+    typedData_getMessageHash as getMessageHash,
+    typedData_getStructHash as getStructHash,
+    typedData_getTypeHash as getTypeHash,
+    typedData_isMerkleTreeType as isMerkleTreeType,
+    typedData_prepareSelector as prepareSelector,
+  };
+}
+
 declare function useDecoded(encoded: bigint[]): string;
 declare function useEncoded(decoded: string): bigint;
 declare const enum StarknetIdContract {
@@ -3327,4 +3593,4 @@ declare class CallData {
 /** @deprecated prefer the 'num' naming */
 declare const number: typeof num;
 
-export { Abi, AbiEntry, AbiStructs, Account, AccountInterface, AllowArray, Args, ArgsOrCalldata, ArgsOrCalldataWithOptions, ArraySignatureType, AsyncContractFunction, BlockNumber, BlockTag, Builtins, ByteCode, CairoAssembly, CairoContract, CairoVersion, Call, CallContractResponse, CallData, CallDetails, CallL1Handler, CallOptions, CallStruct, Calldata, CommonTransactionReceiptResponse, CommonTransactionResponse, CompiledContract, CompiledSierra, CompiledSierraCasm, CompleteDeclareContractPayload, CompressedProgram, Contract, ContractClass, ContractEntryPoint, ContractEntryPointFields, ContractFactory, ContractFunction, ContractInterface, ContractOptions, CustomError, DeclareAndDeployContractPayload, DeclareContractPayload, DeclareContractResponse, DeclareContractTransaction, DeclareDeployUDCResponse, DeclareSignerDetails, DeclareTransactionReceiptResponse, DeclareTransactionResponse, DeployAccountContractPayload, DeployAccountContractTransaction, DeployAccountSignerDetails, DeployContractPayload, DeployContractResponse, DeployContractUDCResponse, DeployedContractItem, Details, EntryPointType, EntryPointsByType, EstimateFee, EstimateFeeAction, EstimateFeeBulk, EstimateFeeDetails, EstimateFeeResponse, EstimateFeeResponseBulk, Event, ExecutionResources, FunctionAbi, FunctionInvocation, GatewayError, GetBlockResponse, GetCodeResponse, GetContractAddressesResponse, GetTransactionReceiptResponse, GetTransactionResponse, GetTransactionStatusResponse, HexCalldata, HttpError, Invocation, InvocationBulk, InvocationsDetails, InvocationsDetailsWithNonce, InvocationsSignerDetails, InvokeFunctionResponse, InvokeOptions, InvokeTransactionReceiptResponse, InvokeTransactionResponse, LegacyCompiledContract, LegacyContractClass, LibraryError, MessageToL1, MessageToL2, MultiDeployContractResponse, MultiType, Nonce, ParsedStruct, Program, Provider, ProviderInterface, ProviderOptions, PythonicHints, RPC, RawArgs, RawArgsArray, RawArgsObject, RawCalldata, Result, RpcProvider, RpcProviderOptions, Sequencer, SequencerHttpMethod, SequencerIdentifier, SequencerProvider, SequencerProviderOptions, SierraContractClass, SierraContractEntryPointFields, SierraEntryPointsByType, SierraProgramDebugInfo, Signature, Signer, SignerInterface, StateUpdateResponse, Status, Storage, Struct, StructAbi, TransactionBulk, TransactionSimulation, TransactionSimulationResponse, TransactionStatus, TransactionTraceResponse, TransactionType, Tupled, UniversalDeployerContractPayload, WeierstrassSignatureType, addAddressPadding, buildUrl, cairo, constants, defaultProvider, ec, encode, fixProto, fixStack, getCalldata, getChecksumAddress, hash, isUrl, json, merkle, num, number, shortString, splitArgsAndOptions, stark, starknetId, transaction, index as typedData, uint256$1 as uint256, validateAndParseAddress, validateChecksumAddress, waitForTransactionOptions };
+export { Abi, AbiEntry, AbiStructs, Account, AccountInterface, AllowArray, Args, ArgsOrCalldata, ArgsOrCalldataWithOptions, ArraySignatureType, AsyncContractFunction, BigNumberish, BlockIdentifier, BlockNumber, BlockTag, Builtins, ByteCode, CairoAssembly, CairoContract, CairoVersion, Call, CallContractResponse, CallData, CallDetails, CallL1Handler, CallOptions, CallStruct, Calldata, CommonTransactionReceiptResponse, CommonTransactionResponse, CompiledContract, CompiledSierra, CompiledSierraCasm, CompleteDeclareContractPayload, CompressedProgram, Contract, ContractClass, ContractEntryPoint, ContractEntryPointFields, ContractFactory, ContractFunction, ContractInterface, ContractOptions, CustomError, DeclareAndDeployContractPayload, DeclareContractPayload, DeclareContractResponse, DeclareContractTransaction, DeclareDeployUDCResponse, DeclareSignerDetails, DeclareTransactionReceiptResponse, DeclareTransactionResponse, DeployAccountContractPayload, DeployAccountContractTransaction, DeployAccountSignerDetails, DeployContractPayload, DeployContractResponse, DeployContractUDCResponse, DeployedContractItem, Details, EntryPointType, EntryPointsByType, EstimateFee, EstimateFeeAction, EstimateFeeBulk, EstimateFeeDetails, EstimateFeeResponse, EstimateFeeResponseBulk, Event, ExecutionResources, FunctionAbi, FunctionInvocation, GatewayError, GetBlockResponse, GetCodeResponse, GetContractAddressesResponse, GetTransactionReceiptResponse, GetTransactionResponse, GetTransactionStatusResponse, HexCalldata, HttpError, Invocation, InvocationBulk, InvocationsDetails, InvocationsDetailsWithNonce, InvocationsSignerDetails, InvokeFunctionResponse, InvokeOptions, InvokeTransactionReceiptResponse, InvokeTransactionResponse, LegacyCompiledContract, LegacyContractClass, LibraryError, MessageToL1, MessageToL2, MultiDeployContractResponse, MultiType, Nonce, ParsedStruct, Program, Provider, ProviderInterface, ProviderOptions, PythonicHints, RPC, RawArgs, RawArgsArray, RawArgsObject, RawCalldata, Result, RpcProvider, RpcProviderOptions, Sequencer, SequencerHttpMethod, SequencerIdentifier, SequencerProvider, SequencerProviderOptions, SierraContractClass, SierraContractEntryPointFields, SierraEntryPointsByType, SierraProgramDebugInfo, Signature, Signer, SignerInterface, StarkNetDomain, StarkNetMerkleType, StarkNetType, StateUpdateResponse, Status, Storage, Struct, StructAbi, TransactionBulk, TransactionSimulation, TransactionSimulationResponse, TransactionStatus, TransactionTraceResponse, TransactionType, Tupled, TypedData, Uint256, UniversalDeployerContractPayload, WeierstrassSignatureType, addAddressPadding, buildUrl, cairo, constants, defaultProvider, ec, encode, fixProto, fixStack, getCalldata, getChecksumAddress, hash, isUrl, json, merkle, num, number, shortString, splitArgsAndOptions, stark, starknetId, transaction, typedData, index as types, uint256$1 as uint256, validateAndParseAddress, validateChecksumAddress, waitForTransactionOptions };