starknet 6.1.5 → 6.2.0

package/dist/index.js

@@ -53,7 +53,9 @@ __export(src_exports, {
   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,
@@ -120,7 +122,7 @@ __export(constants_exports, {
   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
@@ -129,6 +131,30 @@ __export(constants_exports, {
 // 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,
@@ -141,13 +167,9 @@ __export(api_exports, {
   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 = {};
 
@@ -155,77 +177,173 @@ var errors_exports = {};
 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, {
@@ -320,11 +438,11 @@ var NetworkName = /* @__PURE__ */ ((NetworkName2) => {
   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";
@@ -391,6 +509,12 @@ var HttpError = class extends LibraryError {
   }
 };
 
+// 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, {
@@ -2825,10 +2949,10 @@ function intDAM(dam) {
 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;
@@ -3262,9 +3386,9 @@ var RpcChannel = class {
     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)),
@@ -3278,15 +3402,15 @@ var RpcChannel = class {
     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) {
@@ -3369,9 +3493,9 @@ var RpcChannel = class {
   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", {
@@ -3387,9 +3511,9 @@ var RpcChannel = class {
         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)
         }
@@ -3397,10 +3521,10 @@ var RpcChannel = class {
     } 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,
@@ -3419,13 +3543,13 @@ var RpcChannel = class {
     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,
@@ -3435,7 +3559,7 @@ var RpcChannel = class {
     } 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,
@@ -3443,7 +3567,7 @@ var RpcChannel = class {
             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,
@@ -3453,10 +3577,10 @@ var RpcChannel = class {
     } 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: {
@@ -3486,9 +3610,9 @@ var RpcChannel = class {
           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)
         }
@@ -3496,8 +3620,8 @@ var RpcChannel = class {
     } 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),
@@ -3580,7 +3704,7 @@ var RpcChannel = class {
     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),
@@ -3626,106 +3750,645 @@ var RpcChannel = class {
   }
 };
 
-// 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, result } = await rawResult.json();
+      this.errorHandler(method, params, error);
+      return result;
+    } catch (error) {
+      this.errorHandler(method, params, error?.response?.data, error);
+      throw error;
+    }
   }
   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 error = new Error("waiting for transaction status");
+          throw error;
+        }
+        if (errorStates.includes(executionStatus) || errorStates.includes(finalityStatus)) {
+          const message = `${executionStatus}: ${finalityStatus}`;
+          const error = new Error(message);
+          error.response = txStatus;
+          isErrorState = true;
+          throw error;
+        } else if (successStates.includes(executionStatus) || successStates.includes(finalityStatus)) {
+          onchain = true;
+        }
+      } 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;
+  }
+  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) {
@@ -4443,7 +5106,7 @@ var Signer = class {
   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,
@@ -4451,7 +5114,7 @@ var Signer = class {
         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,
@@ -4469,7 +5132,7 @@ var Signer = class {
   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,
@@ -4477,7 +5140,7 @@ var Signer = class {
         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,
@@ -4494,13 +5157,13 @@ var Signer = class {
   }
   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,
@@ -4548,7 +5211,7 @@ var EthSigner = class {
   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,
@@ -4556,7 +5219,7 @@ var EthSigner = class {
         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,
@@ -4574,7 +5237,7 @@ var EthSigner = class {
   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,
@@ -4582,7 +5245,7 @@ var EthSigner = class {
         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,
@@ -4599,13 +5262,13 @@ var EthSigner = class {
   }
   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,
@@ -5755,6 +6418,8 @@ var number = num_exports;
   Provider,
   ProviderInterface,
   RPC,
+  RPC06,
+  RPC07,
   RpcChannel,
   RpcProvider,
   SIMULATION_FLAG,