starknet 6.9.0 → 6.10.1

package/dist/provider/interface.d.ts

@@ -0,0 +1,261 @@
+import { RPC06, RPC07 } from '../channel';
+import { StarknetChainId } from '../constants';
+import type { AccountInvocations, BigNumberish, Block, BlockIdentifier, Call, CallContractResponse, ContractClassResponse, ContractVersion, DeclareContractResponse, DeclareContractTransaction, DeployAccountContractPayload, DeployAccountContractTransaction, DeployContractResponse, EstimateFeeResponse, EstimateFeeResponseBulk, GetBlockResponse, GetTransactionResponse, Invocation, InvocationsDetailsWithNonce, InvokeFunctionResponse, Nonce, PendingBlock, SimulateTransactionResponse, StateUpdateResponse, Storage, getContractVersionOptions, getEstimateFeeBulkOptions, getSimulateTransactionOptions, waitForTransactionOptions } from '../types';
+import type { GetTransactionReceiptResponse } from '../utils/transactionReceipt';
+export declare abstract class ProviderInterface {
+    abstract channel: RPC07.RpcChannel | RPC06.RpcChannel;
+    /**
+     * 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?: 'pending'): Promise<PendingBlock>;
+    abstract getBlock(blockIdentifier: 'latest'): Promise<Block>;
+    abstract getBlock(blockIdentifier: BlockIdentifier): Promise<GetBlockResponse>;
+    /**
+     * 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<ContractClassResponse>;
+    /**
+     * Gets the price of l1 gas in the block
+     *
+     * @param blockIdentifier block identifier
+     * @returns gas price of the block
+     */
+    abstract getL1GasPrice(blockIdentifier: BlockIdentifier): Promise<string>;
+    /**
+     * Get L1 message hash from L2 transaction hash
+     * @param {BigNumberish} l2TxHash L2 transaction hash
+     * @returns {string} Hex string of L1 message hash
+     * @example
+     * In Sepolia Testnet :
+     * ```typescript
+     * const result = provider.getL1MessageHash('0x28dfc05eb4f261b37ddad451ff22f1d08d4e3c24dc646af0ec69fa20e096819');
+     * // result = '0x55b3f8b6e607fffd9b4d843dfe8f9b5c05822cd94fcad8797deb01d77805532a'
+     * ```
+     */
+    abstract getL1MessageHash(l2TxHash: BigNumberish): Promise<string>;
+    /**
+     * Returns the contract class hash in the given block for the contract deployed at 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<ContractClassResponse>;
+    /**
+     * Returns the nonce associated with the given address in the given block
+     *
+     * @param contractAddress - contract address
+     * @returns the hex nonce
+     */
+    abstract getNonceForAddress(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<Nonce>;
+    /**
+     * Get the value of the storage (contract's variable) at the given address and 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 transactionHash
+     * @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 transactionHash
+     * @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 won't be supported as soon as fees are mandatory. Should not be used outside of Account class
+     *
+     * @param invocation the invocation object containing:
+     * - contractAddress - the address of the contract
+     * - entrypoint - the entrypoint of the contract
+     * - calldata - (defaults to []) the calldata
+     * - signature - (defaults to []) the signature
+     * @param details - optional details containing:
+     * - nonce - optional nonce
+     * - version - optional version
+     * - maxFee - optional maxFee
+     * @returns response from addTransaction
+     */
+    abstract invokeFunction(invocation: Invocation, details: InvocationsDetailsWithNonce): Promise<InvokeFunctionResponse>;
+    /**
+     * Declares a given compiled contract (json) to starknet
+     * @param transaction transaction payload to be deployed containing:
+     * - compiled contract code
+     * - sender address
+     * - signature
+     * @param details Invocation Details containing:
+     * - nonce
+     * - optional version
+     * - optional maxFee
+     * @returns a confirmation of sending a transaction on the starknet contract
+     */
+    abstract declareContract(transaction: DeclareContractTransaction, details: InvocationsDetailsWithNonce): Promise<DeclareContractResponse>;
+    /**
+     * Estimates the fee for a given INVOKE transaction
+     * @deprecated Please use getInvokeEstimateFee or getDeclareEstimateFee instead. Should not be used outside of Account class
+     *
+     * @param invocation the invocation object containing:
+     * - contractAddress - the address of the contract
+     * - entrypoint - the entrypoint of the contract
+     * - calldata - (defaults to []) the calldata
+     * - signature - (defaults to []) the signature
+     * @param details - optional details containing:
+     * - nonce - optional nonce
+     * - version - optional version
+     * @param blockIdentifier - (optional) block identifier
+     * @param skipValidate - (optional) skip cairo __validate__ method
+     * @returns the estimated fee
+     */
+    abstract getEstimateFee(invocation: Invocation, details: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier, skipValidate?: boolean): Promise<EstimateFeeResponse>;
+    /**
+     * Estimates the fee for a given INVOKE transaction
+     *
+     * @param invocation the invocation object containing:
+     * - contractAddress - the address of the contract
+     * - entrypoint - the entrypoint of the contract
+     * - calldata - (defaults to []) the calldata
+     * - signature - (defaults to []) the signature
+     * @param details - optional details containing:
+     * - nonce - optional nonce
+     * - version - optional version
+     * @param blockIdentifier - (optional) block identifier
+     * @param skipValidate - (optional) skip cairo __validate__ method
+     * @returns the estimated fee
+     */
+    abstract getInvokeEstimateFee(invocation: Invocation, details: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier, skipValidate?: boolean): Promise<EstimateFeeResponse>;
+    /**
+     * Estimates the fee for a given DECLARE transaction
+     *
+     * @param transaction transaction payload to be declared containing:
+     * - compiled contract code
+     * - sender address
+     * - signature - (defaults to []) the signature
+     * @param details - optional details containing:
+     * - nonce
+     * - version - optional version
+     * - optional maxFee
+     * @param blockIdentifier - (optional) block identifier
+     * @param skipValidate - (optional) skip cairo __validate__ method
+     * @returns the estimated fee
+     */
+    abstract getDeclareEstimateFee(transaction: DeclareContractTransaction, details: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier, skipValidate?: boolean): Promise<EstimateFeeResponse>;
+    /**
+     * Estimates the fee for a given DEPLOY_ACCOUNT transaction
+     *
+     * @param transaction transaction payload to be deployed containing:
+     * - classHash
+     * - constructorCalldata
+     * - addressSalt
+     * - signature - (defaults to []) the signature
+     * @param details - optional details containing:
+     * - nonce
+     * - version - optional version
+     * - optional maxFee
+     * @param blockIdentifier - (optional) block identifier
+     * @param skipValidate - (optional) skip cairo __validate__ method
+     * @returns the estimated fee
+     */
+    abstract getDeployAccountEstimateFee(transaction: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier, skipValidate?: boolean): Promise<EstimateFeeResponse>;
+    /**
+     * Estimates the fee for a list of INVOKE transaction
+     *
+     * @param invocations AccountInvocations - Complete invocations array with account details
+     * @param options getEstimateFeeBulkOptions
+     * - (optional) blockIdentifier - BlockIdentifier
+     * @returns the estimated fee
+     */
+    abstract getEstimateFeeBulk(invocations: AccountInvocations, options?: getEstimateFeeBulkOptions): Promise<EstimateFeeResponseBulk>;
+    /**
+     * Wait for the transaction to be accepted
+     * @param txHash - transaction hash
+     * @param options waitForTransactionOptions
+     * - (optional) retryInterval: number | undefined;
+     * - (optional) successStates: TransactionStatus[] | undefined;
+     * @return GetTransactionReceiptResponse
+     */
+    abstract waitForTransaction(txHash: BigNumberish, options?: waitForTransactionOptions): Promise<GetTransactionReceiptResponse>;
+    /**
+     * Simulates the transaction and returns the transaction trace and estimated fee.
+     *
+     * @param invocations AccountInvocations - Complete invocations array with account details
+     * @param options - getSimulateTransactionOptions
+     *  - (optional) blockIdentifier - block identifier
+     *  - (optional) skipValidate - skip cairo __validate__ method
+     *  - (optional) skipExecute - skip cairo __execute__ method
+     * @returns an array of transaction trace and estimated fee
+     */
+    abstract getSimulateTransaction(invocations: AccountInvocations, options?: getSimulateTransactionOptions): Promise<SimulateTransactionResponse>;
+    /**
+     * Gets the state changes in a specific block (result of executing the requested block)
+     *
+     * @param blockIdentifier - block identifier
+     * @returns StateUpdateResponse
+     */
+    abstract getStateUpdate(blockIdentifier?: BlockIdentifier): Promise<StateUpdateResponse>;
+    /**
+     * Gets the contract version from the provided address
+     * @param contractAddress string
+     * @param classHash undefined
+     * @param options - getContractVersionOptions
+     *   - (optional) compiler - (default true) extract compiler version using type tactic from abi
+     *   - (optional) blockIdentifier - block identifier
+     */
+    abstract getContractVersion(contractAddress: string, classHash?: undefined, options?: getContractVersionOptions): Promise<ContractVersion>;
+    /**
+     * Gets the contract version from the provided address
+     * @param contractAddress undefined
+     * @param classHash
+     * @param options - getContractVersionOptions
+     *   - (optional) compiler - (default true) extract compiler version using type tactic from abi
+     *   - (optional) blockIdentifier - block identifier
+     */
+    abstract getContractVersion(contractAddress: undefined, classHash: string, options?: getContractVersionOptions): Promise<ContractVersion>;
+}

package/dist/provider/interface.mjs

@@ -0,0 +1,2 @@
+export class ProviderInterface {
+}

package/dist/provider/rpc.cjs

@@ -0,0 +1,301 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RpcProvider = void 0;
+var _utils = require("@noble/curves/abstract/utils");
+var _sha = require("@noble/hashes/sha3");
+var _channel = require("../channel/index.cjs");
+var _types = require("../types/index.cjs");
+var _assert = _interopRequireDefault(require("../utils/assert.cjs"));
+var _cairo = require("../utils/calldata/cairo.cjs");
+var _contract = require("../utils/contract.cjs");
+var _encode = require("../utils/encode.cjs");
+var _num = require("../utils/num.cjs");
+var _provider = require("../utils/provider.cjs");
+var _rpc = require("../utils/responseParser/rpc.cjs");
+var _transactionReceipt = require("../utils/transactionReceipt.cjs");
+var _errors = require("./errors.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class RpcProvider {
+  responseParser;
+  channel;
+  constructor(optionsOrProvider) {
+    if (optionsOrProvider && "channel" in optionsOrProvider) {
+      this.channel = optionsOrProvider.channel;
+      this.responseParser = "responseParser" in optionsOrProvider ? optionsOrProvider.responseParser : new _rpc.RPCResponseParser();
+    } else {
+      this.channel = new _channel.RpcChannel({
+        ...optionsOrProvider,
+        waitMode: false
+      });
+      this.responseParser = new _rpc.RPCResponseParser(optionsOrProvider?.feeMarginPercentage);
+    }
+  }
+  fetch(method, params, id = 0) {
+    return this.channel.fetch(method, params, id);
+  }
+  async getChainId() {
+    return this.channel.getChainId();
+  }
+  async getSpecVersion() {
+    return this.channel.getSpecVersion();
+  }
+  async getNonceForAddress(contractAddress, blockIdentifier) {
+    return this.channel.getNonceForAddress(contractAddress, blockIdentifier);
+  }
+  async getBlock(blockIdentifier) {
+    return this.channel.getBlockWithTxHashes(blockIdentifier).then(this.responseParser.parseGetBlockResponse);
+  }
+  /**
+   * Get the most recent accepted block hash and number
+   */
+  async getBlockLatestAccepted() {
+    return this.channel.getBlockLatestAccepted();
+  }
+  /**
+   * Get the most recent accepted block number
+   * redundant use getBlockLatestAccepted();
+   * @returns Number of the latest block
+   */
+  async getBlockNumber() {
+    return this.channel.getBlockNumber();
+  }
+  async getBlockWithTxHashes(blockIdentifier) {
+    return this.channel.getBlockWithTxHashes(blockIdentifier);
+  }
+  async getBlockWithTxs(blockIdentifier) {
+    return this.channel.getBlockWithTxs(blockIdentifier);
+  }
+  /**
+   * Pause the execution of the script until a specified block is created.
+   * @param {BlockIdentifier} blockIdentifier bloc number (BigNumberisk) 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
+   * ```typescript
+   * await myProvider.waitForBlock();
+   * // wait the creation of the pending block
+   * ```
+   */
+  async waitForBlock(blockIdentifier = "pending", retryInterval = 5e3) {
+    if (blockIdentifier === _types.BlockTag.LATEST) return;
+    const currentBlock = await this.getBlockNumber();
+    const targetBlock = blockIdentifier === _types.BlockTag.PENDING ? currentBlock + 1 : Number((0, _num.toHex)(blockIdentifier));
+    if (targetBlock <= currentBlock) return;
+    const {
+      retries
+    } = this.channel;
+    let retriesCount = retries;
+    let isTargetBlock = false;
+    while (!isTargetBlock) {
+      const currBlock = await this.getBlockNumber();
+      if (currBlock === targetBlock) {
+        isTargetBlock = true;
+      } else {
+        await (0, _provider.wait)(retryInterval);
+      }
+      retriesCount -= 1;
+      if (retriesCount <= 0) {
+        throw new Error(`waitForBlock() timed-out after ${retries} tries.`);
+      }
+    }
+  }
+  async getL1GasPrice(blockIdentifier) {
+    return this.channel.getBlockWithTxHashes(blockIdentifier).then(this.responseParser.parseL1GasPriceResponse);
+  }
+  async getL1MessageHash(l2TxHash) {
+    const transaction = await this.channel.getTransactionByHash(l2TxHash);
+    (0, _assert.default)(transaction.type === "L1_HANDLER", "This L2 transaction is not a L1 message.");
+    const {
+      calldata,
+      contract_address,
+      entry_point_selector,
+      nonce
+    } = transaction;
+    const params = [calldata[0], contract_address, nonce, entry_point_selector, calldata.length - 1, ...calldata.slice(1)];
+    const myEncode = (0, _encode.addHexPrefix)(params.reduce((res, par) => res + (0, _encode.removeHexPrefix)((0, _num.toHex)(par)).padStart(64, "0"), ""));
+    return (0, _encode.addHexPrefix)((0, _utils.bytesToHex)((0, _sha.keccak_256)((0, _num.hexToBytes)(myEncode))));
+  }
+  async getBlockWithReceipts(blockIdentifier) {
+    if (this.channel instanceof _channel.RPC06.RpcChannel) throw new _errors.LibraryError("Unsupported method for RPC version");
+    return this.channel.getBlockWithReceipts(blockIdentifier);
+  }
+  getStateUpdate = this.getBlockStateUpdate;
+  async getBlockStateUpdate(blockIdentifier) {
+    return this.channel.getBlockStateUpdate(blockIdentifier);
+  }
+  async getBlockTransactionsTraces(blockIdentifier) {
+    return this.channel.getBlockTransactionsTraces(blockIdentifier);
+  }
+  async getBlockTransactionCount(blockIdentifier) {
+    return this.channel.getBlockTransactionCount(blockIdentifier);
+  }
+  /**
+   * Return transactions from pending block
+   * @deprecated Instead use getBlock(BlockTag.PENDING); (will be removed in next minor version)
+   * Utility method, same result can be achieved using getBlockWithTxHashes(BlockTag.pending);
+   */
+  async getPendingTransactions() {
+    const {
+      transactions
+    } = await this.getBlockWithTxHashes(_types.BlockTag.PENDING).then(this.responseParser.parseGetBlockResponse);
+    return Promise.all(transactions.map(it => this.getTransactionByHash(it)));
+  }
+  async getTransaction(txHash) {
+    return this.channel.getTransactionByHash(txHash);
+  }
+  async getTransactionByHash(txHash) {
+    return this.channel.getTransactionByHash(txHash);
+  }
+  async getTransactionByBlockIdAndIndex(blockIdentifier, index) {
+    return this.channel.getTransactionByBlockIdAndIndex(blockIdentifier, index);
+  }
+  async getTransactionReceipt(txHash) {
+    const txReceiptWoHelper = await this.channel.getTransactionReceipt(txHash);
+    const txReceiptWoHelperModified = this.responseParser.parseTransactionReceipt(txReceiptWoHelper);
+    return new _transactionReceipt.ReceiptTx(txReceiptWoHelperModified);
+  }
+  async getTransactionTrace(txHash) {
+    return this.channel.getTransactionTrace(txHash);
+  }
+  /**
+   * Get the status of a transaction
+   */
+  async getTransactionStatus(transactionHash) {
+    return this.channel.getTransactionStatus(transactionHash);
+  }
+  /**
+   * @param invocations AccountInvocations
+   * @param options blockIdentifier and flags to skip validation and fee charge<br/>
+   * - blockIdentifier<br/>
+   * - skipValidate (default false)<br/>
+   * - skipFeeCharge (default true)<br/>
+   */
+  async getSimulateTransaction(invocations, options) {
+    return this.channel.simulateTransaction(invocations, options).then(r => this.responseParser.parseSimulateTransactionResponse(r));
+  }
+  async waitForTransaction(txHash, options) {
+    const receiptWoHelper = await this.channel.waitForTransaction(txHash, options);
+    return new _transactionReceipt.ReceiptTx(receiptWoHelper);
+  }
+  async getStorageAt(contractAddress, key, blockIdentifier) {
+    return this.channel.getStorageAt(contractAddress, key, blockIdentifier);
+  }
+  async getClassHashAt(contractAddress, blockIdentifier) {
+    return this.channel.getClassHashAt(contractAddress, blockIdentifier);
+  }
+  async getClassByHash(classHash) {
+    return this.getClass(classHash);
+  }
+  async getClass(classHash, blockIdentifier) {
+    return this.channel.getClass(classHash, blockIdentifier).then(this.responseParser.parseContractClassResponse);
+  }
+  async getClassAt(contractAddress, blockIdentifier) {
+    return this.channel.getClassAt(contractAddress, blockIdentifier).then(this.responseParser.parseContractClassResponse);
+  }
+  async getContractVersion(contractAddress, classHash, {
+    blockIdentifier = this.channel.blockIdentifier,
+    compiler = true
+  } = {}) {
+    let contractClass;
+    if (contractAddress) {
+      contractClass = await this.getClassAt(contractAddress, blockIdentifier);
+    } else if (classHash) {
+      contractClass = await this.getClass(classHash, blockIdentifier);
+    } else {
+      throw Error("getContractVersion require contractAddress or classHash");
+    }
+    if ((0, _contract.isSierra)(contractClass)) {
+      if (compiler) {
+        const abiTest = (0, _cairo.getAbiContractVersion)(contractClass.abi);
+        return {
+          cairo: "1",
+          compiler: abiTest.compiler
+        };
+      }
+      return {
+        cairo: "1",
+        compiler: void 0
+      };
+    }
+    return {
+      cairo: "0",
+      compiler: "0"
+    };
+  }
+  /**
+   * @deprecated use get*type*EstimateFee (will be refactored based on type after sequencer deprecation)
+   */
+  async getEstimateFee(invocation, invocationDetails, blockIdentifier, skipValidate) {
+    return this.getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier, skipValidate);
+  }
+  async getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier, skipValidate) {
+    return this.channel.getEstimateFee([{
+      type: _types.TransactionType.INVOKE,
+      ...invocation,
+      ...invocationDetails
+    }], {
+      blockIdentifier,
+      skipValidate
+    }).then(r => this.responseParser.parseFeeEstimateResponse(r));
+  }
+  async getDeclareEstimateFee(invocation, details, blockIdentifier, skipValidate) {
+    return this.channel.getEstimateFee([{
+      type: _types.TransactionType.DECLARE,
+      ...invocation,
+      ...details
+    }], {
+      blockIdentifier,
+      skipValidate
+    }).then(r => this.responseParser.parseFeeEstimateResponse(r));
+  }
+  async getDeployAccountEstimateFee(invocation, details, blockIdentifier, skipValidate) {
+    return this.channel.getEstimateFee([{
+      type: _types.TransactionType.DEPLOY_ACCOUNT,
+      ...invocation,
+      ...details
+    }], {
+      blockIdentifier,
+      skipValidate
+    }).then(r => this.responseParser.parseFeeEstimateResponse(r));
+  }
+  async getEstimateFeeBulk(invocations, options) {
+    return this.channel.getEstimateFee(invocations, options).then(r => this.responseParser.parseFeeEstimateBulkResponse(r));
+  }
+  async invokeFunction(functionInvocation, details) {
+    return this.channel.invoke(functionInvocation, details);
+  }
+  async declareContract(transaction, details) {
+    return this.channel.declare(transaction, details);
+  }
+  async deployAccountContract(transaction, details) {
+    return this.channel.deployAccount(transaction, details);
+  }
+  async callContract(call, blockIdentifier) {
+    return this.channel.callContract(call, blockIdentifier);
+  }
+  /**
+   * NEW: Estimate the fee for a message from L1
+   * @param message Message From L1
+   */
+  async estimateMessageFee(message, blockIdentifier) {
+    return this.channel.estimateMessageFee(message, blockIdentifier);
+  }
+  /**
+   * Returns an object about the sync status, or false if the node is not synching
+   * @returns Object with the stats data
+   */
+  async getSyncingStats() {
+    return this.channel.getSyncingStats();
+  }
+  /**
+   * Returns all events matching the given filter
+   * @returns events and the pagination of the events
+   */
+  async getEvents(eventFilter) {
+    return this.channel.getEvents(eventFilter);
+  }
+}
+exports.RpcProvider = RpcProvider;

package/dist/provider/rpc.d.ts

@@ -0,0 +1,115 @@
+import { RPC06, RPC07 } from '../channel';
+import { AccountInvocations, BigNumberish, Block, BlockIdentifier, Call, ContractVersion, DeclareContractTransaction, DeployAccountContractTransaction, GetBlockResponse, Invocation, InvocationsDetailsWithNonce, PendingBlock, PendingStateUpdate, RPC, RpcProviderOptions, StateUpdate, StateUpdateResponse, getContractVersionOptions, getEstimateFeeBulkOptions, getSimulateTransactionOptions, waitForTransactionOptions } from '../types';
+import { RPCResponseParser } from '../utils/responseParser/rpc';
+import { GetTransactionReceiptResponse } from '../utils/transactionReceipt';
+import { ProviderInterface } from './interface';
+export declare class RpcProvider implements ProviderInterface {
+    responseParser: RPCResponseParser;
+    channel: RPC07.RpcChannel | RPC06.RpcChannel;
+    constructor(optionsOrProvider?: RpcProviderOptions | ProviderInterface | RpcProvider);
+    fetch(method: string, params?: object, id?: string | number): any;
+    getChainId(): Promise<"0x534e5f4d41494e" | "0x534e5f5345504f4c4941">;
+    getSpecVersion(): Promise<string>;
+    getNonceForAddress(contractAddress: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<string>;
+    getBlock(): Promise<PendingBlock>;
+    getBlock(blockIdentifier: 'pending'): Promise<PendingBlock>;
+    getBlock(blockIdentifier: 'latest'): Promise<Block>;
+    getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
+    /**
+     * Get the most recent accepted block hash and number
+     */
+    getBlockLatestAccepted(): Promise<RPC.RPCSPEC06.BlockHashAndNumber>;
+    /**
+     * Get the most recent accepted block number
+     * redundant use getBlockLatestAccepted();
+     * @returns Number of the latest block
+     */
+    getBlockNumber(): Promise<number>;
+    getBlockWithTxHashes(blockIdentifier?: BlockIdentifier): Promise<RPC.RPCSPEC06.BlockWithTxHashes>;
+    getBlockWithTxs(blockIdentifier?: BlockIdentifier): Promise<RPC.RPCSPEC06.BlockWithTxs>;
+    /**
+     * Pause the execution of the script until a specified block is created.
+     * @param {BlockIdentifier} blockIdentifier bloc number (BigNumberisk) 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
+     * ```typescript
+     * await myProvider.waitForBlock();
+     * // wait the creation of the pending block
+     * ```
+     */
+    waitForBlock(blockIdentifier?: BlockIdentifier, retryInterval?: number): Promise<void>;
+    getL1GasPrice(blockIdentifier?: BlockIdentifier): Promise<string>;
+    getL1MessageHash(l2TxHash: BigNumberish): Promise<string>;
+    getBlockWithReceipts(blockIdentifier?: BlockIdentifier): Promise<RPC.BlockWithTxReceipts>;
+    getStateUpdate: {
+        (): Promise<PendingStateUpdate>;
+        (blockIdentifier: 'pending'): Promise<PendingStateUpdate>;
+        (blockIdentifier: 'latest'): Promise<StateUpdate>;
+        (blockIdentifier?: BlockIdentifier): Promise<StateUpdateResponse>;
+    };
+    getBlockStateUpdate(): Promise<PendingStateUpdate>;
+    getBlockStateUpdate(blockIdentifier: 'pending'): Promise<PendingStateUpdate>;
+    getBlockStateUpdate(blockIdentifier: 'latest'): Promise<StateUpdate>;
+    getBlockStateUpdate(blockIdentifier?: BlockIdentifier): Promise<StateUpdateResponse>;
+    getBlockTransactionsTraces(blockIdentifier?: BlockIdentifier): Promise<RPC.RPCSPEC06.BlockTransactionsTraces>;
+    getBlockTransactionCount(blockIdentifier?: BlockIdentifier): Promise<number>;
+    /**
+     * Return transactions from pending block
+     * @deprecated Instead use getBlock(BlockTag.PENDING); (will be removed in next minor version)
+     * Utility method, same result can be achieved using getBlockWithTxHashes(BlockTag.pending);
+     */
+    getPendingTransactions(): Promise<RPC.RPCSPEC06.TransactionWithHash[]>;
+    getTransaction(txHash: BigNumberish): Promise<RPC.RPCSPEC06.TransactionWithHash>;
+    getTransactionByHash(txHash: BigNumberish): Promise<RPC.RPCSPEC06.TransactionWithHash>;
+    getTransactionByBlockIdAndIndex(blockIdentifier: BlockIdentifier, index: number): Promise<RPC.RPCSPEC06.TransactionWithHash>;
+    getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
+    getTransactionTrace(txHash: BigNumberish): Promise<RPC.RPCSPEC06.SPEC.TRANSACTION_TRACE>;
+    /**
+     * Get the status of a transaction
+     */
+    getTransactionStatus(transactionHash: BigNumberish): Promise<RPC.RPCSPEC06.TransactionStatus>;
+    /**
+     * @param invocations AccountInvocations
+     * @param options blockIdentifier and flags to skip validation and fee charge<br/>
+     * - blockIdentifier<br/>
+     * - skipValidate (default false)<br/>
+     * - skipFeeCharge (default true)<br/>
+     */
+    getSimulateTransaction(invocations: AccountInvocations, options?: getSimulateTransactionOptions): Promise<import("../types").SimulateTransactionResponse>;
+    waitForTransaction(txHash: BigNumberish, options?: waitForTransactionOptions): Promise<GetTransactionReceiptResponse>;
+    getStorageAt(contractAddress: BigNumberish, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<string>;
+    getClassHashAt(contractAddress: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<string>;
+    getClassByHash(classHash: BigNumberish): Promise<import("../types").LegacyContractClass | Omit<import("../types").CompiledSierra, "sierra_program_debug_info">>;
+    getClass(classHash: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<import("../types").LegacyContractClass | Omit<import("../types").CompiledSierra, "sierra_program_debug_info">>;
+    getClassAt(contractAddress: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<import("../types").LegacyContractClass | Omit<import("../types").CompiledSierra, "sierra_program_debug_info">>;
+    getContractVersion(contractAddress: BigNumberish, classHash?: undefined, options?: getContractVersionOptions): Promise<ContractVersion>;
+    getContractVersion(contractAddress: undefined, classHash: BigNumberish, options?: getContractVersionOptions): Promise<ContractVersion>;
+    /**
+     * @deprecated use get*type*EstimateFee (will be refactored based on type after sequencer deprecation)
+     */
+    getEstimateFee(invocation: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier, skipValidate?: boolean): Promise<import("../types").EstimateFeeResponse>;
+    getInvokeEstimateFee(invocation: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier, skipValidate?: boolean): Promise<import("../types").EstimateFeeResponse>;
+    getDeclareEstimateFee(invocation: DeclareContractTransaction, details: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier, skipValidate?: boolean): Promise<import("../types").EstimateFeeResponse>;
+    getDeployAccountEstimateFee(invocation: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier, skipValidate?: boolean): Promise<import("../types").EstimateFeeResponse>;
+    getEstimateFeeBulk(invocations: AccountInvocations, options: getEstimateFeeBulkOptions): Promise<import("../types").EstimateFeeResponseBulk>;
+    invokeFunction(functionInvocation: Invocation, details: InvocationsDetailsWithNonce): Promise<RPC.InvokedTransaction>;
+    declareContract(transaction: DeclareContractTransaction, details: InvocationsDetailsWithNonce): Promise<RPC.DeclaredTransaction>;
+    deployAccountContract(transaction: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce): Promise<RPC.DeployedAccountTransaction>;
+    callContract(call: Call, blockIdentifier?: BlockIdentifier): Promise<string[]>;
+    /**
+     * NEW: Estimate the fee for a message from L1
+     * @param message Message From L1
+     */
+    estimateMessageFee(message: RPC.L1Message, blockIdentifier?: BlockIdentifier): Promise<RPC.RPCSPEC06.SPEC.FEE_ESTIMATE>;
+    /**
+     * Returns an object about the sync status, or false if the node is not synching
+     * @returns Object with the stats data
+     */
+    getSyncingStats(): Promise<RPC.RPCSPEC06.Syncing>;
+    /**
+     * Returns all events matching the given filter
+     * @returns events and the pagination of the events
+     */
+    getEvents(eventFilter: RPC.EventFilter): Promise<RPC.RPCSPEC06.SPEC.EVENTS_CHUNK>;
+}