starknet 5.22.0 → 5.23.0

package/dist/index.js

@@ -78,6 +78,7 @@ __export(src_exports, {
   fixStack: () => fixStack,
   getCalldata: () => getCalldata,
   getChecksumAddress: () => getChecksumAddress,
+  getDefaultNodeUrl: () => getDefaultNodeUrl,
   hash: () => hash_exports,
   isSierra: () => isSierra,
   isUrl: () => isUrl,
@@ -116,6 +117,8 @@ __export(constants_exports, {
   MASK_250: () => MASK_250,
   MASK_251: () => MASK_251,
   NetworkName: () => NetworkName,
+  RPC_GOERLI_NODES: () => RPC_GOERLI_NODES,
+  RPC_MAINNET_NODES: () => RPC_MAINNET_NODES,
   StarknetChainId: () => StarknetChainId,
   TEXT_TO_FELT_MAX_LEN: () => TEXT_TO_FELT_MAX_LEN,
   TransactionHashPrefix: () => TransactionHashPrefix,
@@ -141,6 +144,7 @@ __export(encode_exports, {
   stringToArrayBuffer: () => stringToArrayBuffer,
   utf8ToArray: () => utf8ToArray
 });
+var import_base = require("@scure/base");
 var IS_BROWSER = typeof window !== "undefined";
 var STRING_ZERO = "0";
 function arrayBufferToString(array) {
@@ -153,10 +157,10 @@ function stringToArrayBuffer(str) {
   return utf8ToArray(str);
 }
 function atobUniversal(a) {
-  return IS_BROWSER ? utf8ToArray(atob(a)) : Buffer.from(a, "base64");
+  return import_base.base64.decode(a);
 }
 function btoaUniversal(b) {
-  return IS_BROWSER ? btoa(arrayBufferToString(b)) : Buffer.from(b).toString("base64");
+  return import_base.base64.encode(new Uint8Array(b));
 }
 function buf2hex(buffer) {
   return buffer.reduce((r, x) => r + x.toString(16).padStart(2, "0"), "");
@@ -236,6 +240,14 @@ var UDC = {
   ADDRESS: "0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf",
   ENTRYPOINT: "deployContract"
 };
+var RPC_GOERLI_NODES = [
+  "https://starknet-testnet.public.blastapi.io/rpc/v0.5",
+  "https://limited-rpc.nethermind.io/goerli-juno/v0_5"
+];
+var RPC_MAINNET_NODES = [
+  "https://starknet-mainnet.public.blastapi.io/rpc/v0.5",
+  "https://limited-rpc.nethermind.io/mainnet-juno/v0_5"
+];
 
 // src/types/index.ts
 var types_exports = {};
@@ -256,10 +268,10 @@ __export(types_exports, {
 });
 
 // src/types/account.ts
-var SIMULATION_FLAG = /* @__PURE__ */ ((SIMULATION_FLAG3) => {
-  SIMULATION_FLAG3["SKIP_VALIDATE"] = "SKIP_VALIDATE";
-  SIMULATION_FLAG3["SKIP_EXECUTE"] = "SKIP_EXECUTE";
-  return SIMULATION_FLAG3;
+var SIMULATION_FLAG = /* @__PURE__ */ ((SIMULATION_FLAG2) => {
+  SIMULATION_FLAG2["SKIP_VALIDATE"] = "SKIP_VALIDATE";
+  SIMULATION_FLAG2["SKIP_EXECUTE"] = "SKIP_EXECUTE";
+  return SIMULATION_FLAG2;
 })(SIMULATION_FLAG || {});
 
 // src/types/calldata.ts
@@ -293,12 +305,12 @@ var EntryPointType = /* @__PURE__ */ ((EntryPointType2) => {
 })(EntryPointType || {});
 
 // src/types/lib/index.ts
-var TransactionType = /* @__PURE__ */ ((TransactionType3) => {
-  TransactionType3["DECLARE"] = "DECLARE";
-  TransactionType3["DEPLOY"] = "DEPLOY";
-  TransactionType3["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
-  TransactionType3["INVOKE"] = "INVOKE_FUNCTION";
-  return TransactionType3;
+var TransactionType = /* @__PURE__ */ ((TransactionType2) => {
+  TransactionType2["DECLARE"] = "DECLARE";
+  TransactionType2["DEPLOY"] = "DEPLOY";
+  TransactionType2["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
+  TransactionType2["INVOKE"] = "INVOKE_FUNCTION";
+  return TransactionType2;
 })(TransactionType || {});
 var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
   TransactionStatus2["NOT_RECEIVED"] = "NOT_RECEIVED";
@@ -309,18 +321,18 @@ var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
   TransactionStatus2["REVERTED"] = "REVERTED";
   return TransactionStatus2;
 })(TransactionStatus || {});
-var TransactionFinalityStatus = /* @__PURE__ */ ((TransactionFinalityStatus3) => {
-  TransactionFinalityStatus3["NOT_RECEIVED"] = "NOT_RECEIVED";
-  TransactionFinalityStatus3["RECEIVED"] = "RECEIVED";
-  TransactionFinalityStatus3["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-  TransactionFinalityStatus3["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-  return TransactionFinalityStatus3;
+var TransactionFinalityStatus = /* @__PURE__ */ ((TransactionFinalityStatus2) => {
+  TransactionFinalityStatus2["NOT_RECEIVED"] = "NOT_RECEIVED";
+  TransactionFinalityStatus2["RECEIVED"] = "RECEIVED";
+  TransactionFinalityStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
+  TransactionFinalityStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
+  return TransactionFinalityStatus2;
 })(TransactionFinalityStatus || {});
-var TransactionExecutionStatus = /* @__PURE__ */ ((TransactionExecutionStatus3) => {
-  TransactionExecutionStatus3["REJECTED"] = "REJECTED";
-  TransactionExecutionStatus3["REVERTED"] = "REVERTED";
-  TransactionExecutionStatus3["SUCCEEDED"] = "SUCCEEDED";
-  return TransactionExecutionStatus3;
+var TransactionExecutionStatus = /* @__PURE__ */ ((TransactionExecutionStatus2) => {
+  TransactionExecutionStatus2["REJECTED"] = "REJECTED";
+  TransactionExecutionStatus2["REVERTED"] = "REVERTED";
+  TransactionExecutionStatus2["SUCCEEDED"] = "SUCCEEDED";
+  return TransactionExecutionStatus2;
 })(TransactionExecutionStatus || {});
 var BlockStatus = /* @__PURE__ */ ((BlockStatus2) => {
   BlockStatus2["PENDING"] = "PENDING";
@@ -338,42 +350,68 @@ var BlockTag = /* @__PURE__ */ ((BlockTag2) => {
 // src/types/api/rpc.ts
 var rpc_exports = {};
 __export(rpc_exports, {
-  SimulationFlag: () => SimulationFlag,
-  TransactionExecutionStatus: () => TransactionExecutionStatus2,
-  TransactionFinalityStatus: () => TransactionFinalityStatus2,
-  TransactionType: () => TransactionType2
+  EBlockTag: () => EBlockTag,
+  EDataAvailabilityMode: () => EDataAvailabilityMode,
+  ESimulationFlag: () => ESimulationFlag,
+  ETransactionExecutionStatus: () => ETransactionExecutionStatus,
+  ETransactionFinalityStatus: () => ETransactionFinalityStatus,
+  ETransactionStatus: () => ETransactionStatus,
+  ETransactionType: () => ETransactionType,
+  Errors: () => errors_exports,
+  JRPC: () => jsonrpc_exports,
+  SPEC: () => components_exports
 });
 
-// src/types/api/openrpc.ts
-var TXN_TYPE = /* @__PURE__ */ ((TXN_TYPE2) => {
-  TXN_TYPE2["DECLARE"] = "DECLARE";
-  TXN_TYPE2["DEPLOY"] = "DEPLOY";
-  TXN_TYPE2["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
-  TXN_TYPE2["INVOKE"] = "INVOKE";
-  TXN_TYPE2["L1_HANDLER"] = "L1_HANDLER";
-  return TXN_TYPE2;
-})(TXN_TYPE || {});
-var TXN_FINALITY_STATUS = /* @__PURE__ */ ((TXN_FINALITY_STATUS2) => {
-  TXN_FINALITY_STATUS2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-  TXN_FINALITY_STATUS2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-  return TXN_FINALITY_STATUS2;
-})(TXN_FINALITY_STATUS || {});
-var TXN_EXECUTION_STATUS = /* @__PURE__ */ ((TXN_EXECUTION_STATUS2) => {
-  TXN_EXECUTION_STATUS2["SUCCEEDED"] = "SUCCEEDED";
-  TXN_EXECUTION_STATUS2["REVERTED"] = "REVERTED";
-  return TXN_EXECUTION_STATUS2;
-})(TXN_EXECUTION_STATUS || {});
-var SIMULATION_FLAG2 = /* @__PURE__ */ ((SIMULATION_FLAG3) => {
-  SIMULATION_FLAG3["SKIP_VALIDATE"] = "SKIP_VALIDATE";
-  SIMULATION_FLAG3["SKIP_FEE_CHARGE"] = "SKIP_FEE_CHARGE";
-  return SIMULATION_FLAG3;
-})(SIMULATION_FLAG2 || {});
+// src/types/api/jsonrpc/index.ts
+var jsonrpc_exports = {};
 
-// src/types/api/rpc.ts
-var TransactionType2 = TXN_TYPE;
-var SimulationFlag = SIMULATION_FLAG2;
-var TransactionFinalityStatus2 = TXN_FINALITY_STATUS;
-var TransactionExecutionStatus2 = TXN_EXECUTION_STATUS;
+// src/types/api/rpcspec/errors.ts
+var errors_exports = {};
+
+// src/types/api/rpcspec/components.ts
+var components_exports = {};
+
+// src/types/api/rpcspec/nonspec.ts
+var ETransactionType = /* @__PURE__ */ ((ETransactionType2) => {
+  ETransactionType2["DECLARE"] = "DECLARE";
+  ETransactionType2["DEPLOY"] = "DEPLOY";
+  ETransactionType2["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
+  ETransactionType2["INVOKE"] = "INVOKE";
+  ETransactionType2["L1_HANDLER"] = "L1_HANDLER";
+  return ETransactionType2;
+})(ETransactionType || {});
+var ESimulationFlag = /* @__PURE__ */ ((ESimulationFlag2) => {
+  ESimulationFlag2["SKIP_VALIDATE"] = "SKIP_VALIDATE";
+  ESimulationFlag2["SKIP_FEE_CHARGE"] = "SKIP_FEE_CHARGE";
+  return ESimulationFlag2;
+})(ESimulationFlag || {});
+var ETransactionStatus = /* @__PURE__ */ ((ETransactionStatus2) => {
+  ETransactionStatus2["RECEIVED"] = "RECEIVED";
+  ETransactionStatus2["REJECTED"] = "REJECTED";
+  ETransactionStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
+  ETransactionStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
+  return ETransactionStatus2;
+})(ETransactionStatus || {});
+var ETransactionFinalityStatus = /* @__PURE__ */ ((ETransactionFinalityStatus2) => {
+  ETransactionFinalityStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
+  ETransactionFinalityStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
+  return ETransactionFinalityStatus2;
+})(ETransactionFinalityStatus || {});
+var ETransactionExecutionStatus = /* @__PURE__ */ ((ETransactionExecutionStatus2) => {
+  ETransactionExecutionStatus2["SUCCEEDED"] = "SUCCEEDED";
+  ETransactionExecutionStatus2["REVERTED"] = "REVERTED";
+  return ETransactionExecutionStatus2;
+})(ETransactionExecutionStatus || {});
+var EBlockTag = /* @__PURE__ */ ((EBlockTag2) => {
+  EBlockTag2["LATEST"] = "latest";
+  EBlockTag2["PENDING"] = "pending";
+  return EBlockTag2;
+})(EBlockTag || {});
+var EDataAvailabilityMode = /* @__PURE__ */ ((EDataAvailabilityMode2) => {
+  EDataAvailabilityMode2["L1"] = "L1";
+  EDataAvailabilityMode2["L2"] = "L2";
+  return EDataAvailabilityMode2;
+})(EDataAvailabilityMode || {});
 
 // src/types/api/sequencer.ts
 var sequencer_exports = {};
@@ -2241,10 +2279,10 @@ function compressProgram(jsonProgram) {
   const compressedProgram = (0, import_pako.gzip)(stringified);
   return btoaUniversal(compressedProgram);
 }
-function decompressProgram(base64) {
-  if (Array.isArray(base64))
-    return base64;
-  const decompressed = arrayBufferToString((0, import_pako.ungzip)(atobUniversal(base64)));
+function decompressProgram(base642) {
+  if (Array.isArray(base642))
+    return base642;
+  const decompressed = arrayBufferToString((0, import_pako.ungzip)(atobUniversal(base642)));
   return parse2(decompressed);
 }
 function randomAddress() {
@@ -2349,22 +2387,22 @@ var RPCResponseParser = class {
   parseGetBlockResponse(res) {
     return {
       timestamp: res.timestamp,
-      block_hash: res.block_hash,
-      block_number: res.block_number,
-      new_root: res.new_root,
+      block_hash: "block_hash" in res ? res.block_hash : "",
+      block_number: "block_number" in res ? res.block_number : -1,
+      new_root: "new_root" in res ? res.new_root : "",
       parent_hash: res.parent_hash,
-      status: res.status,
+      status: "status" in res ? res.status : "PENDING" /* PENDING */,
       transactions: res.transactions
     };
   }
   parseGetTransactionResponse(res) {
     return {
-      calldata: res.calldata || [],
-      contract_address: res.contract_address,
-      sender_address: res.contract_address,
-      max_fee: res.max_fee,
-      nonce: res.nonce,
-      signature: res.signature || [],
+      calldata: "calldata" in res ? res.calldata : [],
+      contract_address: "contract_address" in res ? res.contract_address : "",
+      sender_address: "sender_address" in res ? res.sender_address : "",
+      max_fee: "max_fee" in res ? res.max_fee : "",
+      nonce: "nonce" in res ? res.nonce : "",
+      signature: "signature" in res ? res.signature : [],
       transaction_hash: res.transaction_hash,
       version: res.version
     };
@@ -2640,6 +2678,13 @@ var Block = class {
 };
 
 // src/provider/rpc.ts
+var getDefaultNodeUrl = (networkName, mute = false) => {
+  if (!mute)
+    console.warn("Using default public node url, please provide nodeUrl in provider options!");
+  const nodes = networkName === "SN_MAIN" /* SN_MAIN */ ? RPC_MAINNET_NODES : RPC_GOERLI_NODES;
+  const randIdx = Math.floor(Math.random() * nodes.length);
+  return nodes[randIdx];
+};
 var defaultOptions = {
   headers: { "Content-Type": "application/json" },
   blockIdentifier: "pending" /* pending */,
@@ -2648,52 +2693,127 @@ var defaultOptions = {
 var RpcProvider = class {
   constructor(optionsOrProvider) {
     this.responseParser = new RPCResponseParser();
-    const { nodeUrl, retries, headers, blockIdentifier, chainId } = optionsOrProvider;
-    this.nodeUrl = nodeUrl;
+    /**
+     * @deprecated renamed to getBlockLatestAccepted(); (will be removed in next minor version)
+     */
+    this.getBlockHashAndNumber = this.getBlockLatestAccepted;
+    /**
+     * @deprecated renamed to getBlockStateUpdate();
+     */
+    this.getStateUpdate = this.getBlockStateUpdate;
+    /**
+     * Returns the execution traces of all transactions included in the given block
+     * @deprecated renamed to getBlockTransactionsTraces()
+     */
+    this.traceBlockTransactions = this.getBlockTransactionsTraces;
+    /**
+     * Get the number of transactions in a block given a block id
+     * @deprecated renamed to getBlockTransactionCount()
+     * @returns Number of transactions
+     */
+    this.getTransactionCount = this.getBlockTransactionCount;
+    /**
+     * @deprecated renamed to getTransactionTrace();
+     * For a given executed transaction, return the trace of its execution, including internal calls
+     */
+    this.traceTransaction = this.getTransactionTrace;
+    /**
+     * @deprecated renamed to simulateTransaction();
+     */
+    this.getSimulateTransaction = this.simulateTransaction;
+    const { nodeUrl, retries, headers, blockIdentifier, chainId } = optionsOrProvider || {};
+    if (Object.values(NetworkName).includes(nodeUrl)) {
+      this.nodeUrl = getDefaultNodeUrl(nodeUrl, optionsOrProvider?.default);
+    } else if (nodeUrl) {
+      this.nodeUrl = nodeUrl;
+    } else {
+      this.nodeUrl = getDefaultNodeUrl(void 0, optionsOrProvider?.default);
+    }
     this.retries = retries || defaultOptions.retries;
     this.headers = { ...defaultOptions.headers, ...headers };
     this.blockIdentifier = blockIdentifier || defaultOptions.blockIdentifier;
     this.chainId = chainId;
     this.getChainId();
   }
-  fetch(method, params) {
-    const body = stringify2({ method, jsonrpc: "2.0", params, id: 0 });
+  fetch(method, params, id = 0) {
+    const rpcRequestBody = {
+      id,
+      jsonrpc: "2.0",
+      method,
+      ...params && { params }
+    };
     return fetchPonyfill_default(this.nodeUrl, {
       method: "POST",
-      body,
+      body: stringify2(rpcRequestBody),
       headers: this.headers
     });
   }
-  errorHandler(error) {
-    if (error) {
-      const { code, message } = error;
-      throw new LibraryError(`${code}: ${message}`);
+  errorHandler(method, params, rpcError, otherError) {
+    if (rpcError) {
+      const { code, message, data } = rpcError;
+      throw new LibraryError(
+        `RPC: ${method} with params ${JSON.stringify(params)}
+ ${code}: ${message}: ${data}`
+      );
+    }
+    if (otherError instanceof LibraryError) {
+      throw otherError;
+    }
+    if (otherError) {
+      throw Error(otherError.message);
     }
   }
   async fetchEndpoint(method, params) {
     try {
       const rawResult = await this.fetch(method, params);
       const { error, result } = await rawResult.json();
-      this.errorHandler(error);
+      this.errorHandler(method, params, error);
       return result;
     } catch (error) {
-      this.errorHandler(error?.response?.data);
+      this.errorHandler(method, params, error?.response?.data, error);
       throw error;
     }
   }
-  // Methods from Interface
   async getChainId() {
     this.chainId ?? (this.chainId = await this.fetchEndpoint("starknet_chainId"));
     return this.chainId;
   }
+  /**
+   * NEW: Returns the version of the Starknet JSON-RPC specification being used
+   */
+  async getSpecVersion() {
+    return this.fetchEndpoint("starknet_specVersion");
+  }
+  async getNonceForAddress(contractAddress, blockIdentifier = this.blockIdentifier) {
+    const contract_address = toHex(contractAddress);
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getNonce", {
+      contract_address,
+      block_id
+    });
+  }
+  /**
+   * @deprecated use getBlockWithTxHashes or getBlockWithTxs (will be removed on sequencer deprecation)
+   */
   async getBlock(blockIdentifier = this.blockIdentifier) {
     return this.getBlockWithTxHashes(blockIdentifier).then(
       this.responseParser.parseGetBlockResponse
     );
   }
-  async getBlockHashAndNumber() {
+  /**
+   * Get the most recent accepted block hash and number
+   */
+  async getBlockLatestAccepted() {
     return this.fetchEndpoint("starknet_blockHashAndNumber");
   }
+  /**
+   * @deprecated redundant use getBlockLatestAccepted();
+   * Get the most recent accepted block number
+   * @returns Number of the latest block
+   */
+  async getBlockNumber() {
+    return this.fetchEndpoint("starknet_blockNumber");
+  }
   async getBlockWithTxHashes(blockIdentifier = this.blockIdentifier) {
     const block_id = new Block(blockIdentifier).identifier;
     return this.fetchEndpoint("starknet_getBlockWithTxHashes", { block_id });
@@ -2702,68 +2822,176 @@ var RpcProvider = class {
     const block_id = new Block(blockIdentifier).identifier;
     return this.fetchEndpoint("starknet_getBlockWithTxs", { block_id });
   }
-  async getClassHashAt(contractAddress, blockIdentifier = this.blockIdentifier) {
+  async getBlockStateUpdate(blockIdentifier = this.blockIdentifier) {
     const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getClassHashAt", {
-      block_id,
-      contract_address: contractAddress
-    });
+    return this.fetchEndpoint("starknet_getStateUpdate", { block_id });
   }
-  async getNonceForAddress(contractAddress, blockIdentifier = this.blockIdentifier) {
+  async getBlockTransactionsTraces(blockIdentifier = this.blockIdentifier) {
     const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getNonce", {
-      contract_address: contractAddress,
-      block_id
-    });
+    return this.fetchEndpoint("starknet_traceBlockTransactions", { block_id });
   }
+  async getBlockTransactionCount(blockIdentifier = this.blockIdentifier) {
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getBlockTransactionCount", { block_id });
+  }
+  /**
+   * Return transactions from pending block
+   * @deprecated Instead use getBlock(BlockTag.pending); (will be removed in next minor version)
+   */
   async getPendingTransactions() {
-    return this.fetchEndpoint("starknet_pendingTransactions");
+    const { transactions } = await this.getBlock("pending" /* pending */);
+    return Promise.all(transactions.map((it) => this.getTransactionByHash(it)));
   }
-  async getProtocolVersion() {
-    throw new Error("Pathfinder does not implement this rpc 0.1.0 method");
+  /**
+   * @deprecated use getTransactionByHash or getTransactionByBlockIdAndIndex (will be removed on sequencer deprecation)
+   */
+  async getTransaction(txHash) {
+    return this.getTransactionByHash(txHash).then(this.responseParser.parseGetTransactionResponse);
   }
-  async getStateUpdate(blockIdentifier = this.blockIdentifier) {
+  async getTransactionByHash(txHash) {
+    const transaction_hash = toHex(txHash);
+    return this.fetchEndpoint("starknet_getTransactionByHash", {
+      transaction_hash
+    });
+  }
+  async getTransactionByBlockIdAndIndex(blockIdentifier, index) {
     const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getStateUpdate", { block_id });
+    return this.fetchEndpoint("starknet_getTransactionByBlockIdAndIndex", { block_id, index });
+  }
+  async getTransactionReceipt(txHash) {
+    const transaction_hash = toHex(txHash);
+    return this.fetchEndpoint("starknet_getTransactionReceipt", { transaction_hash });
+  }
+  async getTransactionTrace(txHash) {
+    const transaction_hash = toHex(txHash);
+    return this.fetchEndpoint("starknet_traceTransaction", { transaction_hash });
+  }
+  // TODO: implement in waitforTransaction, add add tests, when RPC 0.5 become standard /
+  /**
+   * NEW: Get the status of a transaction
+   */
+  async getTransactionStatus(transactionHash) {
+    const transaction_hash = toHex(transactionHash);
+    return this.fetchEndpoint("starknet_getTransactionStatus", { transaction_hash });
+  }
+  /**
+   * @param invocations AccountInvocations
+   * @param simulateTransactionOptions blockIdentifier and flags to skip validation and fee charge<br/>
+   * - blockIdentifier<br/>
+   * - skipValidate (default false)<br/>
+   * - skipFeeCharge (default true)<br/>
+   */
+  async simulateTransaction(invocations, {
+    blockIdentifier = this.blockIdentifier,
+    skipValidate = false,
+    skipFeeCharge = true
+  }) {
+    const block_id = new Block(blockIdentifier).identifier;
+    const simulationFlags = [];
+    if (skipValidate)
+      simulationFlags.push(rpc_exports.ESimulationFlag.SKIP_VALIDATE);
+    if (skipFeeCharge)
+      simulationFlags.push(rpc_exports.ESimulationFlag.SKIP_FEE_CHARGE);
+    return this.fetchEndpoint("starknet_simulateTransactions", {
+      block_id,
+      transactions: invocations.map((it) => this.buildTransaction(it)),
+      simulation_flags: simulationFlags
+    }).then(this.responseParser.parseSimulateTransactionResponse);
+  }
+  async waitForTransaction(txHash, options) {
+    const transactionHash = toHex(txHash);
+    let { retries } = this;
+    let onchain = false;
+    let isErrorState = false;
+    const retryInterval = options?.retryInterval ?? 5e3;
+    const errorStates = options?.errorStates ?? [
+      rpc_exports.ETransactionStatus.REJECTED,
+      rpc_exports.ETransactionExecutionStatus.REVERTED
+    ];
+    const successStates = options?.successStates ?? [
+      rpc_exports.ETransactionExecutionStatus.SUCCEEDED,
+      rpc_exports.ETransactionStatus.ACCEPTED_ON_L2,
+      rpc_exports.ETransactionStatus.ACCEPTED_ON_L1
+    ];
+    let txStatus;
+    while (!onchain) {
+      await wait(retryInterval);
+      try {
+        txStatus = await this.getTransactionStatus(transactionHash);
+        const executionStatus = txStatus.execution_status;
+        const finalityStatus = txStatus.finality_status;
+        if (!finalityStatus) {
+          const error = new Error("waiting for transaction status");
+          throw error;
+        }
+        if (successStates.includes(executionStatus) || successStates.includes(finalityStatus)) {
+          onchain = true;
+        } else if (errorStates.includes(executionStatus) || errorStates.includes(finalityStatus)) {
+          const message = `${executionStatus}: ${finalityStatus}`;
+          const error = new Error(message);
+          error.response = txStatus;
+          isErrorState = true;
+          throw error;
+        }
+      } catch (error) {
+        if (error instanceof Error && isErrorState) {
+          throw error;
+        }
+        if (retries <= 0) {
+          throw new Error(`waitForTransaction timed-out with retries ${this.retries}`);
+        }
+      }
+      retries -= 1;
+    }
+    let txReceipt = null;
+    while (txReceipt === null) {
+      try {
+        txReceipt = await this.getTransactionReceipt(transactionHash);
+      } catch (error) {
+        if (retries <= 0) {
+          throw new Error(`waitForTransaction timed-out with retries ${this.retries}`);
+        }
+      }
+      retries -= 1;
+      await wait(retryInterval);
+    }
+    return txReceipt;
   }
   async getStorageAt(contractAddress, key, blockIdentifier = this.blockIdentifier) {
+    const contract_address = toHex(contractAddress);
     const parsedKey = toStorageKey(key);
     const block_id = new Block(blockIdentifier).identifier;
     return this.fetchEndpoint("starknet_getStorageAt", {
-      contract_address: contractAddress,
+      contract_address,
       key: parsedKey,
       block_id
     });
   }
-  // Methods from Interface
-  async getTransaction(txHash) {
-    return this.getTransactionByHash(txHash).then(this.responseParser.parseGetTransactionResponse);
-  }
-  async getTransactionByHash(txHash) {
-    return this.fetchEndpoint("starknet_getTransactionByHash", { transaction_hash: txHash });
-  }
-  async getTransactionByBlockIdAndIndex(blockIdentifier, index) {
+  async getClassHashAt(contractAddress, blockIdentifier = this.blockIdentifier) {
+    const contract_address = toHex(contractAddress);
     const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getTransactionByBlockIdAndIndex", { block_id, index });
-  }
-  async getTransactionReceipt(txHash) {
-    return this.fetchEndpoint("starknet_getTransactionReceipt", { transaction_hash: txHash });
+    return this.fetchEndpoint("starknet_getClassHashAt", {
+      block_id,
+      contract_address
+    });
   }
   async getClassByHash(classHash) {
     return this.getClass(classHash);
   }
   async getClass(classHash, blockIdentifier = this.blockIdentifier) {
+    const class_hash = toHex(classHash);
     const block_id = new Block(blockIdentifier).identifier;
     return this.fetchEndpoint("starknet_getClass", {
-      class_hash: classHash,
+      class_hash,
       block_id
     }).then(this.responseParser.parseContractClassResponse);
   }
   async getClassAt(contractAddress, blockIdentifier = this.blockIdentifier) {
+    const contract_address = toHex(contractAddress);
     const block_id = new Block(blockIdentifier).identifier;
     return this.fetchEndpoint("starknet_getClassAt", {
       block_id,
-      contract_address: contractAddress
+      contract_address
     }).then(this.responseParser.parseContractClassResponse);
   }
   async getCode(_contractAddress, _blockIdentifier) {
@@ -2787,6 +3015,9 @@ var RpcProvider = class {
     }
     return { cairo: "0", compiler: "0" };
   }
+  /**
+   * @deprecated use get*type*EstimateFee (will be refactored based on type after sequencer deprecation)
+   */
   async getEstimateFee(invocation, invocationDetails, blockIdentifier = this.blockIdentifier) {
     return this.getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier);
   }
@@ -2845,11 +3076,24 @@ var RpcProvider = class {
       block_id
     }).then(this.responseParser.parseFeeEstimateBulkResponse);
   }
+  async invokeFunction(functionInvocation, details) {
+    return this.fetchEndpoint("starknet_addInvokeTransaction", {
+      invoke_transaction: {
+        sender_address: functionInvocation.contractAddress,
+        calldata: CallData.toHex(functionInvocation.calldata),
+        type: rpc_exports.ETransactionType.INVOKE,
+        max_fee: toHex(details.maxFee || 0),
+        version: "0x1",
+        signature: signatureToHexArray(functionInvocation.signature),
+        nonce: toHex(details.nonce)
+      }
+    });
+  }
   async declareContract({ contract, signature, senderAddress, compiledClassHash }, details) {
     if (!isSierra(contract)) {
       return this.fetchEndpoint("starknet_addDeclareTransaction", {
         declare_transaction: {
-          type: rpc_exports.TransactionType.DECLARE,
+          type: rpc_exports.ETransactionType.DECLARE,
           contract_class: {
             program: contract.program,
             entry_points_by_type: contract.entry_points_by_type,
@@ -2865,7 +3109,7 @@ var RpcProvider = class {
     }
     return this.fetchEndpoint("starknet_addDeclareTransaction", {
       declare_transaction: {
-        type: rpc_exports.TransactionType.DECLARE,
+        type: rpc_exports.ETransactionType.DECLARE,
         contract_class: {
           sierra_program: decompressProgram(contract.sierra_program),
           contract_class_version: contract.contract_class_version,
@@ -2887,7 +3131,7 @@ var RpcProvider = class {
         constructor_calldata: CallData.toHex(constructorCalldata || []),
         class_hash: toHex(classHash),
         contract_address_salt: toHex(addressSalt || 0),
-        type: rpc_exports.TransactionType.DEPLOY_ACCOUNT,
+        type: rpc_exports.ETransactionType.DEPLOY_ACCOUNT,
         max_fee: toHex(details.maxFee || 0),
         version: toHex(details.version || 0),
         signature: signatureToHexArray(signature),
@@ -2895,20 +3139,6 @@ var RpcProvider = class {
       }
     });
   }
-  async invokeFunction(functionInvocation, details) {
-    return this.fetchEndpoint("starknet_addInvokeTransaction", {
-      invoke_transaction: {
-        sender_address: functionInvocation.contractAddress,
-        calldata: CallData.toHex(functionInvocation.calldata),
-        type: rpc_exports.TransactionType.INVOKE,
-        max_fee: toHex(details.maxFee || 0),
-        version: "0x1",
-        signature: signatureToHexArray(functionInvocation.signature),
-        nonce: toHex(details.nonce)
-      }
-    });
-  }
-  // Methods from Interface
   async callContract(call, blockIdentifier = this.blockIdentifier) {
     const block_id = new Block(blockIdentifier).identifier;
     const result = await this.fetchEndpoint("starknet_call", {
@@ -2921,117 +3151,47 @@ var RpcProvider = class {
     });
     return this.responseParser.parseCallContractResponse(result);
   }
-  async traceTransaction(transactionHash) {
-    return this.fetchEndpoint("starknet_traceTransaction", { transaction_hash: transactionHash });
-  }
-  async traceBlockTransactions(blockHash) {
-    return this.fetchEndpoint("starknet_traceBlockTransactions", { block_hash: blockHash });
-  }
-  async waitForTransaction(txHash, options) {
-    let { retries } = this;
-    let onchain = false;
-    let isErrorState = false;
-    let txReceipt = {};
-    const retryInterval = options?.retryInterval ?? 5e3;
-    const errorStates = options?.errorStates ?? [TransactionExecutionStatus2.REVERTED];
-    const successStates = options?.successStates ?? [
-      TransactionExecutionStatus2.SUCCEEDED,
-      TransactionFinalityStatus2.ACCEPTED_ON_L1,
-      TransactionFinalityStatus2.ACCEPTED_ON_L2
-    ];
-    while (!onchain) {
-      await wait(retryInterval);
-      try {
-        txReceipt = await this.getTransactionReceipt(txHash);
-        const executionStatus = pascalToSnake(txReceipt.execution_status);
-        const finalityStatus = pascalToSnake(txReceipt.finality_status);
-        if (!executionStatus || !finalityStatus) {
-          const error = new Error("waiting for transaction status");
-          throw error;
-        }
-        if (successStates.includes(executionStatus) || successStates.includes(finalityStatus)) {
-          onchain = true;
-        } else if (errorStates.includes(executionStatus) || errorStates.includes(finalityStatus)) {
-          const message = `${executionStatus}: ${finalityStatus}: ${txReceipt.revert_reason}`;
-          const error = new Error(message);
-          error.response = txReceipt;
-          isErrorState = true;
-          throw error;
-        }
-      } catch (error) {
-        if (error instanceof Error && isErrorState) {
-          throw error;
-        }
-        if (retries === 0) {
-          throw new Error(`waitForTransaction timed-out with retries ${this.retries}`);
-        }
-      }
-      retries -= 1;
-    }
-    await wait(retryInterval);
-    return txReceipt;
-  }
   /**
-   * Gets the transaction count from a block.
-   *
-   *
-   * @param blockIdentifier
-   * @returns Number of transactions
+   * NEW: Estimate the fee for a message from L1
+   * @param message Message From L1
    */
-  async getTransactionCount(blockIdentifier = this.blockIdentifier) {
+  async estimateMessageFee(message, blockIdentifier = this.blockIdentifier) {
+    const { from_address, to_address, entry_point_selector, payload } = message;
+    const formattedMessage = {
+      from_address: toHex(from_address),
+      to_address: toHex(to_address),
+      entry_point_selector: getSelector(entry_point_selector),
+      payload: getHexStringArray(payload)
+    };
     const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getBlockTransactionCount", { block_id });
-  }
-  /**
-   * Gets the latest block number
-   *
-   *
-   * @returns Number of the latest block
-   */
-  async getBlockNumber() {
-    return this.fetchEndpoint("starknet_blockNumber");
+    return this.fetchEndpoint("starknet_estimateMessageFee", {
+      message: formattedMessage,
+      block_id
+    });
   }
   /**
-   * Gets syncing status of the node
-   *
-   *
+   * 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.fetchEndpoint("starknet_syncing");
   }
   /**
-   * Gets all the events filtered
-   *
-   *
+   * Returns all events matching the given filter
    * @returns events and the pagination of the events
    */
   async getEvents(eventFilter) {
     return this.fetchEndpoint("starknet_getEvents", { filter: eventFilter });
   }
-  async getSimulateTransaction(invocations, {
-    blockIdentifier = this.blockIdentifier,
-    skipValidate = false,
-    skipExecute = false,
-    // @deprecated
-    skipFeeCharge = true
-    // Pathfinder currently does not support `starknet_simulateTransactions` without `SKIP_FEE_CHARGE` simulation flag being set. This will become supported in a future release
-  }) {
-    const block_id = new Block(blockIdentifier).identifier;
-    const simulationFlags = [];
-    if (skipValidate)
-      simulationFlags.push(SimulationFlag.SKIP_VALIDATE);
-    if (skipExecute || skipFeeCharge)
-      simulationFlags.push(SimulationFlag.SKIP_FEE_CHARGE);
-    return this.fetchEndpoint("starknet_simulateTransactions", {
-      block_id,
-      transactions: invocations.map((it) => this.buildTransaction(it)),
-      simulation_flags: simulationFlags
-    }).then(this.responseParser.parseSimulateTransactionResponse);
-  }
+  /**
+   * StarknetId Endpoint (get name from address)
+   */
   async getStarkName(address, StarknetIdContract2) {
     return getStarkName(this, address, StarknetIdContract2);
   }
+  /**
+   * StarknetId Endpoint (get address from name)
+   */
   async getAddressFromStarkName(name, StarknetIdContract2) {
     return getAddressFromStarkName(this, name, StarknetIdContract2);
   }
@@ -3044,12 +3204,11 @@ var RpcProvider = class {
     };
     if (invocation.type === "INVOKE_FUNCTION" /* INVOKE */) {
       return {
-        type: rpc_exports.TransactionType.INVOKE,
+        type: rpc_exports.ETransactionType.INVOKE,
         // Diff between sequencer and rpc invoke type
         sender_address: invocation.contractAddress,
         calldata: CallData.toHex(invocation.calldata),
         version: toHex(invocation.version || defaultVersions.v1),
-        // HEX_STR_TRANSACTION_VERSION_1, // as any HOTFIX TODO: Resolve spec version
         ...details
       };
     }
@@ -3060,7 +3219,6 @@ var RpcProvider = class {
           contract_class: invocation.contract,
           sender_address: invocation.senderAddress,
           version: toHex(invocation.version || defaultVersions.v1),
-          // HEX_STR_TRANSACTION_VERSION_1, // as any HOTFIX TODO: Resolve spec version
           ...details
         };
       }
@@ -3074,7 +3232,6 @@ var RpcProvider = class {
         compiled_class_hash: invocation.compiledClassHash || "",
         sender_address: invocation.senderAddress,
         version: toHex(invocation.version || defaultVersions.v2),
-        // HEX_STR_TRANSACTION_VERSION_2, // as any HOTFIX TODO: Resolve spec version
         ...details
       };
     }
@@ -3758,7 +3915,7 @@ var Provider = class {
     } else if (providerOrOptions && "sequencer" in providerOrOptions) {
       this.provider = new SequencerProvider(providerOrOptions.sequencer);
     } else {
-      this.provider = new SequencerProvider();
+      this.provider = new RpcProvider();
     }
   }
   async getChainId() {
@@ -4208,7 +4365,7 @@ var Signer = class {
 // src/utils/events.ts
 function parseUDCEvent(txReceipt) {
   if (!txReceipt.events) {
-    throw new Error("UDC emited event is empty");
+    throw new Error("UDC emitted event is empty");
   }
   const event = txReceipt.events.find(
     (it) => cleanHex(it.from_address) === cleanHex(UDC.ADDRESS)
@@ -4747,7 +4904,7 @@ var ProviderInterface = class {
 };
 
 // src/provider/index.ts
-var defaultProvider = new Provider();
+var defaultProvider = new Provider({ rpc: { default: true } });
 
 // src/account/interface.ts
 var AccountInterface = class extends ProviderInterface {
@@ -5205,6 +5362,7 @@ var number = num_exports;
   fixStack,
   getCalldata,
   getChecksumAddress,
+  getDefaultNodeUrl,
   hash,
   isSierra,
   isUrl,