starknet 6.1.5 → 6.2.0

package/dist/index.global.js

@@ -12695,7 +12695,9 @@ var starknet = (() => {
     Provider: () => RpcProvider2,
     ProviderInterface: () => ProviderInterface,
     RPC: () => api_exports,
-    RpcChannel: () => RpcChannel,
+    RPC06: () => rpc_0_6_exports,
+    RPC07: () => rpc_0_7_exports,
+    RpcChannel: () => RpcChannel2,
     RpcProvider: () => RpcProvider2,
     SIMULATION_FLAG: () => SIMULATION_FLAG,
     Signer: () => Signer,
@@ -12761,7 +12763,7 @@ var starknet = (() => {
     RPC_NODES: () => RPC_NODES,
     StarknetChainId: () => StarknetChainId,
     TEXT_TO_FELT_MAX_LEN: () => TEXT_TO_FELT_MAX_LEN,
-    TRANSACTION_VERSION: () => ETransactionVersion,
+    TRANSACTION_VERSION: () => ETransactionVersion4,
     TransactionHashPrefix: () => TransactionHashPrefix,
     UDC: () => UDC,
     ZERO: () => ZERO
@@ -12770,6 +12772,30 @@ var starknet = (() => {
   // src/types/api/index.ts
   var api_exports = {};
   __export(api_exports, {
+    EBlockTag: () => EBlockTag2,
+    EDAMode: () => EDAMode2,
+    EDataAvailabilityMode: () => EDataAvailabilityMode2,
+    ESimulationFlag: () => ESimulationFlag2,
+    ETransactionExecutionStatus: () => ETransactionExecutionStatus2,
+    ETransactionFinalityStatus: () => ETransactionFinalityStatus2,
+    ETransactionStatus: () => ETransactionStatus2,
+    ETransactionType: () => ETransactionType2,
+    ETransactionVersion: () => ETransactionVersion4,
+    ETransactionVersion2: () => ETransactionVersion22,
+    ETransactionVersion3: () => ETransactionVersion32,
+    Errors: () => errors_exports2,
+    JRPC: () => jsonrpc_exports,
+    RPCSPEC06: () => rpcspec_0_6_exports,
+    RPCSPEC07: () => rpcspec_0_7_exports,
+    SPEC: () => components_exports2
+  });
+
+  // src/types/api/jsonrpc/index.ts
+  var jsonrpc_exports = {};
+
+  // src/types/api/rpcspec_0_6/index.ts
+  var rpcspec_0_6_exports = {};
+  __export(rpcspec_0_6_exports, {
     EBlockTag: () => EBlockTag,
     EDAMode: () => EDAMode,
     EDataAvailabilityMode: () => EDataAvailabilityMode,
@@ -12782,13 +12808,9 @@ var starknet = (() => {
     ETransactionVersion2: () => ETransactionVersion2,
     ETransactionVersion3: () => ETransactionVersion3,
     Errors: () => errors_exports,
-    JRPC: () => jsonrpc_exports,
     SPEC: () => components_exports
   });
 
-  // src/types/api/jsonrpc/index.ts
-  var jsonrpc_exports = {};
-
   // src/types/api/rpcspec_0_6/errors.ts
   var errors_exports = {};
 
@@ -12796,77 +12818,173 @@ var starknet = (() => {
   var components_exports = {};
 
   // src/types/api/rpcspec_0_6/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;
+  var ETransactionType = /* @__PURE__ */ ((ETransactionType3) => {
+    ETransactionType3["DECLARE"] = "DECLARE";
+    ETransactionType3["DEPLOY"] = "DEPLOY";
+    ETransactionType3["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
+    ETransactionType3["INVOKE"] = "INVOKE";
+    ETransactionType3["L1_HANDLER"] = "L1_HANDLER";
+    return ETransactionType3;
   })(ETransactionType || {});
-  var ESimulationFlag = /* @__PURE__ */ ((ESimulationFlag2) => {
-    ESimulationFlag2["SKIP_VALIDATE"] = "SKIP_VALIDATE";
-    ESimulationFlag2["SKIP_FEE_CHARGE"] = "SKIP_FEE_CHARGE";
-    return ESimulationFlag2;
+  var ESimulationFlag = /* @__PURE__ */ ((ESimulationFlag3) => {
+    ESimulationFlag3["SKIP_VALIDATE"] = "SKIP_VALIDATE";
+    ESimulationFlag3["SKIP_FEE_CHARGE"] = "SKIP_FEE_CHARGE";
+    return ESimulationFlag3;
   })(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;
+  var ETransactionStatus = /* @__PURE__ */ ((ETransactionStatus3) => {
+    ETransactionStatus3["RECEIVED"] = "RECEIVED";
+    ETransactionStatus3["REJECTED"] = "REJECTED";
+    ETransactionStatus3["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
+    ETransactionStatus3["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
+    return ETransactionStatus3;
   })(ETransactionStatus || {});
-  var ETransactionFinalityStatus = /* @__PURE__ */ ((ETransactionFinalityStatus2) => {
-    ETransactionFinalityStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-    ETransactionFinalityStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-    return ETransactionFinalityStatus2;
+  var ETransactionFinalityStatus = /* @__PURE__ */ ((ETransactionFinalityStatus3) => {
+    ETransactionFinalityStatus3["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
+    ETransactionFinalityStatus3["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
+    return ETransactionFinalityStatus3;
   })(ETransactionFinalityStatus || {});
-  var ETransactionExecutionStatus = /* @__PURE__ */ ((ETransactionExecutionStatus2) => {
-    ETransactionExecutionStatus2["SUCCEEDED"] = "SUCCEEDED";
-    ETransactionExecutionStatus2["REVERTED"] = "REVERTED";
-    return ETransactionExecutionStatus2;
+  var ETransactionExecutionStatus = /* @__PURE__ */ ((ETransactionExecutionStatus3) => {
+    ETransactionExecutionStatus3["SUCCEEDED"] = "SUCCEEDED";
+    ETransactionExecutionStatus3["REVERTED"] = "REVERTED";
+    return ETransactionExecutionStatus3;
   })(ETransactionExecutionStatus || {});
-  var EBlockTag = /* @__PURE__ */ ((EBlockTag2) => {
-    EBlockTag2["LATEST"] = "latest";
-    EBlockTag2["PENDING"] = "pending";
-    return EBlockTag2;
+  var EBlockTag = /* @__PURE__ */ ((EBlockTag3) => {
+    EBlockTag3["LATEST"] = "latest";
+    EBlockTag3["PENDING"] = "pending";
+    return EBlockTag3;
   })(EBlockTag || {});
-  var EDataAvailabilityMode = /* @__PURE__ */ ((EDataAvailabilityMode2) => {
-    EDataAvailabilityMode2["L1"] = "L1";
-    EDataAvailabilityMode2["L2"] = "L2";
-    return EDataAvailabilityMode2;
+  var EDataAvailabilityMode = /* @__PURE__ */ ((EDataAvailabilityMode3) => {
+    EDataAvailabilityMode3["L1"] = "L1";
+    EDataAvailabilityMode3["L2"] = "L2";
+    return EDataAvailabilityMode3;
   })(EDataAvailabilityMode || {});
-  var EDAMode = /* @__PURE__ */ ((EDAMode3) => {
-    EDAMode3[EDAMode3["L1"] = 0] = "L1";
-    EDAMode3[EDAMode3["L2"] = 1] = "L2";
-    return EDAMode3;
+  var EDAMode = /* @__PURE__ */ ((EDAMode4) => {
+    EDAMode4[EDAMode4["L1"] = 0] = "L1";
+    EDAMode4[EDAMode4["L2"] = 1] = "L2";
+    return EDAMode4;
   })(EDAMode || {});
-  var ETransactionVersion = /* @__PURE__ */ ((ETransactionVersion4) => {
-    ETransactionVersion4["V0"] = "0x0";
-    ETransactionVersion4["V1"] = "0x1";
-    ETransactionVersion4["V2"] = "0x2";
-    ETransactionVersion4["V3"] = "0x3";
-    ETransactionVersion4["F0"] = "0x100000000000000000000000000000000";
-    ETransactionVersion4["F1"] = "0x100000000000000000000000000000001";
-    ETransactionVersion4["F2"] = "0x100000000000000000000000000000002";
-    ETransactionVersion4["F3"] = "0x100000000000000000000000000000003";
-    return ETransactionVersion4;
+  var ETransactionVersion = /* @__PURE__ */ ((ETransactionVersion5) => {
+    ETransactionVersion5["V0"] = "0x0";
+    ETransactionVersion5["V1"] = "0x1";
+    ETransactionVersion5["V2"] = "0x2";
+    ETransactionVersion5["V3"] = "0x3";
+    ETransactionVersion5["F0"] = "0x100000000000000000000000000000000";
+    ETransactionVersion5["F1"] = "0x100000000000000000000000000000001";
+    ETransactionVersion5["F2"] = "0x100000000000000000000000000000002";
+    ETransactionVersion5["F3"] = "0x100000000000000000000000000000003";
+    return ETransactionVersion5;
   })(ETransactionVersion || {});
-  var ETransactionVersion2 = /* @__PURE__ */ ((ETransactionVersion23) => {
-    ETransactionVersion23["V0"] = "0x0";
-    ETransactionVersion23["V1"] = "0x1";
-    ETransactionVersion23["V2"] = "0x2";
-    ETransactionVersion23["F0"] = "0x100000000000000000000000000000000";
-    ETransactionVersion23["F1"] = "0x100000000000000000000000000000001";
-    ETransactionVersion23["F2"] = "0x100000000000000000000000000000002";
-    return ETransactionVersion23;
+  var ETransactionVersion2 = /* @__PURE__ */ ((ETransactionVersion24) => {
+    ETransactionVersion24["V0"] = "0x0";
+    ETransactionVersion24["V1"] = "0x1";
+    ETransactionVersion24["V2"] = "0x2";
+    ETransactionVersion24["F0"] = "0x100000000000000000000000000000000";
+    ETransactionVersion24["F1"] = "0x100000000000000000000000000000001";
+    ETransactionVersion24["F2"] = "0x100000000000000000000000000000002";
+    return ETransactionVersion24;
   })(ETransactionVersion2 || {});
-  var ETransactionVersion3 = /* @__PURE__ */ ((ETransactionVersion33) => {
-    ETransactionVersion33["V3"] = "0x3";
-    ETransactionVersion33["F3"] = "0x100000000000000000000000000000003";
-    return ETransactionVersion33;
+  var ETransactionVersion3 = /* @__PURE__ */ ((ETransactionVersion34) => {
+    ETransactionVersion34["V3"] = "0x3";
+    ETransactionVersion34["F3"] = "0x100000000000000000000000000000003";
+    return ETransactionVersion34;
   })(ETransactionVersion3 || {});
 
+  // src/types/api/rpcspec_0_7/index.ts
+  var rpcspec_0_7_exports = {};
+  __export(rpcspec_0_7_exports, {
+    EBlockTag: () => EBlockTag2,
+    EDAMode: () => EDAMode2,
+    EDataAvailabilityMode: () => EDataAvailabilityMode2,
+    ESimulationFlag: () => ESimulationFlag2,
+    ETransactionExecutionStatus: () => ETransactionExecutionStatus2,
+    ETransactionFinalityStatus: () => ETransactionFinalityStatus2,
+    ETransactionStatus: () => ETransactionStatus2,
+    ETransactionType: () => ETransactionType2,
+    ETransactionVersion: () => ETransactionVersion4,
+    ETransactionVersion2: () => ETransactionVersion22,
+    ETransactionVersion3: () => ETransactionVersion32,
+    Errors: () => errors_exports2,
+    SPEC: () => components_exports2
+  });
+
+  // src/types/api/rpcspec_0_7/errors.ts
+  var errors_exports2 = {};
+
+  // src/types/api/rpcspec_0_7/components.ts
+  var components_exports2 = {};
+
+  // src/types/api/rpcspec_0_7/nonspec.ts
+  var ETransactionType2 = /* @__PURE__ */ ((ETransactionType3) => {
+    ETransactionType3["DECLARE"] = "DECLARE";
+    ETransactionType3["DEPLOY"] = "DEPLOY";
+    ETransactionType3["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
+    ETransactionType3["INVOKE"] = "INVOKE";
+    ETransactionType3["L1_HANDLER"] = "L1_HANDLER";
+    return ETransactionType3;
+  })(ETransactionType2 || {});
+  var ESimulationFlag2 = /* @__PURE__ */ ((ESimulationFlag3) => {
+    ESimulationFlag3["SKIP_VALIDATE"] = "SKIP_VALIDATE";
+    ESimulationFlag3["SKIP_FEE_CHARGE"] = "SKIP_FEE_CHARGE";
+    return ESimulationFlag3;
+  })(ESimulationFlag2 || {});
+  var ETransactionStatus2 = /* @__PURE__ */ ((ETransactionStatus3) => {
+    ETransactionStatus3["RECEIVED"] = "RECEIVED";
+    ETransactionStatus3["REJECTED"] = "REJECTED";
+    ETransactionStatus3["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
+    ETransactionStatus3["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
+    return ETransactionStatus3;
+  })(ETransactionStatus2 || {});
+  var ETransactionFinalityStatus2 = /* @__PURE__ */ ((ETransactionFinalityStatus3) => {
+    ETransactionFinalityStatus3["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
+    ETransactionFinalityStatus3["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
+    return ETransactionFinalityStatus3;
+  })(ETransactionFinalityStatus2 || {});
+  var ETransactionExecutionStatus2 = /* @__PURE__ */ ((ETransactionExecutionStatus3) => {
+    ETransactionExecutionStatus3["SUCCEEDED"] = "SUCCEEDED";
+    ETransactionExecutionStatus3["REVERTED"] = "REVERTED";
+    return ETransactionExecutionStatus3;
+  })(ETransactionExecutionStatus2 || {});
+  var EBlockTag2 = /* @__PURE__ */ ((EBlockTag3) => {
+    EBlockTag3["LATEST"] = "latest";
+    EBlockTag3["PENDING"] = "pending";
+    return EBlockTag3;
+  })(EBlockTag2 || {});
+  var EDataAvailabilityMode2 = /* @__PURE__ */ ((EDataAvailabilityMode3) => {
+    EDataAvailabilityMode3["L1"] = "L1";
+    EDataAvailabilityMode3["L2"] = "L2";
+    return EDataAvailabilityMode3;
+  })(EDataAvailabilityMode2 || {});
+  var EDAMode2 = /* @__PURE__ */ ((EDAMode4) => {
+    EDAMode4[EDAMode4["L1"] = 0] = "L1";
+    EDAMode4[EDAMode4["L2"] = 1] = "L2";
+    return EDAMode4;
+  })(EDAMode2 || {});
+  var ETransactionVersion4 = /* @__PURE__ */ ((ETransactionVersion5) => {
+    ETransactionVersion5["V0"] = "0x0";
+    ETransactionVersion5["V1"] = "0x1";
+    ETransactionVersion5["V2"] = "0x2";
+    ETransactionVersion5["V3"] = "0x3";
+    ETransactionVersion5["F0"] = "0x100000000000000000000000000000000";
+    ETransactionVersion5["F1"] = "0x100000000000000000000000000000001";
+    ETransactionVersion5["F2"] = "0x100000000000000000000000000000002";
+    ETransactionVersion5["F3"] = "0x100000000000000000000000000000003";
+    return ETransactionVersion5;
+  })(ETransactionVersion4 || {});
+  var ETransactionVersion22 = /* @__PURE__ */ ((ETransactionVersion24) => {
+    ETransactionVersion24["V0"] = "0x0";
+    ETransactionVersion24["V1"] = "0x1";
+    ETransactionVersion24["V2"] = "0x2";
+    ETransactionVersion24["F0"] = "0x100000000000000000000000000000000";
+    ETransactionVersion24["F1"] = "0x100000000000000000000000000000001";
+    ETransactionVersion24["F2"] = "0x100000000000000000000000000000002";
+    return ETransactionVersion24;
+  })(ETransactionVersion22 || {});
+  var ETransactionVersion32 = /* @__PURE__ */ ((ETransactionVersion34) => {
+    ETransactionVersion34["V3"] = "0x3";
+    ETransactionVersion34["F3"] = "0x100000000000000000000000000000003";
+    return ETransactionVersion34;
+  })(ETransactionVersion32 || {});
+
   // src/utils/encode.ts
   var encode_exports = {};
   __export(encode_exports, {
@@ -13119,11 +13237,11 @@ var starknet = (() => {
     NetworkName2["SN_SEPOLIA"] = "SN_SEPOLIA";
     return NetworkName2;
   })(NetworkName || {});
-  var StarknetChainId = /* @__PURE__ */ ((StarknetChainId5) => {
-    StarknetChainId5["SN_MAIN"] = "0x534e5f4d41494e";
-    StarknetChainId5["SN_GOERLI"] = "0x534e5f474f45524c49";
-    StarknetChainId5["SN_SEPOLIA"] = "0x534e5f5345504f4c4941";
-    return StarknetChainId5;
+  var StarknetChainId = /* @__PURE__ */ ((StarknetChainId6) => {
+    StarknetChainId6["SN_MAIN"] = "0x534e5f4d41494e";
+    StarknetChainId6["SN_GOERLI"] = "0x534e5f474f45524c49";
+    StarknetChainId6["SN_SEPOLIA"] = "0x534e5f5345504f4c4941";
+    return StarknetChainId6;
   })(StarknetChainId || {});
   var TransactionHashPrefix = /* @__PURE__ */ ((TransactionHashPrefix2) => {
     TransactionHashPrefix2["DECLARE"] = "0x6465636c617265";
@@ -13190,6 +13308,12 @@ var starknet = (() => {
     }
   };
 
+  // src/channel/rpc_0_6.ts
+  var rpc_0_6_exports = {};
+  __export(rpc_0_6_exports, {
+    RpcChannel: () => RpcChannel
+  });
+
   // src/types/index.ts
   var types_exports = {};
   __export(types_exports, {
@@ -22881,10 +23005,10 @@ var starknet = (() => {
   function toTransactionVersion(defaultVersion, providedVersion) {
     const providedVersion0xs = providedVersion ? toHex(providedVersion) : void 0;
     const defaultVersion0xs = toHex(defaultVersion);
-    if (providedVersion && !Object.values(ETransactionVersion).includes(providedVersion0xs)) {
+    if (providedVersion && !Object.values(ETransactionVersion4).includes(providedVersion0xs)) {
       throw Error(`providedVersion ${providedVersion} is not ETransactionVersion`);
     }
-    if (!Object.values(ETransactionVersion).includes(defaultVersion0xs)) {
+    if (!Object.values(ETransactionVersion4).includes(defaultVersion0xs)) {
       throw Error(`defaultVersion ${defaultVersion} is not ETransactionVersion`);
     }
     return providedVersion ? providedVersion0xs : defaultVersion0xs;
@@ -23477,9 +23601,9 @@ var starknet = (() => {
       const block_id = new Block(blockIdentifier).identifier;
       const simulationFlags = [];
       if (skipValidate)
-        simulationFlags.push(api_exports.ESimulationFlag.SKIP_VALIDATE);
+        simulationFlags.push(rpcspec_0_6_exports.ESimulationFlag.SKIP_VALIDATE);
       if (skipFeeCharge)
-        simulationFlags.push(api_exports.ESimulationFlag.SKIP_FEE_CHARGE);
+        simulationFlags.push(rpcspec_0_6_exports.ESimulationFlag.SKIP_FEE_CHARGE);
       return this.fetchEndpoint("starknet_simulateTransactions", {
         block_id,
         transactions: invocations.map((it) => this.buildTransaction(it)),
@@ -23493,15 +23617,15 @@ var starknet = (() => {
       let isErrorState = false;
       const retryInterval = options?.retryInterval ?? 5e3;
       const errorStates = options?.errorStates ?? [
-        api_exports.ETransactionStatus.REJECTED
+        rpcspec_0_6_exports.ETransactionStatus.REJECTED
         // TODO: commented out to preserve the long-standing behavior of "reverted" not being treated as an error by default
         // should decide which behavior to keep in the future
         // RPC.ETransactionExecutionStatus.REVERTED,
       ];
       const successStates = options?.successStates ?? [
-        api_exports.ETransactionExecutionStatus.SUCCEEDED,
-        api_exports.ETransactionStatus.ACCEPTED_ON_L2,
-        api_exports.ETransactionStatus.ACCEPTED_ON_L1
+        rpcspec_0_6_exports.ETransactionExecutionStatus.SUCCEEDED,
+        rpcspec_0_6_exports.ETransactionStatus.ACCEPTED_ON_L2,
+        rpcspec_0_6_exports.ETransactionStatus.ACCEPTED_ON_L1
       ];
       let txStatus;
       while (!onchain) {
@@ -23584,9 +23708,9 @@ var starknet = (() => {
     async getEstimateFee(invocations, { blockIdentifier = this.blockIdentifier, skipValidate = true }) {
       const block_id = new Block(blockIdentifier).identifier;
       let flags = {};
-      if (isVersion("0.6", await this.getSpecVersion())) {
+      if (!isVersion("0.5", await this.getSpecVersion())) {
         flags = {
-          simulation_flags: skipValidate ? [api_exports.ESimulationFlag.SKIP_VALIDATE] : []
+          simulation_flags: skipValidate ? [rpcspec_0_6_exports.ESimulationFlag.SKIP_VALIDATE] : []
         };
       }
       return this.fetchEndpoint("starknet_estimateFee", {
@@ -23602,9 +23726,9 @@ var starknet = (() => {
           invoke_transaction: {
             sender_address: functionInvocation.contractAddress,
             calldata: CallData.toHex(functionInvocation.calldata),
-            type: api_exports.ETransactionType.INVOKE,
+            type: rpcspec_0_6_exports.ETransactionType.INVOKE,
             max_fee: toHex(details.maxFee || 0),
-            version: "0x1" /* V1 */,
+            version: rpcspec_0_6_exports.ETransactionVersion.V1,
             signature: signatureToHexArray(functionInvocation.signature),
             nonce: toHex(details.nonce)
           }
@@ -23612,10 +23736,10 @@ var starknet = (() => {
       } else {
         promise = this.fetchEndpoint("starknet_addInvokeTransaction", {
           invoke_transaction: {
-            type: api_exports.ETransactionType.INVOKE,
+            type: rpcspec_0_6_exports.ETransactionType.INVOKE,
             sender_address: functionInvocation.contractAddress,
             calldata: CallData.toHex(functionInvocation.calldata),
-            version: "0x3" /* V3 */,
+            version: rpcspec_0_6_exports.ETransactionVersion.V3,
             signature: signatureToHexArray(functionInvocation.signature),
             nonce: toHex(details.nonce),
             resource_bounds: details.resourceBounds,
@@ -23634,13 +23758,13 @@ var starknet = (() => {
       if (!isSierra(contract) && !isV3Tx(details)) {
         promise = this.fetchEndpoint("starknet_addDeclareTransaction", {
           declare_transaction: {
-            type: api_exports.ETransactionType.DECLARE,
+            type: rpcspec_0_6_exports.ETransactionType.DECLARE,
             contract_class: {
               program: contract.program,
               entry_points_by_type: contract.entry_points_by_type,
               abi: contract.abi
             },
-            version: "0x1" /* V1 */,
+            version: rpcspec_0_6_exports.ETransactionVersion.V1,
             max_fee: toHex(details.maxFee || 0),
             signature: signatureToHexArray(signature),
             sender_address: senderAddress,
@@ -23650,7 +23774,7 @@ var starknet = (() => {
       } else if (isSierra(contract) && !isV3Tx(details)) {
         promise = this.fetchEndpoint("starknet_addDeclareTransaction", {
           declare_transaction: {
-            type: api_exports.ETransactionType.DECLARE,
+            type: rpcspec_0_6_exports.ETransactionType.DECLARE,
             contract_class: {
               sierra_program: decompressProgram(contract.sierra_program),
               contract_class_version: contract.contract_class_version,
@@ -23658,7 +23782,7 @@ var starknet = (() => {
               abi: contract.abi
             },
             compiled_class_hash: compiledClassHash || "",
-            version: "0x2" /* V2 */,
+            version: rpcspec_0_6_exports.ETransactionVersion.V2,
             max_fee: toHex(details.maxFee || 0),
             signature: signatureToHexArray(signature),
             sender_address: senderAddress,
@@ -23668,10 +23792,10 @@ var starknet = (() => {
       } else if (isSierra(contract) && isV3Tx(details)) {
         promise = this.fetchEndpoint("starknet_addDeclareTransaction", {
           declare_transaction: {
-            type: api_exports.ETransactionType.DECLARE,
+            type: rpcspec_0_6_exports.ETransactionType.DECLARE,
             sender_address: senderAddress,
             compiled_class_hash: compiledClassHash || "",
-            version: "0x3" /* V3 */,
+            version: rpcspec_0_6_exports.ETransactionVersion.V3,
             signature: signatureToHexArray(signature),
             nonce: toHex(details.nonce),
             contract_class: {
@@ -23701,9 +23825,9 @@ var starknet = (() => {
             constructor_calldata: CallData.toHex(constructorCalldata || []),
             class_hash: toHex(classHash),
             contract_address_salt: toHex(addressSalt || 0),
-            type: api_exports.ETransactionType.DEPLOY_ACCOUNT,
+            type: rpcspec_0_6_exports.ETransactionType.DEPLOY_ACCOUNT,
             max_fee: toHex(details.maxFee || 0),
-            version: "0x1" /* V1 */,
+            version: rpcspec_0_6_exports.ETransactionVersion.V1,
             signature: signatureToHexArray(signature),
             nonce: toHex(details.nonce)
           }
@@ -23711,8 +23835,8 @@ var starknet = (() => {
       } else {
         promise = this.fetchEndpoint("starknet_addDeployAccountTransaction", {
           deploy_account_transaction: {
-            type: api_exports.ETransactionType.DEPLOY_ACCOUNT,
-            version: "0x3" /* V3 */,
+            type: rpcspec_0_6_exports.ETransactionType.DEPLOY_ACCOUNT,
+            version: rpcspec_0_6_exports.ETransactionVersion.V3,
             signature: signatureToHexArray(signature),
             nonce: toHex(details.nonce),
             contract_address_salt: toHex(addressSalt || 0),
@@ -23795,7 +23919,7 @@ var starknet = (() => {
       if (invocation.type === "INVOKE_FUNCTION" /* INVOKE */) {
         return {
           // v0 v1 v3
-          type: api_exports.ETransactionType.INVOKE,
+          type: rpcspec_0_6_exports.ETransactionType.INVOKE,
           // TODO: Diff between sequencer and rpc invoke type
           sender_address: invocation.contractAddress,
           calldata: CallData.toHex(invocation.calldata),
@@ -23841,106 +23965,645 @@ var starknet = (() => {
     }
   };
 
-  // src/utils/responseParser/rpc.ts
-  var RPCResponseParser = class {
-    parseGetBlockResponse(res) {
-      return { status: "PENDING", ...res };
-    }
-    parseTransactionReceipt(res) {
-      if ("actual_fee" in res && typeof res.actual_fee === "string") {
-        return {
-          ...res,
-          actual_fee: {
-            amount: res.actual_fee,
-            unit: "FRI"
-          }
-        };
+  // src/channel/rpc_0_7.ts
+  var rpc_0_7_exports = {};
+  __export(rpc_0_7_exports, {
+    RpcChannel: () => RpcChannel2
+  });
+  var defaultOptions2 = {
+    headers: { "Content-Type": "application/json" },
+    blockIdentifier: "pending" /* pending */,
+    retries: 200
+  };
+  var RpcChannel2 = class {
+    nodeUrl;
+    headers;
+    retries;
+    requestId;
+    blockIdentifier;
+    chainId;
+    speckVersion;
+    waitMode;
+    // behave like web2 rpc and return when tx is processed
+    constructor(optionsOrProvider) {
+      const { nodeUrl, retries, headers, blockIdentifier, chainId, waitMode } = 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);
       }
-      return res;
+      this.retries = retries || defaultOptions2.retries;
+      this.headers = { ...defaultOptions2.headers, ...headers };
+      this.blockIdentifier = blockIdentifier || defaultOptions2.blockIdentifier;
+      this.chainId = chainId;
+      this.waitMode = waitMode || false;
+      this.requestId = 0;
     }
-    parseFeeEstimateResponse(res) {
-      const val = res[0];
-      return {
-        overall_fee: toBigInt(val.overall_fee),
-        gas_consumed: toBigInt(val.gas_consumed),
-        gas_price: toBigInt(val.gas_price),
-        unit: val.unit,
-        suggestedMaxFee: estimatedFeeToMaxFee(val.overall_fee),
-        resourceBounds: estimateFeeToBounds(val)
+    fetch(method, params, id = 0) {
+      const rpcRequestBody = {
+        id,
+        jsonrpc: "2.0",
+        method,
+        ...params && { params }
       };
-    }
-    parseFeeEstimateBulkResponse(res) {
-      return res.map((val) => ({
-        overall_fee: toBigInt(val.overall_fee),
-        gas_consumed: toBigInt(val.gas_consumed),
-        gas_price: toBigInt(val.gas_price),
-        unit: val.unit,
-        suggestedMaxFee: estimatedFeeToMaxFee(val.overall_fee),
-        resourceBounds: estimateFeeToBounds(val)
-      }));
-    }
-    parseSimulateTransactionResponse(res) {
-      return res.map((it) => {
-        return {
-          ...it,
-          suggestedMaxFee: estimatedFeeToMaxFee(BigInt(it.fee_estimation.overall_fee)),
-          resourceBounds: estimateFeeToBounds(it.fee_estimation)
-        };
+      return fetchPonyfill_default(this.nodeUrl, {
+        method: "POST",
+        body: stringify2(rpcRequestBody),
+        headers: this.headers
       });
     }
-    parseContractClassResponse(res) {
-      return {
-        ...res,
-        abi: typeof res.abi === "string" ? JSON.parse(res.abi) : res.abi
-      };
-    }
-  };
-
-  // src/provider/rpc.ts
-  var RpcProvider = class {
-    responseParser = new RPCResponseParser();
-    channel;
-    constructor(optionsOrProvider) {
-      if (optionsOrProvider && "channel" in optionsOrProvider) {
-        this.channel = optionsOrProvider.channel;
-      } else {
-        this.channel = new RpcChannel({ ...optionsOrProvider, waitMode: false });
+    errorHandler(method, params, rpcError, otherError) {
+      if (rpcError) {
+        const { code, message, data } = rpcError;
+        throw new LibraryError(
+          `RPC: ${method} with params ${stringify2(params, null, 2)}
+ 
+        ${code}: ${message}: ${stringify2(data)}`
+        );
+      }
+      if (otherError instanceof LibraryError) {
+        throw otherError;
+      }
+      if (otherError) {
+        throw Error(otherError.message);
       }
     }
-    fetch(method, params, id = 0) {
-      return this.channel.fetch(method, params, id);
+    async fetchEndpoint(method, params) {
+      try {
+        const rawResult = await this.fetch(method, params, this.requestId += 1);
+        const { error: error2, result } = await rawResult.json();
+        this.errorHandler(method, params, error2);
+        return result;
+      } catch (error2) {
+        this.errorHandler(method, params, error2?.response?.data, error2);
+        throw error2;
+      }
     }
     async getChainId() {
-      return this.channel.getChainId();
+      this.chainId ??= await this.fetchEndpoint("starknet_chainId");
+      return this.chainId;
     }
     async getSpecVersion() {
-      return this.channel.getSpecVersion();
-    }
-    async getNonceForAddress(contractAddress, blockIdentifier) {
-      return this.channel.getNonceForAddress(contractAddress, blockIdentifier);
+      this.speckVersion ??= await this.fetchEndpoint("starknet_specVersion");
+      return this.speckVersion;
     }
-    async getBlock(blockIdentifier) {
-      return this.channel.getBlockWithTxHashes(blockIdentifier).then(this.responseParser.parseGetBlockResponse);
+    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
+      });
     }
     /**
      * Get the most recent accepted block hash and number
      */
-    async getBlockLatestAccepted() {
-      return this.channel.getBlockLatestAccepted();
+    getBlockLatestAccepted() {
+      return this.fetchEndpoint("starknet_blockHashAndNumber");
     }
     /**
      * Get the most recent accepted block number
      * redundant use getBlockLatestAccepted();
      * @returns Number of the latest block
      */
-    async getBlockNumber() {
-      return this.channel.getBlockNumber();
+    getBlockNumber() {
+      return this.fetchEndpoint("starknet_blockNumber");
     }
-    async getBlockWithTxHashes(blockIdentifier) {
-      return this.channel.getBlockWithTxHashes(blockIdentifier);
+    getBlockWithTxHashes(blockIdentifier = this.blockIdentifier) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getBlockWithTxHashes", { block_id });
     }
-    async getBlockWithTxs(blockIdentifier) {
-      return this.channel.getBlockWithTxs(blockIdentifier);
+    getBlockWithTxs(blockIdentifier = this.blockIdentifier) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getBlockWithTxs", { block_id });
+    }
+    getBlockWithReceipts(blockIdentifier = this.blockIdentifier) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getBlockWithReceipts", { block_id });
+    }
+    getBlockStateUpdate(blockIdentifier = this.blockIdentifier) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getStateUpdate", { block_id });
+    }
+    getBlockTransactionsTraces(blockIdentifier = this.blockIdentifier) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_traceBlockTransactions", { block_id });
+    }
+    getBlockTransactionCount(blockIdentifier = this.blockIdentifier) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getBlockTransactionCount", { block_id });
+    }
+    getTransactionByHash(txHash) {
+      const transaction_hash = toHex(txHash);
+      return this.fetchEndpoint("starknet_getTransactionByHash", {
+        transaction_hash
+      });
+    }
+    getTransactionByBlockIdAndIndex(blockIdentifier, index) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getTransactionByBlockIdAndIndex", { block_id, index });
+    }
+    getTransactionReceipt(txHash) {
+      const transaction_hash = toHex(txHash);
+      return this.fetchEndpoint("starknet_getTransactionReceipt", { transaction_hash });
+    }
+    getTransactionTrace(txHash) {
+      const transaction_hash = toHex(txHash);
+      return this.fetchEndpoint("starknet_traceTransaction", { transaction_hash });
+    }
+    /**
+     * Get the status of a transaction
+     */
+    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/>
+     */
+    simulateTransaction(invocations, {
+      blockIdentifier = this.blockIdentifier,
+      skipValidate = true,
+      skipFeeCharge = true
+    } = {}) {
+      const block_id = new Block(blockIdentifier).identifier;
+      const simulationFlags = [];
+      if (skipValidate)
+        simulationFlags.push(rpcspec_0_7_exports.ESimulationFlag.SKIP_VALIDATE);
+      if (skipFeeCharge)
+        simulationFlags.push(rpcspec_0_7_exports.ESimulationFlag.SKIP_FEE_CHARGE);
+      return this.fetchEndpoint("starknet_simulateTransactions", {
+        block_id,
+        transactions: invocations.map((it) => this.buildTransaction(it)),
+        simulation_flags: simulationFlags
+      });
+    }
+    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 ?? [
+        rpcspec_0_7_exports.ETransactionStatus.REJECTED
+        // TODO: commented out to preserve the long-standing behavior of "reverted" not being treated as an error by default
+        // should decide which behavior to keep in the future
+        // RPC.ETransactionExecutionStatus.REVERTED,
+      ];
+      const successStates = options?.successStates ?? [
+        rpcspec_0_7_exports.ETransactionExecutionStatus.SUCCEEDED,
+        rpcspec_0_7_exports.ETransactionStatus.ACCEPTED_ON_L2,
+        rpcspec_0_7_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 error2 = new Error("waiting for transaction status");
+            throw error2;
+          }
+          if (errorStates.includes(executionStatus) || errorStates.includes(finalityStatus)) {
+            const message = `${executionStatus}: ${finalityStatus}`;
+            const error2 = new Error(message);
+            error2.response = txStatus;
+            isErrorState = true;
+            throw error2;
+          } else if (successStates.includes(executionStatus) || successStates.includes(finalityStatus)) {
+            onchain = true;
+          }
+        } catch (error2) {
+          if (error2 instanceof Error && isErrorState) {
+            throw error2;
+          }
+          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 (error2) {
+          if (retries <= 0) {
+            throw new Error(`waitForTransaction timed-out with retries ${this.retries}`);
+          }
+        }
+        retries -= 1;
+        await wait(retryInterval);
+      }
+      return txReceipt;
+    }
+    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,
+        key: parsedKey,
+        block_id
+      });
+    }
+    getClassHashAt(contractAddress, blockIdentifier = this.blockIdentifier) {
+      const contract_address = toHex(contractAddress);
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getClassHashAt", {
+        block_id,
+        contract_address
+      });
+    }
+    getClass(classHash, blockIdentifier = this.blockIdentifier) {
+      const class_hash = toHex(classHash);
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getClass", {
+        class_hash,
+        block_id
+      });
+    }
+    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
+      });
+    }
+    async getEstimateFee(invocations, { blockIdentifier = this.blockIdentifier, skipValidate = true }) {
+      const block_id = new Block(blockIdentifier).identifier;
+      let flags = {};
+      if (!isVersion("0.5", await this.getSpecVersion())) {
+        flags = {
+          simulation_flags: skipValidate ? [rpcspec_0_7_exports.ESimulationFlag.SKIP_VALIDATE] : []
+        };
+      }
+      return this.fetchEndpoint("starknet_estimateFee", {
+        request: invocations.map((it) => this.buildTransaction(it, "fee")),
+        block_id,
+        ...flags
+      });
+    }
+    async invoke(functionInvocation, details) {
+      let promise;
+      if (!isV3Tx(details)) {
+        promise = this.fetchEndpoint("starknet_addInvokeTransaction", {
+          invoke_transaction: {
+            sender_address: functionInvocation.contractAddress,
+            calldata: CallData.toHex(functionInvocation.calldata),
+            type: rpcspec_0_7_exports.ETransactionType.INVOKE,
+            max_fee: toHex(details.maxFee || 0),
+            version: rpcspec_0_7_exports.ETransactionVersion.V1,
+            signature: signatureToHexArray(functionInvocation.signature),
+            nonce: toHex(details.nonce)
+          }
+        });
+      } else {
+        promise = this.fetchEndpoint("starknet_addInvokeTransaction", {
+          invoke_transaction: {
+            type: rpcspec_0_7_exports.ETransactionType.INVOKE,
+            sender_address: functionInvocation.contractAddress,
+            calldata: CallData.toHex(functionInvocation.calldata),
+            version: rpcspec_0_7_exports.ETransactionVersion.V3,
+            signature: signatureToHexArray(functionInvocation.signature),
+            nonce: toHex(details.nonce),
+            resource_bounds: details.resourceBounds,
+            tip: toHex(details.tip),
+            paymaster_data: details.paymasterData.map((it) => toHex(it)),
+            account_deployment_data: details.accountDeploymentData.map((it) => toHex(it)),
+            nonce_data_availability_mode: details.nonceDataAvailabilityMode,
+            fee_data_availability_mode: details.feeDataAvailabilityMode
+          }
+        });
+      }
+      return this.waitMode ? this.waitForTransaction((await promise).transaction_hash) : promise;
+    }
+    async declare({ contract, signature, senderAddress, compiledClassHash }, details) {
+      let promise;
+      if (!isSierra(contract) && !isV3Tx(details)) {
+        promise = this.fetchEndpoint("starknet_addDeclareTransaction", {
+          declare_transaction: {
+            type: rpcspec_0_7_exports.ETransactionType.DECLARE,
+            contract_class: {
+              program: contract.program,
+              entry_points_by_type: contract.entry_points_by_type,
+              abi: contract.abi
+            },
+            version: rpcspec_0_7_exports.ETransactionVersion.V1,
+            max_fee: toHex(details.maxFee || 0),
+            signature: signatureToHexArray(signature),
+            sender_address: senderAddress,
+            nonce: toHex(details.nonce)
+          }
+        });
+      } else if (isSierra(contract) && !isV3Tx(details)) {
+        promise = this.fetchEndpoint("starknet_addDeclareTransaction", {
+          declare_transaction: {
+            type: rpcspec_0_7_exports.ETransactionType.DECLARE,
+            contract_class: {
+              sierra_program: decompressProgram(contract.sierra_program),
+              contract_class_version: contract.contract_class_version,
+              entry_points_by_type: contract.entry_points_by_type,
+              abi: contract.abi
+            },
+            compiled_class_hash: compiledClassHash || "",
+            version: rpcspec_0_7_exports.ETransactionVersion.V2,
+            max_fee: toHex(details.maxFee || 0),
+            signature: signatureToHexArray(signature),
+            sender_address: senderAddress,
+            nonce: toHex(details.nonce)
+          }
+        });
+      } else if (isSierra(contract) && isV3Tx(details)) {
+        promise = this.fetchEndpoint("starknet_addDeclareTransaction", {
+          declare_transaction: {
+            type: rpcspec_0_7_exports.ETransactionType.DECLARE,
+            sender_address: senderAddress,
+            compiled_class_hash: compiledClassHash || "",
+            version: rpcspec_0_7_exports.ETransactionVersion.V3,
+            signature: signatureToHexArray(signature),
+            nonce: toHex(details.nonce),
+            contract_class: {
+              sierra_program: decompressProgram(contract.sierra_program),
+              contract_class_version: contract.contract_class_version,
+              entry_points_by_type: contract.entry_points_by_type,
+              abi: contract.abi
+            },
+            resource_bounds: details.resourceBounds,
+            tip: toHex(details.tip),
+            paymaster_data: details.paymasterData.map((it) => toHex(it)),
+            account_deployment_data: details.accountDeploymentData.map((it) => toHex(it)),
+            nonce_data_availability_mode: details.nonceDataAvailabilityMode,
+            fee_data_availability_mode: details.feeDataAvailabilityMode
+          }
+        });
+      } else {
+        throw Error("declare unspotted parameters");
+      }
+      return this.waitMode ? this.waitForTransaction((await promise).transaction_hash) : promise;
+    }
+    async deployAccount({ classHash, constructorCalldata, addressSalt, signature }, details) {
+      let promise;
+      if (!isV3Tx(details)) {
+        promise = this.fetchEndpoint("starknet_addDeployAccountTransaction", {
+          deploy_account_transaction: {
+            constructor_calldata: CallData.toHex(constructorCalldata || []),
+            class_hash: toHex(classHash),
+            contract_address_salt: toHex(addressSalt || 0),
+            type: rpcspec_0_7_exports.ETransactionType.DEPLOY_ACCOUNT,
+            max_fee: toHex(details.maxFee || 0),
+            version: rpcspec_0_7_exports.ETransactionVersion.V1,
+            signature: signatureToHexArray(signature),
+            nonce: toHex(details.nonce)
+          }
+        });
+      } else {
+        promise = this.fetchEndpoint("starknet_addDeployAccountTransaction", {
+          deploy_account_transaction: {
+            type: rpcspec_0_7_exports.ETransactionType.DEPLOY_ACCOUNT,
+            version: rpcspec_0_7_exports.ETransactionVersion.V3,
+            signature: signatureToHexArray(signature),
+            nonce: toHex(details.nonce),
+            contract_address_salt: toHex(addressSalt || 0),
+            constructor_calldata: CallData.toHex(constructorCalldata || []),
+            class_hash: toHex(classHash),
+            resource_bounds: details.resourceBounds,
+            tip: toHex(details.tip),
+            paymaster_data: details.paymasterData.map((it) => toHex(it)),
+            nonce_data_availability_mode: details.nonceDataAvailabilityMode,
+            fee_data_availability_mode: details.feeDataAvailabilityMode
+          }
+        });
+      }
+      return this.waitMode ? this.waitForTransaction((await promise).transaction_hash) : promise;
+    }
+    callContract(call, blockIdentifier = this.blockIdentifier) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_call", {
+        request: {
+          contract_address: call.contractAddress,
+          entry_point_selector: getSelectorFromName(call.entrypoint),
+          calldata: CallData.toHex(call.calldata)
+        },
+        block_id
+      });
+    }
+    /**
+     * NEW: Estimate the fee for a message from L1
+     * @param message Message From L1
+     */
+    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_estimateMessageFee", {
+        message: formattedMessage,
+        block_id
+      });
+    }
+    /**
+     * Returns an object about the sync status, or false if the node is not synching
+     * @returns Object with the stats data
+     */
+    getSyncingStats() {
+      return this.fetchEndpoint("starknet_syncing");
+    }
+    /**
+     * Returns all events matching the given filter
+     * @returns events and the pagination of the events
+     */
+    getEvents(eventFilter) {
+      return this.fetchEndpoint("starknet_getEvents", { filter: eventFilter });
+    }
+    buildTransaction(invocation, versionType) {
+      const defaultVersions = getVersionsByType(versionType);
+      let details;
+      if (!isV3Tx(invocation)) {
+        details = {
+          signature: signatureToHexArray(invocation.signature),
+          nonce: toHex(invocation.nonce),
+          max_fee: toHex(invocation.maxFee || 0)
+        };
+      } else {
+        details = {
+          signature: signatureToHexArray(invocation.signature),
+          nonce: toHex(invocation.nonce),
+          resource_bounds: invocation.resourceBounds,
+          tip: toHex(invocation.tip),
+          paymaster_data: invocation.paymasterData.map((it) => toHex(it)),
+          nonce_data_availability_mode: invocation.nonceDataAvailabilityMode,
+          fee_data_availability_mode: invocation.feeDataAvailabilityMode,
+          account_deployment_data: invocation.accountDeploymentData.map((it) => toHex(it))
+        };
+      }
+      if (invocation.type === "INVOKE_FUNCTION" /* INVOKE */) {
+        return {
+          // v0 v1 v3
+          type: rpcspec_0_7_exports.ETransactionType.INVOKE,
+          // TODO: Diff between sequencer and rpc invoke type
+          sender_address: invocation.contractAddress,
+          calldata: CallData.toHex(invocation.calldata),
+          version: toHex(invocation.version || defaultVersions.v3),
+          ...details
+        };
+      }
+      if (invocation.type === "DECLARE" /* DECLARE */) {
+        if (!isSierra(invocation.contract)) {
+          return {
+            type: invocation.type,
+            contract_class: invocation.contract,
+            sender_address: invocation.senderAddress,
+            version: toHex(invocation.version || defaultVersions.v1),
+            ...details
+          };
+        }
+        return {
+          // Cairo 1 - v2 v3
+          type: invocation.type,
+          contract_class: {
+            ...invocation.contract,
+            sierra_program: decompressProgram(invocation.contract.sierra_program)
+          },
+          compiled_class_hash: invocation.compiledClassHash || "",
+          sender_address: invocation.senderAddress,
+          version: toHex(invocation.version || defaultVersions.v3),
+          ...details
+        };
+      }
+      if (invocation.type === "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */) {
+        const { account_deployment_data, ...restDetails } = details;
+        return {
+          type: invocation.type,
+          constructor_calldata: CallData.toHex(invocation.constructorCalldata || []),
+          class_hash: toHex(invocation.classHash),
+          contract_address_salt: toHex(invocation.addressSalt || 0),
+          version: toHex(invocation.version || defaultVersions.v3),
+          ...restDetails
+        };
+      }
+      throw Error("RPC buildTransaction received unknown TransactionType");
+    }
+  };
+
+  // src/utils/responseParser/rpc.ts
+  var RPCResponseParser = class {
+    parseGetBlockResponse(res) {
+      return { status: "PENDING", ...res };
+    }
+    parseTransactionReceipt(res) {
+      if ("actual_fee" in res && typeof res.actual_fee === "string") {
+        return {
+          ...res,
+          actual_fee: {
+            amount: res.actual_fee,
+            unit: "FRI"
+          }
+        };
+      }
+      return res;
+    }
+    parseFeeEstimateResponse(res) {
+      const val = res[0];
+      return {
+        overall_fee: toBigInt(val.overall_fee),
+        gas_consumed: toBigInt(val.gas_consumed),
+        gas_price: toBigInt(val.gas_price),
+        unit: val.unit,
+        suggestedMaxFee: estimatedFeeToMaxFee(val.overall_fee),
+        resourceBounds: estimateFeeToBounds(val)
+      };
+    }
+    parseFeeEstimateBulkResponse(res) {
+      return res.map((val) => ({
+        overall_fee: toBigInt(val.overall_fee),
+        gas_consumed: toBigInt(val.gas_consumed),
+        gas_price: toBigInt(val.gas_price),
+        unit: val.unit,
+        suggestedMaxFee: estimatedFeeToMaxFee(val.overall_fee),
+        resourceBounds: estimateFeeToBounds(val)
+      }));
+    }
+    parseSimulateTransactionResponse(res) {
+      return res.map((it) => {
+        return {
+          ...it,
+          suggestedMaxFee: estimatedFeeToMaxFee(BigInt(it.fee_estimation.overall_fee)),
+          resourceBounds: estimateFeeToBounds(it.fee_estimation)
+        };
+      });
+    }
+    parseContractClassResponse(res) {
+      return {
+        ...res,
+        abi: typeof res.abi === "string" ? JSON.parse(res.abi) : res.abi
+      };
+    }
+  };
+
+  // src/provider/rpc.ts
+  var RpcProvider = class {
+    responseParser = new RPCResponseParser();
+    channel;
+    constructor(optionsOrProvider) {
+      if (optionsOrProvider && "channel" in optionsOrProvider) {
+        this.channel = optionsOrProvider.channel;
+      } else {
+        this.channel = new RpcChannel2({ ...optionsOrProvider, waitMode: false });
+      }
+    }
+    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);
+    }
+    async getBlockWithReceipts(blockIdentifier) {
+      if (this.channel instanceof rpc_0_6_exports.RpcChannel)
+        throw new LibraryError("Unsupported method for RPC version");
+      return this.channel.getBlockWithReceipts(blockIdentifier);
     }
     getStateUpdate = this.getBlockStateUpdate;
     async getBlockStateUpdate(blockIdentifier) {
@@ -24879,7 +25542,7 @@ var starknet = (() => {
     async signTransaction(transactions, details) {
       const compiledCalldata = getExecuteCalldata(transactions, details.cairoVersion);
       let msgHash;
-      if (Object.values(ETransactionVersion2).includes(details.version)) {
+      if (Object.values(ETransactionVersion22).includes(details.version)) {
         const det = details;
         msgHash = calculateInvokeTransactionHash2({
           ...det,
@@ -24887,7 +25550,7 @@ var starknet = (() => {
           compiledCalldata,
           version: det.version
         });
-      } else if (Object.values(ETransactionVersion3).includes(details.version)) {
+      } else if (Object.values(ETransactionVersion32).includes(details.version)) {
         const det = details;
         msgHash = calculateInvokeTransactionHash2({
           ...det,
@@ -24905,7 +25568,7 @@ var starknet = (() => {
     async signDeployAccountTransaction(details) {
       const compiledConstructorCalldata = CallData.compile(details.constructorCalldata);
       let msgHash;
-      if (Object.values(ETransactionVersion2).includes(details.version)) {
+      if (Object.values(ETransactionVersion22).includes(details.version)) {
         const det = details;
         msgHash = calculateDeployAccountTransactionHash3({
           ...det,
@@ -24913,7 +25576,7 @@ var starknet = (() => {
           constructorCalldata: compiledConstructorCalldata,
           version: det.version
         });
-      } else if (Object.values(ETransactionVersion3).includes(details.version)) {
+      } else if (Object.values(ETransactionVersion32).includes(details.version)) {
         const det = details;
         msgHash = calculateDeployAccountTransactionHash3({
           ...det,
@@ -24930,13 +25593,13 @@ var starknet = (() => {
     }
     async signDeclareTransaction(details) {
       let msgHash;
-      if (Object.values(ETransactionVersion2).includes(details.version)) {
+      if (Object.values(ETransactionVersion22).includes(details.version)) {
         const det = details;
         msgHash = calculateDeclareTransactionHash3({
           ...det,
           version: det.version
         });
-      } else if (Object.values(ETransactionVersion3).includes(details.version)) {
+      } else if (Object.values(ETransactionVersion32).includes(details.version)) {
         const det = details;
         msgHash = calculateDeclareTransactionHash3({
           ...det,
@@ -25060,7 +25723,7 @@ var starknet = (() => {
     async signTransaction(transactions, details) {
       const compiledCalldata = getExecuteCalldata(transactions, details.cairoVersion);
       let msgHash;
-      if (Object.values(ETransactionVersion2).includes(details.version)) {
+      if (Object.values(ETransactionVersion22).includes(details.version)) {
         const det = details;
         msgHash = calculateInvokeTransactionHash2({
           ...det,
@@ -25068,7 +25731,7 @@ var starknet = (() => {
           compiledCalldata,
           version: det.version
         });
-      } else if (Object.values(ETransactionVersion3).includes(details.version)) {
+      } else if (Object.values(ETransactionVersion32).includes(details.version)) {
         const det = details;
         msgHash = calculateInvokeTransactionHash2({
           ...det,
@@ -25086,7 +25749,7 @@ var starknet = (() => {
     async signDeployAccountTransaction(details) {
       const compiledConstructorCalldata = CallData.compile(details.constructorCalldata);
       let msgHash;
-      if (Object.values(ETransactionVersion2).includes(details.version)) {
+      if (Object.values(ETransactionVersion22).includes(details.version)) {
         const det = details;
         msgHash = calculateDeployAccountTransactionHash3({
           ...det,
@@ -25094,7 +25757,7 @@ var starknet = (() => {
           constructorCalldata: compiledConstructorCalldata,
           version: det.version
         });
-      } else if (Object.values(ETransactionVersion3).includes(details.version)) {
+      } else if (Object.values(ETransactionVersion32).includes(details.version)) {
         const det = details;
         msgHash = calculateDeployAccountTransactionHash3({
           ...det,
@@ -25111,13 +25774,13 @@ var starknet = (() => {
     }
     async signDeclareTransaction(details) {
       let msgHash;
-      if (Object.values(ETransactionVersion2).includes(details.version)) {
+      if (Object.values(ETransactionVersion22).includes(details.version)) {
         const det = details;
         msgHash = calculateDeclareTransactionHash3({
           ...det,
           version: det.version
         });
-      } else if (Object.values(ETransactionVersion3).includes(details.version)) {
+      } else if (Object.values(ETransactionVersion32).includes(details.version)) {
         const det = details;
         msgHash = calculateDeclareTransactionHash3({
           ...det,