starknet 10.7.0 → 11.0.0-beta.1

package/dist/index.mjs

@@ -609,115 +609,13 @@ ${JSON.stringify(data, null, 2)}`;
 };
 var logger = Logger.getInstance();
 
-// src/channel/rpc_0_9_0.ts
-var rpc_0_9_0_exports = {};
-__export(rpc_0_9_0_exports, {
-  RpcChannel: () => RpcChannel
+// src/channel/v0_9/index.ts
+var v0_9_exports = {};
+__export(v0_9_exports, {
+  RpcChannel: () => RpcChannel,
+  SubscriptionChannel: () => SubscriptionChannel2
 });
 
-// src/types/lib/contract/index.ts
-var EntryPointType = {
-  EXTERNAL: "EXTERNAL",
-  L1_HANDLER: "L1_HANDLER",
-  CONSTRUCTOR: "CONSTRUCTOR"
-};
-
-// src/types/calldata.ts
-var ValidateType = {
-  DEPLOY: "DEPLOY",
-  CALL: "CALL",
-  INVOKE: "INVOKE"
-};
-var Uint = {
-  u8: "core::integer::u8",
-  u16: "core::integer::u16",
-  u32: "core::integer::u32",
-  u64: "core::integer::u64",
-  u96: "core::integer::u96",
-  u128: "core::integer::u128",
-  u256: "core::integer::u256",
-  // This one is struct
-  u512: "core::integer::u512"
-  // This one is struct
-};
-var Int = {
-  i8: "core::integer::i8",
-  i16: "core::integer::i16",
-  i32: "core::integer::i32",
-  i64: "core::integer::i64",
-  i128: "core::integer::i128"
-};
-var Literal = {
-  ClassHash: "core::starknet::class_hash::ClassHash",
-  ContractAddress: "core::starknet::contract_address::ContractAddress",
-  Secp256k1Point: "core::starknet::secp256k1::Secp256k1Point",
-  U96: "core::internal::bounded_int::BoundedInt::<0, 79228162514264337593543950335>"
-};
-var ETH_ADDRESS = "core::starknet::eth_address::EthAddress";
-var NON_ZERO_PREFIX = "core::zeroable::NonZero::";
-
-// src/contract/types/index.type.ts
-function isAccount(providerOrAccount) {
-  return "execute" in providerOrAccount;
-}
-
-// src/types/outsideExecution.ts
-var OutsideExecutionTypesV1 = {
-  StarkNetDomain: [
-    { name: "name", type: "felt" },
-    { name: "version", type: "felt" },
-    { name: "chainId", type: "felt" }
-  ],
-  OutsideExecution: [
-    { name: "caller", type: "felt" },
-    { name: "nonce", type: "felt" },
-    { name: "execute_after", type: "felt" },
-    { name: "execute_before", type: "felt" },
-    { name: "calls_len", type: "felt" },
-    { name: "calls", type: "OutsideCall*" }
-  ],
-  OutsideCall: [
-    { name: "to", type: "felt" },
-    { name: "selector", type: "felt" },
-    { name: "calldata_len", type: "felt" },
-    { name: "calldata", type: "felt*" }
-  ]
-};
-var OutsideExecutionTypesV2 = {
-  StarknetDomain: [
-    // SNIP-12 revision 1 is used, so should be "StarknetDomain", not "StarkNetDomain"
-    { name: "name", type: "shortstring" },
-    { name: "version", type: "shortstring" },
-    // set to 2 in v2
-    { name: "chainId", type: "shortstring" },
-    { name: "revision", type: "shortstring" }
-  ],
-  OutsideExecution: [
-    { name: "Caller", type: "ContractAddress" },
-    { name: "Nonce", type: "felt" },
-    { name: "Execute After", type: "u128" },
-    { name: "Execute Before", type: "u128" },
-    { name: "Calls", type: "Call*" }
-  ],
-  Call: [
-    { name: "To", type: "ContractAddress" },
-    { name: "Selector", type: "selector" },
-    { name: "Calldata", type: "felt*" }
-  ]
-};
-var OutsideExecutionVersion = {
-  UNSUPPORTED: "0",
-  V1: "1",
-  V2: "2"
-};
-
-// src/utils/assert.ts
-function assert(condition, message) {
-  if (!condition) {
-    throw new Error(message || "Assertion failure");
-  }
-}
-
 // src/utils/json.ts
 var json_exports = {};
 __export(json_exports, {
@@ -735,87 +633,114 @@ var parse2 = (str) => json.parse(String(str), void 0, parseIntAsNumberOrBigInt);
 var parseAlwaysAsBig = (str) => json.parse(String(str), void 0, json.parseNumberAndBigInt);
 var stringify2 = (value, replacer, space, numberStringifiers) => json.stringify(value, replacer, space, numberStringifiers);
 
-// src/utils/batch/index.ts
-var BatchClient = class {
-  nodeUrl;
-  headers;
-  interval;
-  requestId = 0;
-  pendingRequests = {};
-  batchPromises = {};
-  delayTimer;
-  delayPromise;
-  delayPromiseResolve;
-  baseFetch;
-  rpcMethods;
-  constructor(options) {
-    this.nodeUrl = options.nodeUrl;
-    this.headers = options.headers;
-    this.interval = options.interval;
-    this.baseFetch = options.baseFetch;
-    this.rpcMethods = options.rpcMethods;
-  }
-  async wait() {
-    if (!this.delayPromise || !this.delayPromiseResolve) {
-      this.delayPromise = new Promise((resolve) => {
-        this.delayPromiseResolve = resolve;
-      });
-    }
-    if (this.delayTimer) {
-      clearTimeout(this.delayTimer);
-      this.delayTimer = void 0;
-    }
-    this.delayTimer = setTimeout(() => {
-      if (this.delayPromiseResolve) {
-        this.delayPromiseResolve();
-        this.delayPromise = void 0;
-        this.delayPromiseResolve = void 0;
-      }
-    }, this.interval);
-    return this.delayPromise;
+// src/utils/errors/rpc.ts
+var errorCodes = {
+  FAILED_TO_RECEIVE_TXN: 1,
+  NO_TRACE_AVAILABLE: 10,
+  CONTRACT_NOT_FOUND: 20,
+  ENTRYPOINT_NOT_FOUND: 21,
+  BLOCK_NOT_FOUND: 24,
+  INVALID_TXN_INDEX: 27,
+  CLASS_HASH_NOT_FOUND: 28,
+  TXN_HASH_NOT_FOUND: 29,
+  PAGE_SIZE_TOO_BIG: 31,
+  NO_BLOCKS: 32,
+  INVALID_CONTINUATION_TOKEN: 33,
+  TOO_MANY_KEYS_IN_FILTER: 34,
+  CONTRACT_ERROR: 40,
+  TRANSACTION_EXECUTION_ERROR: 41,
+  STORAGE_PROOF_NOT_SUPPORTED: 42,
+  CLASS_ALREADY_DECLARED: 51,
+  INVALID_TRANSACTION_NONCE: 52,
+  INSUFFICIENT_RESOURCES_FOR_VALIDATE: 53,
+  INSUFFICIENT_ACCOUNT_BALANCE: 54,
+  VALIDATION_FAILURE: 55,
+  COMPILATION_FAILED: 56,
+  CONTRACT_CLASS_SIZE_IS_TOO_LARGE: 57,
+  NON_ACCOUNT: 58,
+  DUPLICATE_TX: 59,
+  COMPILED_CLASS_HASH_MISMATCH: 60,
+  UNSUPPORTED_TX_VERSION: 61,
+  UNSUPPORTED_CONTRACT_CLASS_VERSION: 62,
+  UNEXPECTED_ERROR: 63,
+  REPLACEMENT_TRANSACTION_UNDERPRICED: 64,
+  FEE_BELOW_MINIMUM: 65,
+  INVALID_SUBSCRIPTION_ID: 66,
+  TOO_MANY_ADDRESSES_IN_FILTER: 67,
+  TOO_MANY_BLOCKS_BACK: 68,
+  COMPILATION_ERROR: 100,
+  //
+  INVALID_ADDRESS: 150,
+  TOKEN_NOT_SUPPORTED: 151,
+  INVALID_SIGNATURE: 153,
+  MAX_AMOUNT_TOO_LOW: 154,
+  CLASS_HASH_NOT_SUPPORTED: 155,
+  PAYMASTER_TRANSACTION_EXECUTION_ERROR: 156,
+  INVALID_TIME_BOUNDS: 157,
+  INVALID_DEPLOYMENT_DATA: 158,
+  INVALID_CLASS_HASH: 159,
+  INVALID_ID: 160,
+  UNKNOWN_ERROR: 163
+};
+var rpc_default = errorCodes;
+
+// src/utils/errors/index.ts
+function fixStack(target, fn = target.constructor) {
+  const { captureStackTrace } = Error;
+  captureStackTrace && captureStackTrace(target, fn);
+}
+function fixProto(target, prototype) {
+  const { setPrototypeOf } = Object;
+  setPrototypeOf ? setPrototypeOf(target, prototype) : target.__proto__ = prototype;
+}
+var CustomError = class extends Error {
+  name;
+  constructor(message) {
+    super(message);
+    Object.defineProperty(this, "name", {
+      value: new.target.name,
+      enumerable: false,
+      configurable: true
+    });
+    fixProto(this, new.target.prototype);
+    fixStack(this);
   }
-  addPendingRequest(method, params, id) {
-    const request = {
-      id: id ?? `batched_${this.requestId += 1}`,
-      jsonrpc: "2.0",
-      method: method.description || String(method),
-      params: params ?? void 0
-    };
-    this.pendingRequests[request.id] = request;
-    return request.id;
+};
+var LibraryError = class extends CustomError {
+};
+var RpcError = class extends LibraryError {
+  constructor(baseError, method, params) {
+    super(`RPC: ${method} with params ${stringify2(params, null, 2)}
+
+      ${baseError.code}: ${baseError.message}: ${stringify2(baseError.data)}`);
+    this.baseError = baseError;
+    this.request = { method, params };
   }
-  async sendBatch(requests) {
-    const raw = await this.baseFetch(this.nodeUrl, {
-      method: "POST",
-      body: stringify2(requests),
-      headers: this.headers
-    });
-    return raw.json();
+  request;
+  get code() {
+    return this.baseError.code;
   }
   /**
-   * Automatically batches and fetches JSON-RPC calls in a single request.
-   * @param method Method to call
-   * @param params Method parameters
-   * @param id JSON-RPC Request ID
-   * @returns JSON-RPC Response
+   * Verifies the underlying RPC error, also serves as a type guard for the _baseError_ property
+   * @example
+   * ```typescript
+   * SomeError.isType('UNEXPECTED_ERROR');
+   * ```
    */
-  async fetch(method, params, id) {
-    const requestId = this.addPendingRequest(method, params, id);
-    await this.wait();
-    const requests = this.pendingRequests;
-    this.pendingRequests = {};
-    if (!this.batchPromises[requestId]) {
-      const promise = this.sendBatch(Object.values(requests));
-      Object.keys(requests).forEach((key) => {
-        this.batchPromises[key] = promise;
-      });
-    }
-    const results = await this.batchPromises[requestId];
-    delete this.batchPromises[requestId];
-    const result = results.find((res) => res.id === requestId);
-    if (!result)
-      throw new Error(`Couldn't find the result for the request. Method: ${String(method)}`);
-    return result;
+  isType(typeName) {
+    return rpc_default[typeName] === this.code;
+  }
+};
+var TimeoutError = class extends LibraryError {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+var WebSocketNotConnectedError = class extends LibraryError {
+  constructor(message) {
+    super(message);
+    this.name = "WebSocketNotConnectedError";
   }
 };
 
@@ -846,8 +771,16 @@ __export(num_exports, {
   toStorageKey: () => toStorageKey,
   tryToBigInt: () => tryToBigInt
 });
-import { hexToBytes as hexToBytesNoble } from "@noble/curves/abstract/utils";
-import { sha256 } from "@noble/hashes/sha256";
+import { hexToBytes as hexToBytesNoble } from "@noble/curves/utils.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { utf8ToBytes } from "@noble/hashes/utils.js";
+
+// src/utils/assert.ts
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || "Assertion failure");
+  }
+}
 
 // src/utils/typed.ts
 var isUndefined = (value) => {
@@ -961,7 +894,7 @@ function addPercent(number, percent) {
 }
 function stringToSha256ToArrayBuff4(str) {
   const int31 = (n) => Number(n & MASK_31);
-  const result = int31(BigInt(addHexPrefix(buf2hex(sha256(str)))));
+  const result = int31(BigInt(addHexPrefix(buf2hex(sha256(utf8ToBytes(str))))));
   return hexToBytes(toHex(result));
 }
 function isBigNumberish(input) {
@@ -973,6 +906,155 @@ function getNext(iterator) {
   return it.value;
 }
 
+// src/utils/provider.ts
+var provider_exports = {};
+__export(provider_exports, {
+  Block: () => Block,
+  createSierraContractClass: () => createSierraContractClass,
+  extractAbi: () => extractAbi,
+  getDefaultNodeUrl: () => getDefaultNodeUrl,
+  getDefaultNodes: () => getDefaultNodes,
+  getSupportedRpcVersions: () => getSupportedRpcVersions,
+  parseContract: () => parseContract,
+  validBlockTags: () => validBlockTags,
+  wait: () => wait
+});
+
+// src/types/lib/contract/index.ts
+var EntryPointType = {
+  EXTERNAL: "EXTERNAL",
+  L1_HANDLER: "L1_HANDLER",
+  CONSTRUCTOR: "CONSTRUCTOR"
+};
+
+// src/types/calldata.ts
+var ValidateType = {
+  DEPLOY: "DEPLOY",
+  CALL: "CALL",
+  INVOKE: "INVOKE"
+};
+var Uint = {
+  u8: "core::integer::u8",
+  u16: "core::integer::u16",
+  u32: "core::integer::u32",
+  u64: "core::integer::u64",
+  u96: "core::integer::u96",
+  u128: "core::integer::u128",
+  u256: "core::integer::u256",
+  // This one is struct
+  u512: "core::integer::u512"
+  // This one is struct
+};
+var Int = {
+  i8: "core::integer::i8",
+  i16: "core::integer::i16",
+  i32: "core::integer::i32",
+  i64: "core::integer::i64",
+  i128: "core::integer::i128"
+};
+var Literal = {
+  ClassHash: "core::starknet::class_hash::ClassHash",
+  ContractAddress: "core::starknet::contract_address::ContractAddress",
+  Secp256k1Point: "core::starknet::secp256k1::Secp256k1Point",
+  U96: "core::internal::bounded_int::BoundedInt::<0, 79228162514264337593543950335>"
+};
+var ETH_ADDRESS = "core::starknet::eth_address::EthAddress";
+var NON_ZERO_PREFIX = "core::zeroable::NonZero::";
+
+// src/contract/types/index.type.ts
+function isAccount(providerOrAccount) {
+  return "execute" in providerOrAccount;
+}
+
+// src/types/outsideExecution.ts
+var OutsideExecutionTypesV1 = {
+  StarkNetDomain: [
+    { name: "name", type: "felt" },
+    { name: "version", type: "felt" },
+    { name: "chainId", type: "felt" }
+  ],
+  OutsideExecution: [
+    { name: "caller", type: "felt" },
+    { name: "nonce", type: "felt" },
+    { name: "execute_after", type: "felt" },
+    { name: "execute_before", type: "felt" },
+    { name: "calls_len", type: "felt" },
+    { name: "calls", type: "OutsideCall*" }
+  ],
+  OutsideCall: [
+    { name: "to", type: "felt" },
+    { name: "selector", type: "felt" },
+    { name: "calldata_len", type: "felt" },
+    { name: "calldata", type: "felt*" }
+  ]
+};
+var OutsideExecutionTypesV2 = {
+  StarknetDomain: [
+    // SNIP-12 revision 1 is used, so should be "StarknetDomain", not "StarkNetDomain"
+    { name: "name", type: "shortstring" },
+    { name: "version", type: "shortstring" },
+    // set to 2 in v2
+    { name: "chainId", type: "shortstring" },
+    { name: "revision", type: "shortstring" }
+  ],
+  OutsideExecution: [
+    { name: "Caller", type: "ContractAddress" },
+    { name: "Nonce", type: "felt" },
+    { name: "Execute After", type: "u128" },
+    { name: "Execute Before", type: "u128" },
+    { name: "Calls", type: "Call*" }
+  ],
+  Call: [
+    { name: "To", type: "ContractAddress" },
+    { name: "Selector", type: "selector" },
+    { name: "Calldata", type: "felt*" }
+  ]
+};
+var OutsideExecutionVersion = {
+  UNSUPPORTED: "0",
+  V1: "1",
+  V2: "2"
+};
+
+// src/utils/hash/index.ts
+var hash_exports = {};
+__export(hash_exports, {
+  COMPILED_CLASS_VERSION: () => COMPILED_CLASS_VERSION,
+  blake2sHashMany: () => blake2sHashMany,
+  calculateContractAddressFromHash: () => calculateContractAddressFromHash,
+  calculateDeclareTransactionHash: () => calculateDeclareTransactionHash3,
+  calculateDeployAccountTransactionHash: () => calculateDeployAccountTransactionHash3,
+  calculateInvokeTransactionHash: () => calculateInvokeTransactionHash2,
+  calculateL2MessageTxHash: () => calculateL2MessageTxHash,
+  computeCompiledClassHash: () => computeCompiledClassHash,
+  computeCompiledClassHashBlake: () => computeCompiledClassHashBlake,
+  computeCompiledClassHashPoseidon: () => computeCompiledClassHashPoseidon,
+  computeContractClassHash: () => computeContractClassHash,
+  computeHashOnElements: () => computeHashOnElements2,
+  computeHintedClassHash: () => computeHintedClassHash,
+  computeLegacyContractClassHash: () => computeLegacyContractClassHash,
+  computePedersenHash: () => computePedersenHash,
+  computePedersenHashOnElements: () => computePedersenHashOnElements,
+  computePoseidonHash: () => computePoseidonHash,
+  computePoseidonHashOnElements: () => computePoseidonHashOnElements,
+  computeSierraContractClassHash: () => computeSierraContractClassHash,
+  encodeBuiltins: () => encodeBuiltins,
+  flattenEntryPointData: () => flattenEntryPointData,
+  formatSpaces: () => formatSpaces,
+  getL1MessageHash: () => getL1MessageHash,
+  getL2MessageHash: () => getL2MessageHash,
+  getSelector: () => getSelector,
+  getSelectorFromName: () => getSelectorFromName,
+  hashByteCodeSegments: () => hashByteCodeSegments,
+  hashByteCodeSegmentsBlake: () => hashByteCodeSegmentsBlake,
+  keccakBn: () => keccakBn,
+  nullSkipReplacer: () => nullSkipReplacer,
+  poseidon: () => poseidon,
+  solidityUint256PackedKeccak256: () => solidityUint256PackedKeccak256,
+  starknetKeccak: () => starknetKeccak
+});
+import * as poseidon from "@noble/curves/abstract/poseidon.js";
+
 // src/utils/hash/selector.ts
 var selector_exports = {};
 __export(selector_exports, {
@@ -985,8 +1067,8 @@ __export(selector_exports, {
   starknetKeccak: () => starknetKeccak
 });
 import { keccak } from "@scure/starknet";
-import { keccak_256 } from "@noble/hashes/sha3";
-import { bytesToHex } from "@noble/curves/abstract/utils";
+import { keccak_256 } from "@noble/hashes/sha3.js";
+import { bytesToHex } from "@noble/curves/utils.js";
 function keccakBn(value) {
   const hexWithoutPrefix = removeHexPrefix(toHex(BigInt(value)));
   const evenHex = hexWithoutPrefix.length % 2 === 0 ? hexWithoutPrefix : `0${hexWithoutPrefix}`;
@@ -1031,6 +1113,21 @@ function getL1MessageHash(fromL2Address, toL1Address, payload) {
   return solidityUint256PackedKeccak256([fromL2Address, toL1Address, payload.length, ...payload]);
 }
 
+// src/utils/hash/transactionHash/v3.ts
+var v3_exports = {};
+__export(v3_exports, {
+  calculateDeclareTransactionHash: () => calculateDeclareTransactionHash,
+  calculateDeployAccountTransactionHash: () => calculateDeployAccountTransactionHash,
+  calculateInvokeTransactionHash: () => calculateInvokeTransactionHash,
+  calculateTransactionHashCommon: () => calculateTransactionHashCommon,
+  encodeDataResourceBoundsL1: () => encodeDataResourceBoundsL1,
+  encodeResourceBoundsL1: () => encodeResourceBoundsL1,
+  encodeResourceBoundsL2: () => encodeResourceBoundsL2,
+  hashDAMode: () => hashDAMode,
+  hashFeeFieldV3B3: () => hashFeeFieldV3B3
+});
+import { poseidonHashMany } from "@scure/starknet";
+
 // src/utils/shortString.ts
 var shortString_exports = {};
 __export(shortString_exports, {
@@ -1078,142 +1175,393 @@ function decodeShortString(str) {
   throw new Error(`${str} is not Hex or decimal`);
 }
 
-// src/utils/calldata/byteArray.ts
-var byteArray_exports = {};
-__export(byteArray_exports, {
-  byteArrayFromString: () => byteArrayFromString,
-  stringFromByteArray: () => stringFromByteArray
-});
-function stringFromByteArray(myByteArray) {
-  const pending_word = BigInt(myByteArray.pending_word) === 0n ? "" : decodeShortString(toHex(myByteArray.pending_word));
-  return myByteArray.data.reduce((cumuledString, encodedString) => {
-    const add = BigInt(encodedString) === 0n ? "" : decodeShortString(toHex(encodedString));
-    return cumuledString + add;
-  }, "") + pending_word;
+// src/utils/hash/transactionHash/v3.ts
+var AToBI = (array) => array.map((it) => BigInt(it));
+var DATA_AVAILABILITY_MODE_BITS = 32n;
+var MAX_AMOUNT_BITS = 64n;
+var MAX_PRICE_PER_UNIT_BITS = 128n;
+var RESOURCE_VALUE_OFFSET = MAX_AMOUNT_BITS + MAX_PRICE_PER_UNIT_BITS;
+var L1_GAS_NAME = BigInt(encodeShortString("L1_GAS"));
+var L2_GAS_NAME = BigInt(encodeShortString("L2_GAS"));
+var L1_DATA_GAS_NAME = BigInt(encodeShortString("L1_DATA"));
+function hashDAMode(nonceDAMode, feeDAMode) {
+  return (BigInt(nonceDAMode) << DATA_AVAILABILITY_MODE_BITS) + BigInt(feeDAMode);
 }
-function byteArrayFromString(targetString) {
-  const shortStrings = splitLongString(targetString);
-  const remainder = shortStrings[shortStrings.length - 1];
-  const shortStringsEncoded = shortStrings.map(encodeShortString);
-  const [pendingWord, pendingWordLength] = remainder === void 0 || remainder.length === 31 ? ["0x00", 0] : [shortStringsEncoded.pop(), remainder.length];
-  return {
-    data: shortStringsEncoded.length === 0 ? [] : shortStringsEncoded,
-    pending_word: pendingWord,
-    pending_word_len: pendingWordLength
-  };
+function encodeResourceBoundsL1(bounds) {
+  return (L1_GAS_NAME << RESOURCE_VALUE_OFFSET) + (bounds.l1_gas.max_amount << MAX_PRICE_PER_UNIT_BITS) + bounds.l1_gas.max_price_per_unit;
 }
-
-// src/utils/calldata/cairo.ts
-var cairo_exports = {};
-__export(cairo_exports, {
-  felt: () => felt,
-  getAbiContractVersion: () => getAbiContractVersion,
-  getArrayType: () => getArrayType,
-  isCairo1Abi: () => isCairo1Abi,
-  isCairo1Type: () => isCairo1Type,
-  isLen: () => isLen,
-  isTypeArray: () => isTypeArray,
-  isTypeBool: () => isTypeBool,
-  isTypeContractAddress: () => isTypeContractAddress,
-  isTypeEnum: () => isTypeEnum,
-  isTypeEthAddress: () => isTypeEthAddress,
-  isTypeFelt: () => isTypeFelt,
-  isTypeInt: () => isTypeInt,
-  isTypeLiteral: () => isTypeLiteral,
-  isTypeNamedTuple: () => isTypeNamedTuple,
-  isTypeNonZero: () => isTypeNonZero,
-  isTypeOption: () => isTypeOption,
-  isTypeResult: () => isTypeResult,
-  isTypeSecp256k1Point: () => isTypeSecp256k1Point,
-  isTypeStruct: () => isTypeStruct,
-  isTypeTuple: () => isTypeTuple,
-  isTypeU96: () => isTypeU96,
-  isTypeUint: () => isTypeUint,
-  isTypeUint256: () => isTypeUint256,
-  tuple: () => tuple,
-  uint256: () => uint256,
-  uint512: () => uint512
+function encodeResourceBoundsL2(bounds) {
+  return (L2_GAS_NAME << RESOURCE_VALUE_OFFSET) + (bounds.l2_gas.max_amount << MAX_PRICE_PER_UNIT_BITS) + bounds.l2_gas.max_price_per_unit;
+}
+function encodeDataResourceBoundsL1(bounds) {
+  return (L1_DATA_GAS_NAME << RESOURCE_VALUE_OFFSET) + (bounds.l1_data_gas.max_amount << MAX_PRICE_PER_UNIT_BITS) + bounds.l1_data_gas.max_price_per_unit;
+}
+function hashFeeFieldV3B3(tip, bounds) {
+  const L1Bound = encodeResourceBoundsL1(bounds);
+  const L2Bound = encodeResourceBoundsL2(bounds);
+  const L1Data = encodeDataResourceBoundsL1(bounds);
+  return poseidonHashMany([BigInt(tip), L1Bound, L2Bound, L1Data]);
+}
+function calculateTransactionHashCommon(txHashPrefix, version, senderAddress, chainId, nonce, tip, paymasterData, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, additionalData = []) {
+  const feeFieldHash = hashFeeFieldV3B3(tip, resourceBounds);
+  const dAModeHash = hashDAMode(nonceDataAvailabilityMode, feeDataAvailabilityMode);
+  const dataToHash = AToBI([
+    txHashPrefix,
+    version,
+    senderAddress,
+    feeFieldHash,
+    poseidonHashMany(AToBI(paymasterData)),
+    chainId,
+    nonce,
+    dAModeHash,
+    ...AToBI(additionalData)
+  ]);
+  return toHex(poseidonHashMany(dataToHash));
+}
+function calculateDeployAccountTransactionHash(contractAddress, classHash, compiledConstructorCalldata, salt, version, chainId, nonce, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, tip, paymasterData) {
+  return calculateTransactionHashCommon(
+    _TransactionHashPrefix.DEPLOY_ACCOUNT,
+    version,
+    contractAddress,
+    chainId,
+    nonce,
+    tip,
+    paymasterData,
+    nonceDataAvailabilityMode,
+    feeDataAvailabilityMode,
+    resourceBounds,
+    [poseidonHashMany(AToBI(compiledConstructorCalldata)), classHash, salt]
+  );
+}
+function calculateDeclareTransactionHash(classHash, compiledClassHash, senderAddress, version, chainId, nonce, accountDeploymentData, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, tip, paymasterData) {
+  return calculateTransactionHashCommon(
+    _TransactionHashPrefix.DECLARE,
+    version,
+    senderAddress,
+    chainId,
+    nonce,
+    tip,
+    AToBI(paymasterData),
+    nonceDataAvailabilityMode,
+    feeDataAvailabilityMode,
+    resourceBounds,
+    [poseidonHashMany(AToBI(accountDeploymentData)), classHash, compiledClassHash]
+  );
+}
+function calculateInvokeTransactionHash(senderAddress, version, compiledCalldata, chainId, nonce, accountDeploymentData, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, tip, paymasterData, proofFacts) {
+  const proofFactsAdditionalData = proofFacts?.length ? [poseidonHashMany(AToBI(proofFacts))] : [];
+  return calculateTransactionHashCommon(
+    _TransactionHashPrefix.INVOKE,
+    version,
+    senderAddress,
+    chainId,
+    nonce,
+    tip,
+    paymasterData,
+    nonceDataAvailabilityMode,
+    feeDataAvailabilityMode,
+    resourceBounds,
+    [
+      poseidonHashMany(AToBI(accountDeploymentData)),
+      poseidonHashMany(AToBI(compiledCalldata)),
+      ...proofFactsAdditionalData
+    ]
+  );
+}
+
+// src/utils/hash/transactionHash/v2.ts
+var v2_exports = {};
+__export(v2_exports, {
+  calculateDeclareTransactionHash: () => calculateDeclareTransactionHash2,
+  calculateDeployAccountTransactionHash: () => calculateDeployAccountTransactionHash2,
+  calculateL2MessageTxHash: () => calculateL2MessageTxHash,
+  calculateTransactionHash: () => calculateTransactionHash,
+  calculateTransactionHashCommon: () => calculateTransactionHashCommon2,
+  computeHashOnElements: () => computeHashOnElements
 });
 
-// src/utils/helpers.ts
-function addCompiledFlag(compiled) {
-  Object.defineProperty(compiled, "__compiled__", {
-    enumerable: false,
-    writable: false,
-    value: true
-  });
-  return compiled;
+// src/utils/ec.ts
+var ec_exports = {};
+__export(ec_exports, {
+  starkCurve: () => starkCurve,
+  weierstrass: () => weierstrass
+});
+import * as starkCurve from "@scure/starknet";
+import * as weierstrass from "@noble/curves/abstract/weierstrass.js";
+
+// src/utils/hash/transactionHash/v2.ts
+function computeHashOnElements(data) {
+  return [...data, data.length].reduce((x, y) => starkCurve.pedersen(toBigInt(x), toBigInt(y)), 0).toString();
+}
+function calculateTransactionHashCommon2(txHashPrefix, version, contractAddress, entryPointSelector, calldata, maxFee, chainId, additionalData = []) {
+  const calldataHash = computeHashOnElements(calldata);
+  const dataToHash = [
+    txHashPrefix,
+    version,
+    contractAddress,
+    entryPointSelector,
+    calldataHash,
+    maxFee,
+    chainId,
+    ...additionalData
+  ];
+  return computeHashOnElements(dataToHash);
+}
+function calculateDeclareTransactionHash2(classHash, senderAddress, version, maxFee, chainId, nonce, compiledClassHash) {
+  return calculateTransactionHashCommon2(
+    _TransactionHashPrefix.DECLARE,
+    version,
+    senderAddress,
+    0,
+    [classHash],
+    maxFee,
+    chainId,
+    [nonce, ...compiledClassHash ? [compiledClassHash] : []]
+  );
+}
+function calculateDeployAccountTransactionHash2(contractAddress, classHash, constructorCalldata, salt, version, maxFee, chainId, nonce) {
+  const calldata = [classHash, salt, ...constructorCalldata];
+  return calculateTransactionHashCommon2(
+    _TransactionHashPrefix.DEPLOY_ACCOUNT,
+    version,
+    contractAddress,
+    0,
+    calldata,
+    maxFee,
+    chainId,
+    [nonce]
+  );
+}
+function calculateTransactionHash(contractAddress, version, calldata, maxFee, chainId, nonce) {
+  return calculateTransactionHashCommon2(
+    _TransactionHashPrefix.INVOKE,
+    version,
+    contractAddress,
+    0,
+    calldata,
+    maxFee,
+    chainId,
+    [nonce]
+  );
+}
+function calculateL2MessageTxHash(l1FromAddress, l2ToAddress, l2Selector, l2Calldata, l2ChainId, l1Nonce) {
+  const payload = [l1FromAddress, ...l2Calldata];
+  return calculateTransactionHashCommon2(
+    _TransactionHashPrefix.L1_HANDLER,
+    0,
+    l2ToAddress,
+    getSelector(l2Selector),
+    payload,
+    0,
+    l2ChainId,
+    [l1Nonce]
+  );
 }
 
-// src/utils/cairoDataTypes/felt.ts
-var CairoFelt252 = class _CairoFelt252 {
-  /**
-   * byte representation of the felt252
-   */
-  data;
-  static abiSelector = "core::felt252";
-  constructor(data) {
-    _CairoFelt252.validate(data);
-    const processedData = _CairoFelt252.__processData(data);
-    this.data = processedData.subarray(processedData.findIndex((x) => x > 0));
-  }
-  static __processData(data) {
-    if (isString(data)) {
-      return stringToUint8Array(data);
-    }
-    if (isBigInt(data)) {
-      return bigIntToUint8Array(data);
-    }
-    if (Number.isInteger(data)) {
-      return bigIntToUint8Array(BigInt(data));
-    }
-    if (isBoolean(data)) {
-      return bigIntToUint8Array(BigInt(data ? 1 : 0));
-    }
-    throw new Error(`${data} can't be computed by felt()`);
-  }
-  toBigInt() {
-    return uint8ArrayToBigInt(this.data);
-  }
-  decodeUtf8() {
-    return new TextDecoder().decode(this.data);
-  }
-  toHexString() {
-    return addHexPrefix(this.toBigInt().toString(16));
-  }
-  toApiRequest() {
-    return addCompiledFlag([BigInt(this.toHexString()).toString()]);
-  }
-  static assertRange(val) {
-    assert(val >= 0n && val < PRIME, `Value ${val} is out of felt252 range [0, ${PRIME})`);
-  }
-  static validate(data) {
-    assert(data !== null, "null value is not allowed for felt252");
-    assert(data !== void 0, "undefined value is not allowed for felt252");
-    assert(
-      isString(data) || isNumber(data) || isBigInt(data) || isBoolean(data),
-      `Unsupported data type '${typeof data}' for felt252. Expected string, number, bigint, or boolean`
+// src/utils/hash/transactionHash/index.ts
+function isV3InvokeTx(args) {
+  return [api_exports.ETransactionVersion.V3, api_exports.ETransactionVersion.F3].includes(args.version);
+}
+function calculateInvokeTransactionHash2(args) {
+  if (isV3InvokeTx(args)) {
+    return calculateInvokeTransactionHash(
+      args.senderAddress,
+      args.version,
+      args.compiledCalldata,
+      args.chainId,
+      args.nonce,
+      args.accountDeploymentData,
+      args.nonceDataAvailabilityMode,
+      args.feeDataAvailabilityMode,
+      args.resourceBounds,
+      args.tip,
+      args.paymasterData,
+      args.proofFacts
     );
-    const value = _CairoFelt252.__processData(data);
-    const bn = uint8ArrayToBigInt(value);
-    _CairoFelt252.assertRange(bn);
   }
-  static is(data) {
-    try {
-      _CairoFelt252.validate(data);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  static isAbiType(abiType) {
-    return abiType === _CairoFelt252.abiSelector;
-  }
-  static factoryFromApiResponse(responseIterator) {
-    return new _CairoFelt252(getNext(responseIterator));
-  }
-};
-function CairoFelt(it) {
+  throw new Error("Invalid Tx version for hash calculation");
+}
+function isV3DeclareTx(args) {
+  return [api_exports.ETransactionVersion.V3, api_exports.ETransactionVersion.F3].includes(args.version);
+}
+function calculateDeclareTransactionHash3(args) {
+  if (isV3DeclareTx(args)) {
+    return calculateDeclareTransactionHash(
+      args.classHash,
+      args.compiledClassHash,
+      args.senderAddress,
+      args.version,
+      args.chainId,
+      args.nonce,
+      args.accountDeploymentData,
+      args.nonceDataAvailabilityMode,
+      args.feeDataAvailabilityMode,
+      args.resourceBounds,
+      args.tip,
+      args.paymasterData
+    );
+  }
+  throw new Error("Invalid Tx version for hash calculation");
+}
+function isV3DeployAccountTx(args) {
+  return [api_exports.ETransactionVersion.V3, api_exports.ETransactionVersion.F3].includes(args.version);
+}
+function calculateDeployAccountTransactionHash3(args) {
+  if (isV3DeployAccountTx(args)) {
+    return calculateDeployAccountTransactionHash(
+      args.contractAddress,
+      args.classHash,
+      args.compiledConstructorCalldata,
+      args.salt,
+      args.version,
+      args.chainId,
+      args.nonce,
+      args.nonceDataAvailabilityMode,
+      args.feeDataAvailabilityMode,
+      args.resourceBounds,
+      args.tip,
+      args.paymasterData
+    );
+  }
+  throw new Error("Invalid Tx version for hash calculation");
+}
+
+// src/utils/calldata/byteArray.ts
+var byteArray_exports = {};
+__export(byteArray_exports, {
+  byteArrayFromString: () => byteArrayFromString,
+  stringFromByteArray: () => stringFromByteArray
+});
+function stringFromByteArray(myByteArray) {
+  const pending_word = BigInt(myByteArray.pending_word) === 0n ? "" : decodeShortString(toHex(myByteArray.pending_word));
+  return myByteArray.data.reduce((cumuledString, encodedString) => {
+    const add = BigInt(encodedString) === 0n ? "" : decodeShortString(toHex(encodedString));
+    return cumuledString + add;
+  }, "") + pending_word;
+}
+function byteArrayFromString(targetString) {
+  const shortStrings = splitLongString(targetString);
+  const remainder = shortStrings[shortStrings.length - 1];
+  const shortStringsEncoded = shortStrings.map(encodeShortString);
+  const [pendingWord, pendingWordLength] = remainder === void 0 || remainder.length === 31 ? ["0x00", 0] : [shortStringsEncoded.pop(), remainder.length];
+  return {
+    data: shortStringsEncoded.length === 0 ? [] : shortStringsEncoded,
+    pending_word: pendingWord,
+    pending_word_len: pendingWordLength
+  };
+}
+
+// src/utils/calldata/cairo.ts
+var cairo_exports = {};
+__export(cairo_exports, {
+  felt: () => felt,
+  getAbiContractVersion: () => getAbiContractVersion,
+  getArrayType: () => getArrayType,
+  isCairo1Abi: () => isCairo1Abi,
+  isCairo1Type: () => isCairo1Type,
+  isLen: () => isLen,
+  isTypeArray: () => isTypeArray,
+  isTypeBool: () => isTypeBool,
+  isTypeContractAddress: () => isTypeContractAddress,
+  isTypeEnum: () => isTypeEnum,
+  isTypeEthAddress: () => isTypeEthAddress,
+  isTypeFelt: () => isTypeFelt,
+  isTypeInt: () => isTypeInt,
+  isTypeLiteral: () => isTypeLiteral,
+  isTypeNamedTuple: () => isTypeNamedTuple,
+  isTypeNonZero: () => isTypeNonZero,
+  isTypeOption: () => isTypeOption,
+  isTypeResult: () => isTypeResult,
+  isTypeSecp256k1Point: () => isTypeSecp256k1Point,
+  isTypeStruct: () => isTypeStruct,
+  isTypeTuple: () => isTypeTuple,
+  isTypeU96: () => isTypeU96,
+  isTypeUint: () => isTypeUint,
+  isTypeUint256: () => isTypeUint256,
+  tuple: () => tuple,
+  uint256: () => uint256,
+  uint512: () => uint512
+});
+
+// src/utils/helpers.ts
+function addCompiledFlag(compiled) {
+  Object.defineProperty(compiled, "__compiled__", {
+    enumerable: false,
+    writable: false,
+    value: true
+  });
+  return compiled;
+}
+
+// src/utils/cairoDataTypes/felt.ts
+var CairoFelt252 = class _CairoFelt252 {
+  /**
+   * byte representation of the felt252
+   */
+  data;
+  static abiSelector = "core::felt252";
+  constructor(data) {
+    _CairoFelt252.validate(data);
+    const processedData = _CairoFelt252.__processData(data);
+    this.data = processedData.subarray(processedData.findIndex((x) => x > 0));
+  }
+  static __processData(data) {
+    if (isString(data)) {
+      return stringToUint8Array(data);
+    }
+    if (isBigInt(data)) {
+      return bigIntToUint8Array(data);
+    }
+    if (Number.isInteger(data)) {
+      return bigIntToUint8Array(BigInt(data));
+    }
+    if (isBoolean(data)) {
+      return bigIntToUint8Array(BigInt(data ? 1 : 0));
+    }
+    throw new Error(`${data} can't be computed by felt()`);
+  }
+  toBigInt() {
+    return uint8ArrayToBigInt(this.data);
+  }
+  decodeUtf8() {
+    return new TextDecoder().decode(this.data);
+  }
+  toHexString() {
+    return addHexPrefix(this.toBigInt().toString(16));
+  }
+  toApiRequest() {
+    return addCompiledFlag([BigInt(this.toHexString()).toString()]);
+  }
+  static assertRange(val) {
+    assert(val >= 0n && val < PRIME, `Value ${val} is out of felt252 range [0, ${PRIME})`);
+  }
+  static validate(data) {
+    assert(data !== null, "null value is not allowed for felt252");
+    assert(data !== void 0, "undefined value is not allowed for felt252");
+    assert(
+      isString(data) || isNumber(data) || isBigInt(data) || isBoolean(data),
+      `Unsupported data type '${typeof data}' for felt252. Expected string, number, bigint, or boolean`
+    );
+    const value = _CairoFelt252.__processData(data);
+    const bn = uint8ArrayToBigInt(value);
+    _CairoFelt252.assertRange(bn);
+  }
+  static is(data) {
+    try {
+      _CairoFelt252.validate(data);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  static isAbiType(abiType) {
+    return abiType === _CairoFelt252.abiSelector;
+  }
+  static factoryFromApiResponse(responseIterator) {
+    return new _CairoFelt252(getNext(responseIterator));
+  }
+};
+function CairoFelt(it) {
   if (isBigInt(it) || Number.isInteger(it)) {
     const val = BigInt(it);
     CairoFelt252.assertRange(val);
@@ -1855,134 +2203,14 @@ var CairoBytes31 = class _CairoBytes31 {
   }
 };
 
-// src/utils/ec.ts
-var ec_exports = {};
-__export(ec_exports, {
-  starkCurve: () => starkCurve,
-  weierstrass: () => weierstrass
-});
-import * as starkCurve from "@scure/starknet";
-import * as weierstrass from "@noble/curves/abstract/weierstrass";
-
 // src/utils/hash/pedersenCore.ts
 function computePedersenHash(a, b) {
   return starkCurve.pedersen(BigInt(a), BigInt(b));
 }
-function computeHashOnElements(data) {
+function computeHashOnElements2(data) {
   return [...data, data.length].reduce((x, y) => starkCurve.pedersen(BigInt(x), BigInt(y)), 0).toString();
 }
-var computePedersenHashOnElements = computeHashOnElements;
-
-// src/utils/errors/rpc.ts
-var errorCodes = {
-  FAILED_TO_RECEIVE_TXN: 1,
-  NO_TRACE_AVAILABLE: 10,
-  CONTRACT_NOT_FOUND: 20,
-  ENTRYPOINT_NOT_FOUND: 21,
-  BLOCK_NOT_FOUND: 24,
-  INVALID_TXN_INDEX: 27,
-  CLASS_HASH_NOT_FOUND: 28,
-  TXN_HASH_NOT_FOUND: 29,
-  PAGE_SIZE_TOO_BIG: 31,
-  NO_BLOCKS: 32,
-  INVALID_CONTINUATION_TOKEN: 33,
-  TOO_MANY_KEYS_IN_FILTER: 34,
-  CONTRACT_ERROR: 40,
-  TRANSACTION_EXECUTION_ERROR: 41,
-  STORAGE_PROOF_NOT_SUPPORTED: 42,
-  CLASS_ALREADY_DECLARED: 51,
-  INVALID_TRANSACTION_NONCE: 52,
-  INSUFFICIENT_RESOURCES_FOR_VALIDATE: 53,
-  INSUFFICIENT_ACCOUNT_BALANCE: 54,
-  VALIDATION_FAILURE: 55,
-  COMPILATION_FAILED: 56,
-  CONTRACT_CLASS_SIZE_IS_TOO_LARGE: 57,
-  NON_ACCOUNT: 58,
-  DUPLICATE_TX: 59,
-  COMPILED_CLASS_HASH_MISMATCH: 60,
-  UNSUPPORTED_TX_VERSION: 61,
-  UNSUPPORTED_CONTRACT_CLASS_VERSION: 62,
-  UNEXPECTED_ERROR: 63,
-  REPLACEMENT_TRANSACTION_UNDERPRICED: 64,
-  FEE_BELOW_MINIMUM: 65,
-  INVALID_SUBSCRIPTION_ID: 66,
-  TOO_MANY_ADDRESSES_IN_FILTER: 67,
-  TOO_MANY_BLOCKS_BACK: 68,
-  COMPILATION_ERROR: 100,
-  //
-  INVALID_ADDRESS: 150,
-  TOKEN_NOT_SUPPORTED: 151,
-  INVALID_SIGNATURE: 153,
-  MAX_AMOUNT_TOO_LOW: 154,
-  CLASS_HASH_NOT_SUPPORTED: 155,
-  PAYMASTER_TRANSACTION_EXECUTION_ERROR: 156,
-  INVALID_TIME_BOUNDS: 157,
-  INVALID_DEPLOYMENT_DATA: 158,
-  INVALID_CLASS_HASH: 159,
-  INVALID_ID: 160,
-  UNKNOWN_ERROR: 163
-};
-var rpc_default = errorCodes;
-
-// src/utils/errors/index.ts
-function fixStack(target, fn = target.constructor) {
-  const { captureStackTrace } = Error;
-  captureStackTrace && captureStackTrace(target, fn);
-}
-function fixProto(target, prototype) {
-  const { setPrototypeOf } = Object;
-  setPrototypeOf ? setPrototypeOf(target, prototype) : target.__proto__ = prototype;
-}
-var CustomError = class extends Error {
-  name;
-  constructor(message) {
-    super(message);
-    Object.defineProperty(this, "name", {
-      value: new.target.name,
-      enumerable: false,
-      configurable: true
-    });
-    fixProto(this, new.target.prototype);
-    fixStack(this);
-  }
-};
-var LibraryError = class extends CustomError {
-};
-var RpcError = class extends LibraryError {
-  constructor(baseError, method, params) {
-    super(`RPC: ${method} with params ${stringify2(params, null, 2)}
-
-      ${baseError.code}: ${baseError.message}: ${stringify2(baseError.data)}`);
-    this.baseError = baseError;
-    this.request = { method, params };
-  }
-  request;
-  get code() {
-    return this.baseError.code;
-  }
-  /**
-   * Verifies the underlying RPC error, also serves as a type guard for the _baseError_ property
-   * @example
-   * ```typescript
-   * SomeError.isType('UNEXPECTED_ERROR');
-   * ```
-   */
-  isType(typeName) {
-    return rpc_default[typeName] === this.code;
-  }
-};
-var TimeoutError = class extends LibraryError {
-  constructor(message) {
-    super(message);
-    this.name = "TimeoutError";
-  }
-};
-var WebSocketNotConnectedError = class extends LibraryError {
-  constructor(message) {
-    super(message);
-    this.name = "WebSocketNotConnectedError";
-  }
-};
+var computePedersenHashOnElements = computeHashOnElements2;
 
 // src/utils/connect/buffer.ts
 var buffer_default = config.get("buffer") || typeof Buffer !== "undefined" && Buffer || typeof globalThis !== "undefined" && globalThis.Buffer || typeof window !== "undefined" && window.Buffer || typeof global !== "undefined" && global.Buffer || class {
@@ -2190,7 +2418,7 @@ var CairoByteArray = class _CairoByteArray {
       ...this.pending_word.toApiRequest(),
       ...this.pending_word_len.toApiRequest()
     ];
-    return computeHashOnElements(serialized);
+    return computeHashOnElements2(serialized);
   }
   /**
    * returns an array of all the data chunks and the pending word
@@ -4749,381 +4977,89 @@ var CallData = class _CallData {
   }
 };
 
-// src/utils/hash/index.ts
-var hash_exports = {};
-__export(hash_exports, {
-  COMPILED_CLASS_VERSION: () => COMPILED_CLASS_VERSION,
-  blake2sHashMany: () => blake2sHashMany,
-  calculateContractAddressFromHash: () => calculateContractAddressFromHash,
-  calculateDeclareTransactionHash: () => calculateDeclareTransactionHash3,
-  calculateDeployAccountTransactionHash: () => calculateDeployAccountTransactionHash3,
-  calculateInvokeTransactionHash: () => calculateInvokeTransactionHash2,
-  calculateL2MessageTxHash: () => calculateL2MessageTxHash,
-  computeCompiledClassHash: () => computeCompiledClassHash,
-  computeCompiledClassHashBlake: () => computeCompiledClassHashBlake,
-  computeCompiledClassHashPoseidon: () => computeCompiledClassHashPoseidon,
-  computeContractClassHash: () => computeContractClassHash,
-  computeHashOnElements: () => computeHashOnElements,
-  computeHintedClassHash: () => computeHintedClassHash,
-  computeLegacyContractClassHash: () => computeLegacyContractClassHash,
-  computePedersenHash: () => computePedersenHash,
-  computePedersenHashOnElements: () => computePedersenHashOnElements,
-  computePoseidonHash: () => computePoseidonHash,
-  computePoseidonHashOnElements: () => computePoseidonHashOnElements,
-  computeSierraContractClassHash: () => computeSierraContractClassHash,
-  encodeBuiltins: () => encodeBuiltins,
-  flattenEntryPointData: () => flattenEntryPointData,
-  formatSpaces: () => formatSpaces,
-  getL1MessageHash: () => getL1MessageHash,
-  getL2MessageHash: () => getL2MessageHash,
-  getSelector: () => getSelector,
-  getSelectorFromName: () => getSelectorFromName,
-  hashByteCodeSegments: () => hashByteCodeSegments,
-  hashByteCodeSegmentsBlake: () => hashByteCodeSegmentsBlake,
-  keccakBn: () => keccakBn,
-  nullSkipReplacer: () => nullSkipReplacer,
-  poseidon: () => poseidon,
-  solidityUint256PackedKeccak256: () => solidityUint256PackedKeccak256,
-  starknetKeccak: () => starknetKeccak
-});
-import * as poseidon from "@noble/curves/abstract/poseidon";
-
-// src/utils/hash/transactionHash/v3.ts
-var v3_exports = {};
-__export(v3_exports, {
-  calculateDeclareTransactionHash: () => calculateDeclareTransactionHash,
-  calculateDeployAccountTransactionHash: () => calculateDeployAccountTransactionHash,
-  calculateInvokeTransactionHash: () => calculateInvokeTransactionHash,
-  calculateTransactionHashCommon: () => calculateTransactionHashCommon,
-  encodeDataResourceBoundsL1: () => encodeDataResourceBoundsL1,
-  encodeResourceBoundsL1: () => encodeResourceBoundsL1,
-  encodeResourceBoundsL2: () => encodeResourceBoundsL2,
-  hashDAMode: () => hashDAMode,
-  hashFeeFieldV3B3: () => hashFeeFieldV3B3
-});
-import { poseidonHashMany } from "@scure/starknet";
-var AToBI = (array) => array.map((it) => BigInt(it));
-var DATA_AVAILABILITY_MODE_BITS = 32n;
-var MAX_AMOUNT_BITS = 64n;
-var MAX_PRICE_PER_UNIT_BITS = 128n;
-var RESOURCE_VALUE_OFFSET = MAX_AMOUNT_BITS + MAX_PRICE_PER_UNIT_BITS;
-var L1_GAS_NAME = BigInt(encodeShortString("L1_GAS"));
-var L2_GAS_NAME = BigInt(encodeShortString("L2_GAS"));
-var L1_DATA_GAS_NAME = BigInt(encodeShortString("L1_DATA"));
-function hashDAMode(nonceDAMode, feeDAMode) {
-  return (BigInt(nonceDAMode) << DATA_AVAILABILITY_MODE_BITS) + BigInt(feeDAMode);
-}
-function encodeResourceBoundsL1(bounds) {
-  return (L1_GAS_NAME << RESOURCE_VALUE_OFFSET) + (bounds.l1_gas.max_amount << MAX_PRICE_PER_UNIT_BITS) + bounds.l1_gas.max_price_per_unit;
+// src/utils/hash/classHash/util.ts
+var COMPILED_CLASS_VERSION = "COMPILED_CLASS_V1";
+function formatSpaces(json2) {
+  let insideQuotes = false;
+  const newString = [];
+  for (const char of json2) {
+    if (char === '"' && (newString.length > 0 && newString.slice(-1)[0] === "\\") === false) {
+      insideQuotes = !insideQuotes;
+    }
+    if (insideQuotes) {
+      newString.push(char);
+    } else {
+      newString.push(char === ":" ? ": " : char === "," ? ", " : char);
+    }
+  }
+  return newString.join("");
 }
-function encodeResourceBoundsL2(bounds) {
-  return (L2_GAS_NAME << RESOURCE_VALUE_OFFSET) + (bounds.l2_gas.max_amount << MAX_PRICE_PER_UNIT_BITS) + bounds.l2_gas.max_price_per_unit;
+function nullSkipReplacer(key, value) {
+  if (key === "attributes" || key === "accessible_scopes") {
+    return Array.isArray(value) && value.length === 0 ? void 0 : value;
+  }
+  if (key === "debug_info") {
+    return null;
+  }
+  return value === null ? void 0 : value;
 }
-function encodeDataResourceBoundsL1(bounds) {
-  return (L1_DATA_GAS_NAME << RESOURCE_VALUE_OFFSET) + (bounds.l1_data_gas.max_amount << MAX_PRICE_PER_UNIT_BITS) + bounds.l1_data_gas.max_price_per_unit;
+function encodeBuiltins(builtins) {
+  return builtins.map((it) => BigInt(encodeShortString(it)));
 }
-function hashFeeFieldV3B3(tip, bounds) {
-  const L1Bound = encodeResourceBoundsL1(bounds);
-  const L2Bound = encodeResourceBoundsL2(bounds);
-  const L1Data = encodeDataResourceBoundsL1(bounds);
-  return poseidonHashMany([BigInt(tip), L1Bound, L2Bound, L1Data]);
+function flattenEntryPointData(data, encodedBuiltinsArray) {
+  return data.flatMap((it, index) => [
+    BigInt(it.selector),
+    BigInt(it.offset),
+    ...encodedBuiltinsArray[index]
+  ]);
 }
-function calculateTransactionHashCommon(txHashPrefix, version, senderAddress, chainId, nonce, tip, paymasterData, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, additionalData = []) {
-  const feeFieldHash = hashFeeFieldV3B3(tip, resourceBounds);
-  const dAModeHash = hashDAMode(nonceDataAvailabilityMode, feeDataAvailabilityMode);
-  const dataToHash = AToBI([
-    txHashPrefix,
-    version,
-    senderAddress,
-    feeFieldHash,
-    poseidonHashMany(AToBI(paymasterData)),
-    chainId,
-    nonce,
-    dAModeHash,
-    ...AToBI(additionalData)
+
+// src/utils/hash/classHash/pedersen.ts
+function calculateContractAddressFromHash(salt, classHash, constructorCalldata, deployerAddress) {
+  const compiledCalldata = CallData.compile(constructorCalldata);
+  const constructorCalldataHash = computeHashOnElements2(compiledCalldata);
+  const CONTRACT_ADDRESS_PREFIX = felt("0x535441524b4e45545f434f4e54524143545f41444452455353");
+  const hash = computeHashOnElements2([
+    CONTRACT_ADDRESS_PREFIX,
+    deployerAddress,
+    salt,
+    classHash,
+    constructorCalldataHash
   ]);
-  return toHex(poseidonHashMany(dataToHash));
+  return toHex(BigInt(hash) % ADDR_BOUND);
 }
-function calculateDeployAccountTransactionHash(contractAddress, classHash, compiledConstructorCalldata, salt, version, chainId, nonce, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, tip, paymasterData) {
-  return calculateTransactionHashCommon(
-    _TransactionHashPrefix.DEPLOY_ACCOUNT,
-    version,
-    contractAddress,
-    chainId,
-    nonce,
-    tip,
-    paymasterData,
-    nonceDataAvailabilityMode,
-    feeDataAvailabilityMode,
-    resourceBounds,
-    [poseidonHashMany(AToBI(compiledConstructorCalldata)), classHash, salt]
-  );
+function computeHintedClassHash(compiledContract) {
+  const { abi, program } = compiledContract;
+  const contractClass = { abi, program };
+  const serializedJson = formatSpaces(stringify2(contractClass, nullSkipReplacer));
+  return addHexPrefix(starkCurve.keccak(utf8ToArray(serializedJson)).toString(16));
 }
-function calculateDeclareTransactionHash(classHash, compiledClassHash, senderAddress, version, chainId, nonce, accountDeploymentData, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, tip, paymasterData) {
-  return calculateTransactionHashCommon(
-    _TransactionHashPrefix.DECLARE,
-    version,
-    senderAddress,
-    chainId,
-    nonce,
-    tip,
-    AToBI(paymasterData),
-    nonceDataAvailabilityMode,
-    feeDataAvailabilityMode,
-    resourceBounds,
-    [poseidonHashMany(AToBI(accountDeploymentData)), classHash, compiledClassHash]
+function computeLegacyContractClassHash(contract) {
+  const compiledContract = isString(contract) ? parse2(contract) : contract;
+  const apiVersion = toHex(API_VERSION);
+  const externalEntryPointsHash = computeHashOnElements2(
+    compiledContract.entry_points_by_type.EXTERNAL.flatMap((e) => [e.selector, e.offset])
   );
-}
-function calculateInvokeTransactionHash(senderAddress, version, compiledCalldata, chainId, nonce, accountDeploymentData, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, tip, paymasterData, proofFacts) {
-  const proofFactsAdditionalData = proofFacts?.length ? [poseidonHashMany(AToBI(proofFacts))] : [];
-  return calculateTransactionHashCommon(
-    _TransactionHashPrefix.INVOKE,
-    version,
-    senderAddress,
-    chainId,
-    nonce,
-    tip,
-    paymasterData,
-    nonceDataAvailabilityMode,
-    feeDataAvailabilityMode,
-    resourceBounds,
-    [
-      poseidonHashMany(AToBI(accountDeploymentData)),
-      poseidonHashMany(AToBI(compiledCalldata)),
-      ...proofFactsAdditionalData
-    ]
+  const l1HandlerEntryPointsHash = computeHashOnElements2(
+    compiledContract.entry_points_by_type.L1_HANDLER.flatMap((e) => [e.selector, e.offset])
+  );
+  const constructorEntryPointHash = computeHashOnElements2(
+    compiledContract.entry_points_by_type.CONSTRUCTOR.flatMap((e) => [e.selector, e.offset])
   );
-}
-
-// src/utils/hash/transactionHash/v2.ts
-var v2_exports = {};
-__export(v2_exports, {
-  calculateDeclareTransactionHash: () => calculateDeclareTransactionHash2,
-  calculateDeployAccountTransactionHash: () => calculateDeployAccountTransactionHash2,
-  calculateL2MessageTxHash: () => calculateL2MessageTxHash,
-  calculateTransactionHash: () => calculateTransactionHash,
-  calculateTransactionHashCommon: () => calculateTransactionHashCommon2,
-  computeHashOnElements: () => computeHashOnElements2
-});
-function computeHashOnElements2(data) {
-  return [...data, data.length].reduce((x, y) => starkCurve.pedersen(toBigInt(x), toBigInt(y)), 0).toString();
-}
-function calculateTransactionHashCommon2(txHashPrefix, version, contractAddress, entryPointSelector, calldata, maxFee, chainId, additionalData = []) {
-  const calldataHash = computeHashOnElements2(calldata);
-  const dataToHash = [
-    txHashPrefix,
-    version,
-    contractAddress,
-    entryPointSelector,
-    calldataHash,
-    maxFee,
-    chainId,
-    ...additionalData
-  ];
-  return computeHashOnElements2(dataToHash);
-}
-function calculateDeclareTransactionHash2(classHash, senderAddress, version, maxFee, chainId, nonce, compiledClassHash) {
-  return calculateTransactionHashCommon2(
-    _TransactionHashPrefix.DECLARE,
-    version,
-    senderAddress,
-    0,
-    [classHash],
-    maxFee,
-    chainId,
-    [nonce, ...compiledClassHash ? [compiledClassHash] : []]
-  );
-}
-function calculateDeployAccountTransactionHash2(contractAddress, classHash, constructorCalldata, salt, version, maxFee, chainId, nonce) {
-  const calldata = [classHash, salt, ...constructorCalldata];
-  return calculateTransactionHashCommon2(
-    _TransactionHashPrefix.DEPLOY_ACCOUNT,
-    version,
-    contractAddress,
-    0,
-    calldata,
-    maxFee,
-    chainId,
-    [nonce]
-  );
-}
-function calculateTransactionHash(contractAddress, version, calldata, maxFee, chainId, nonce) {
-  return calculateTransactionHashCommon2(
-    _TransactionHashPrefix.INVOKE,
-    version,
-    contractAddress,
-    0,
-    calldata,
-    maxFee,
-    chainId,
-    [nonce]
-  );
-}
-function calculateL2MessageTxHash(l1FromAddress, l2ToAddress, l2Selector, l2Calldata, l2ChainId, l1Nonce) {
-  const payload = [l1FromAddress, ...l2Calldata];
-  return calculateTransactionHashCommon2(
-    _TransactionHashPrefix.L1_HANDLER,
-    0,
-    l2ToAddress,
-    getSelector(l2Selector),
-    payload,
-    0,
-    l2ChainId,
-    [l1Nonce]
-  );
-}
-
-// src/utils/hash/transactionHash/index.ts
-function isV3InvokeTx(args) {
-  return [api_exports.ETransactionVersion.V3, api_exports.ETransactionVersion.F3].includes(args.version);
-}
-function calculateInvokeTransactionHash2(args) {
-  if (isV3InvokeTx(args)) {
-    return calculateInvokeTransactionHash(
-      args.senderAddress,
-      args.version,
-      args.compiledCalldata,
-      args.chainId,
-      args.nonce,
-      args.accountDeploymentData,
-      args.nonceDataAvailabilityMode,
-      args.feeDataAvailabilityMode,
-      args.resourceBounds,
-      args.tip,
-      args.paymasterData,
-      args.proofFacts
-    );
-  }
-  throw new Error("Invalid Tx version for hash calculation");
-}
-function isV3DeclareTx(args) {
-  return [api_exports.ETransactionVersion.V3, api_exports.ETransactionVersion.F3].includes(args.version);
-}
-function calculateDeclareTransactionHash3(args) {
-  if (isV3DeclareTx(args)) {
-    return calculateDeclareTransactionHash(
-      args.classHash,
-      args.compiledClassHash,
-      args.senderAddress,
-      args.version,
-      args.chainId,
-      args.nonce,
-      args.accountDeploymentData,
-      args.nonceDataAvailabilityMode,
-      args.feeDataAvailabilityMode,
-      args.resourceBounds,
-      args.tip,
-      args.paymasterData
-    );
-  }
-  throw new Error("Invalid Tx version for hash calculation");
-}
-function isV3DeployAccountTx(args) {
-  return [api_exports.ETransactionVersion.V3, api_exports.ETransactionVersion.F3].includes(args.version);
-}
-function calculateDeployAccountTransactionHash3(args) {
-  if (isV3DeployAccountTx(args)) {
-    return calculateDeployAccountTransactionHash(
-      args.contractAddress,
-      args.classHash,
-      args.compiledConstructorCalldata,
-      args.salt,
-      args.version,
-      args.chainId,
-      args.nonce,
-      args.nonceDataAvailabilityMode,
-      args.feeDataAvailabilityMode,
-      args.resourceBounds,
-      args.tip,
-      args.paymasterData
-    );
-  }
-  throw new Error("Invalid Tx version for hash calculation");
-}
-
-// src/utils/hash/classHash/util.ts
-var COMPILED_CLASS_VERSION = "COMPILED_CLASS_V1";
-function formatSpaces(json2) {
-  let insideQuotes = false;
-  const newString = [];
-  for (const char of json2) {
-    if (char === '"' && (newString.length > 0 && newString.slice(-1)[0] === "\\") === false) {
-      insideQuotes = !insideQuotes;
-    }
-    if (insideQuotes) {
-      newString.push(char);
-    } else {
-      newString.push(char === ":" ? ": " : char === "," ? ", " : char);
-    }
-  }
-  return newString.join("");
-}
-function nullSkipReplacer(key, value) {
-  if (key === "attributes" || key === "accessible_scopes") {
-    return Array.isArray(value) && value.length === 0 ? void 0 : value;
-  }
-  if (key === "debug_info") {
-    return null;
-  }
-  return value === null ? void 0 : value;
-}
-function encodeBuiltins(builtins) {
-  return builtins.map((it) => BigInt(encodeShortString(it)));
-}
-function flattenEntryPointData(data, encodedBuiltinsArray) {
-  return data.flatMap((it, index) => [
-    BigInt(it.selector),
-    BigInt(it.offset),
-    ...encodedBuiltinsArray[index]
-  ]);
-}
-
-// src/utils/hash/classHash/pedersen.ts
-function calculateContractAddressFromHash(salt, classHash, constructorCalldata, deployerAddress) {
-  const compiledCalldata = CallData.compile(constructorCalldata);
-  const constructorCalldataHash = computeHashOnElements(compiledCalldata);
-  const CONTRACT_ADDRESS_PREFIX = felt("0x535441524b4e45545f434f4e54524143545f41444452455353");
-  const hash = computeHashOnElements([
-    CONTRACT_ADDRESS_PREFIX,
-    deployerAddress,
-    salt,
-    classHash,
-    constructorCalldataHash
-  ]);
-  return toHex(BigInt(hash) % ADDR_BOUND);
-}
-function computeHintedClassHash(compiledContract) {
-  const { abi, program } = compiledContract;
-  const contractClass = { abi, program };
-  const serializedJson = formatSpaces(stringify2(contractClass, nullSkipReplacer));
-  return addHexPrefix(starkCurve.keccak(utf8ToArray(serializedJson)).toString(16));
-}
-function computeLegacyContractClassHash(contract) {
-  const compiledContract = isString(contract) ? parse2(contract) : contract;
-  const apiVersion = toHex(API_VERSION);
-  const externalEntryPointsHash = computeHashOnElements(
-    compiledContract.entry_points_by_type.EXTERNAL.flatMap((e) => [e.selector, e.offset])
-  );
-  const l1HandlerEntryPointsHash = computeHashOnElements(
-    compiledContract.entry_points_by_type.L1_HANDLER.flatMap((e) => [e.selector, e.offset])
-  );
-  const constructorEntryPointHash = computeHashOnElements(
-    compiledContract.entry_points_by_type.CONSTRUCTOR.flatMap((e) => [e.selector, e.offset])
-  );
-  const builtinsHash = computeHashOnElements(
-    compiledContract.program.builtins.map((s) => encodeShortString(s))
-  );
-  const hintedClassHash = computeHintedClassHash(compiledContract);
-  const dataHash = computeHashOnElements(compiledContract.program.data);
-  return computeHashOnElements([
-    apiVersion,
-    externalEntryPointsHash,
-    l1HandlerEntryPointsHash,
-    constructorEntryPointHash,
-    builtinsHash,
-    hintedClassHash,
-    dataHash
-  ]);
+  const builtinsHash = computeHashOnElements2(
+    compiledContract.program.builtins.map((s) => encodeShortString(s))
+  );
+  const hintedClassHash = computeHintedClassHash(compiledContract);
+  const dataHash = computeHashOnElements2(compiledContract.program.data);
+  return computeHashOnElements2([
+    apiVersion,
+    externalEntryPointsHash,
+    l1HandlerEntryPointsHash,
+    constructorEntryPointHash,
+    builtinsHash,
+    hintedClassHash,
+    dataHash
+  ]);
 }
 
 // src/utils/hash/classHash/poseidon.ts
@@ -5200,7 +5136,7 @@ function computeSierraContractClassHash(sierra) {
 }
 
 // src/utils/connect/blake.ts
-import { blake2s } from "@noble/hashes/blake2s";
+import { blake2s } from "@noble/hashes/blake2.js";
 function blakeHash(uint8Array) {
   return config.get("blake")?.(uint8Array) || blake2s(uint8Array, { dkLen: 32 });
 }
@@ -5380,6 +5316,8 @@ __export(stark_exports, {
   getSharedSecret: () => getSharedSecret,
   intDAM: () => intDAM,
   randomAddress: () => randomAddress,
+  randomFelt: () => randomFelt,
+  randomStarkPrivateKey: () => randomStarkPrivateKey,
   resourceBoundsToBigInt: () => resourceBoundsToBigInt,
   resourceBoundsToEstimateFeeResponse: () => resourceBoundsToEstimateFeeResponse,
   resourceBoundsToHexString: () => resourceBoundsToHexString,
@@ -5392,7 +5330,8 @@ __export(stark_exports, {
   v3Details: () => v3Details,
   zeroResourceBounds: () => zeroResourceBounds
 });
-import { getPublicKey, getStarkKey, utils } from "@scure/starknet";
+import { randomBytes } from "@noble/hashes/utils.js";
+import { getPublicKey, utils } from "@scure/starknet";
 async function compressProgram(jsonProgram) {
   const stringified = isString(jsonProgram) ? jsonProgram : stringify2(jsonProgram);
   const stream = new CompressionStream("gzip");
@@ -5412,9 +5351,14 @@ async function decompressProgram(base642) {
   const decompressed = await new Response(stream.readable).text();
   return parse2(decompressed);
 }
+function randomFelt() {
+  return toHex(uint8ArrayToBigInt(randomBytes(48)) % PRIME);
+}
+function randomStarkPrivateKey() {
+  return addHexPrefix(buf2hex(utils.randomPrivateKey()));
+}
 function randomAddress() {
-  const randomKeyPair = utils.randomPrivateKey();
-  return getStarkKey(randomKeyPair);
+  return randomFelt();
 }
 function encodeProof(proof) {
   return btoaUniversal(new Uint32Array(proof).buffer);
@@ -5433,7 +5377,7 @@ function formatSignature(sig) {
     const { r, s } = sig;
     return [toHex(r), toHex(s)];
   } catch (e) {
-    throw new Error("Signature need to be weierstrass.SignatureType or an array for custom");
+    throw new Error("Signature need to be weierstrass.ECDSASignature or an array for custom");
   }
 }
 function signatureToDecimalArray(sig) {
@@ -5570,413 +5514,1564 @@ function resourceBoundsToHexString(resourceBoundsBN) {
     if (isBigInt(obj)) {
       return toHex(obj);
     }
-    if (isObject(obj)) {
-      const result = {};
-      Object.keys(obj).forEach((key) => {
-        result[key] = convertBigIntToHex(obj[key]);
-      });
-      return result;
+    if (isObject(obj)) {
+      const result = {};
+      Object.keys(obj).forEach((key) => {
+        result[key] = convertBigIntToHex(obj[key]);
+      });
+      return result;
+    }
+    return obj;
+  };
+  return convertBigIntToHex(resourceBoundsBN);
+}
+function resourceBoundsToBigInt(resourceBounds) {
+  const convertStringToBigInt = (obj) => {
+    if (isString(obj)) {
+      return BigInt(obj);
+    }
+    if (isObject(obj)) {
+      const result = {};
+      Object.keys(obj).forEach((key) => {
+        result[key] = convertStringToBigInt(obj[key]);
+      });
+      return result;
+    }
+    return obj;
+  };
+  return convertStringToBigInt(resourceBounds);
+}
+
+// src/utils/contractLoader.ts
+function isFileSystemAvailable() {
+  try {
+    return typeof __require !== "undefined" && typeof __require.resolve === "function";
+  } catch {
+    logger.info("isFileSystemAvailable: false");
+    return false;
+  }
+}
+function contractLoader(input, compiledClassHash) {
+  if (typeof File !== "undefined" && (input instanceof File || Array.isArray(input))) {
+    return loadFromFileAPI(input, compiledClassHash);
+  }
+  if (typeof input === "string") {
+    if (!isFileSystemAvailable()) {
+      throw new Error(
+        'contractLoader with string paths is only available in Node.js environments. In browsers, please use File objects from <input type="file"> or drag-and-drop. Example: await contractLoader(fileInput.files[0])'
+      );
+    }
+    return loadFromFileSystem(input, compiledClassHash);
+  }
+  throw new Error(
+    "Invalid input type. Expected string (Node.js path) or File/File[] (browser File API)"
+  );
+}
+function loadFromFileSystem(contractPath, compiledClassHash) {
+  const fs = __require("fs");
+  const path = __require("path");
+  const resolvedPath = path.resolve(contractPath);
+  let dirPath;
+  let specifiedSierraFile;
+  let specifiedCasmFile;
+  const stats = fs.statSync(resolvedPath);
+  if (stats.isFile()) {
+    dirPath = path.dirname(resolvedPath);
+    const fileName = path.basename(resolvedPath);
+    if (fileName.endsWith(".sierra.json") || fileName.endsWith(".json") && !fileName.endsWith(".casm")) {
+      specifiedSierraFile = fileName;
+    } else if (fileName.endsWith(".casm")) {
+      specifiedCasmFile = fileName;
+    } else {
+      throw new Error(
+        `Invalid file type. Expected .json, .sierra.json, or .casm file, got: ${fileName}`
+      );
+    }
+  } else if (stats.isDirectory()) {
+    dirPath = resolvedPath;
+  } else {
+    throw new Error(`Path is neither a file nor a directory: ${contractPath}`);
+  }
+  const files = fs.readdirSync(dirPath);
+  let sierraFile;
+  let casmFile;
+  if (specifiedSierraFile) {
+    sierraFile = specifiedSierraFile;
+    const baseName = sierraFile.replace(/\.sierra\.json$/, "").replace(/\.json$/, "");
+    casmFile = files.find((f) => f === `${baseName}.casm`);
+  } else if (specifiedCasmFile) {
+    casmFile = specifiedCasmFile;
+    const baseName = casmFile.replace(/\.casm$/, "");
+    sierraFile = files.find((f) => f === `${baseName}.sierra.json`) || files.find((f) => f === `${baseName}.json`);
+  } else {
+    const sierraFiles = files.filter(
+      (f) => f.endsWith(".sierra.json") || f.endsWith(".json") && !f.endsWith(".casm")
+    );
+    if (sierraFiles.length === 0) {
+      throw new Error(`No .sierra.json file found in ${dirPath}. Sierra file is required.`);
+    }
+    if (sierraFiles.length > 1) {
+      throw new Error(
+        `Multiple .sierra.json files found in ${dirPath}: ${sierraFiles.join(", ")}. Please specify which file to use.`
+      );
+    }
+    [sierraFile] = sierraFiles;
+    const baseName = sierraFile.replace(/\.sierra\.json$/, "").replace(/\.json$/, "");
+    casmFile = files.find((f) => f === `${baseName}.casm`);
+  }
+  if (!sierraFile) {
+    throw new Error(`No .sierra.json file found in ${dirPath}. Sierra file is required.`);
+  }
+  const sierraPath = path.join(dirPath, sierraFile);
+  const sierraContent = parse2(fs.readFileSync(sierraPath, "utf8"));
+  if (casmFile) {
+    const casmPath = path.join(dirPath, casmFile);
+    const casmContent = parse2(fs.readFileSync(casmPath, "utf8"));
+    return {
+      sierra: sierraContent,
+      casm: casmContent,
+      compiler: casmContent.compiler_version
+    };
+  }
+  if (!compiledClassHash) {
+    throw new Error(
+      `No .casm file found for ${sierraFile} and no compiledClassHash provided. Either provide a .casm file or pass compiledClassHash as second parameter.`
+    );
+  }
+  return {
+    sierra: sierraContent,
+    compiledClassHash
+  };
+}
+async function loadFromFileAPI(input, compiledClassHash) {
+  const files = Array.isArray(input) ? input : [input];
+  if (files.length === 0) {
+    throw new Error("No files provided");
+  }
+  const sierraFiles = files.filter(
+    (file) => file.name.endsWith(".sierra.json") || file.name.endsWith(".json") && !file.name.endsWith(".casm")
+  );
+  const casmFiles = files.filter((file) => file.name.endsWith(".casm"));
+  if (sierraFiles.length > 1) {
+    throw new Error(
+      `Multiple .sierra.json files provided: ${sierraFiles.map((f) => f.name).join(", ")}. Please provide only one sierra file.`
+    );
+  }
+  if (casmFiles.length > 1) {
+    throw new Error(
+      `Multiple .casm files provided: ${casmFiles.map((f) => f.name).join(", ")}. Please provide only one casm file.`
+    );
+  }
+  const sierraFile = sierraFiles[0];
+  const casmFile = casmFiles[0];
+  if (!sierraFile) {
+    throw new Error(
+      `No .sierra.json file found in provided files. Sierra file is required. Provided files: ${files.map((f) => f.name).join(", ")}`
+    );
+  }
+  const sierraContent = parse2(await readFileAsText(sierraFile));
+  if (casmFile) {
+    const casmContent = parse2(await readFileAsText(casmFile));
+    return {
+      sierra: sierraContent,
+      casm: casmContent,
+      compiler: casmContent.compiler_version
+    };
+  }
+  if (!compiledClassHash) {
+    throw new Error(
+      "No .casm file found in provided files and no compiledClassHash provided. Either provide a .casm file or pass compiledClassHash as second parameter."
+    );
+  }
+  return {
+    sierra: sierraContent,
+    compiledClassHash
+  };
+}
+function readFileAsText(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = (event) => {
+      const content = event.target?.result;
+      if (typeof content === "string") {
+        resolve(content);
+      } else {
+        reject(new Error(`Failed to read file ${file.name} as text`));
+      }
+    };
+    reader.onerror = () => {
+      reject(new Error(`Failed to read file ${file.name}: ${reader.error?.message}`));
+    };
+    reader.readAsText(file);
+  });
+}
+
+// src/utils/contract.ts
+function isSierra(contract) {
+  const compiledContract = isString(contract) ? parse2(contract) : contract;
+  return "sierra_program" in compiledContract;
+}
+function extractContractHashes(payload, starknetVersion) {
+  const response = { ...payload };
+  if (isSierra(payload.contract)) {
+    if (!payload.compiledClassHash && payload.casm) {
+      response.compiledClassHash = computeCompiledClassHash(payload.casm, starknetVersion);
+    }
+    if (!response.compiledClassHash)
+      throw new Error(
+        "Extract compiledClassHash failed, provide (CairoAssembly).casm file or compiledClassHash"
+      );
+  }
+  response.classHash = payload.classHash ?? computeContractClassHash(payload.contract);
+  if (!response.classHash)
+    throw new Error("Extract classHash failed, provide (CompiledContract).json file or classHash");
+  return response;
+}
+async function contractClassResponseToLegacyCompiledContract(ccr) {
+  if (isSierra(ccr)) {
+    throw Error("ContractClassResponse need to be LegacyContractClass (cairo0 response class)");
+  }
+  const contract = ccr;
+  return {
+    ...contract,
+    program: await decompressProgram(contract.program)
+  };
+}
+
+// src/utils/provider.ts
+function wait(delay) {
+  return new Promise((res) => {
+    setTimeout(res, delay);
+  });
+}
+async function createSierraContractClass(contract) {
+  const result = { ...contract };
+  delete result.sierra_program_debug_info;
+  result.abi = formatSpaces(stringify2(contract.abi));
+  result.sierra_program = formatSpaces(stringify2(contract.sierra_program));
+  result.sierra_program = await compressProgram(result.sierra_program);
+  return result;
+}
+async function parseContract(contract) {
+  const parsedContract = isString(contract) ? parse2(contract) : contract;
+  if (!isSierra(contract)) {
+    return {
+      ...parsedContract,
+      ..."program" in parsedContract && {
+        program: await compressProgram(parsedContract.program)
+      }
+    };
+  }
+  return await createSierraContractClass(parsedContract);
+}
+function extractAbi(contract) {
+  return isString(contract.abi) ? parse2(contract.abi) : contract.abi;
+}
+var getDefaultNodeUrl = (networkName, rpcVersion) => {
+  logger.info("Using default public node url, please provide nodeUrl in provider options!");
+  const rpcNodes = getDefaultNodes(rpcVersion ?? config.get("rpcVersion"));
+  const nodes = rpcNodes[networkName ?? _NetworkName.SN_SEPOLIA];
+  const randIdx = Math.floor(Math.random() * nodes.length);
+  return nodes[randIdx];
+};
+function getDefaultNodes(rpcVersion) {
+  const apiVersion = toApiVersion(rpcVersion);
+  return Object.fromEntries(
+    Object.entries(RPC_DEFAULT_NODES).map(([key, urls]) => [
+      key,
+      urls.map((url) => `${url}${apiVersion}`)
+    ])
+  );
+}
+function getSupportedRpcVersions() {
+  return [...new Set(Object.values(_SupportedRpcVersion))];
+}
+var validBlockTags = Object.values(BlockTag);
+var Block = class {
+  /**
+   * @param {BlockIdentifier} hash if not null, contains the block hash
+   */
+  hash = null;
+  /**
+   * @param {BlockIdentifier} number if not null, contains the block number
+   */
+  number = null;
+  /**
+   * @param {BlockIdentifier} tag if not null, contains "pre_confirmed" or "latest"
+   */
+  tag = null;
+  setIdentifier(__identifier) {
+    if (isString(__identifier)) {
+      if (isDecimalString2(__identifier)) {
+        this.number = parseInt(__identifier, 10);
+      } else if (isHex(__identifier)) {
+        this.hash = __identifier;
+      } else if (validBlockTags.includes(__identifier)) {
+        this.tag = __identifier;
+      } else {
+        throw TypeError(`Block identifier unmanaged: ${__identifier}`);
+      }
+    } else if (isBigInt(__identifier)) {
+      this.hash = toHex(__identifier);
+    } else if (isNumber(__identifier)) {
+      this.number = __identifier;
+    } else {
+      this.tag = BlockTag.LATEST;
+    }
+    if (isNumber(this.number) && this.number < 0) {
+      throw TypeError(`Block number (${this.number}) can't be negative`);
+    }
+  }
+  /**
+   * Create a Block instance
+   * @param {BlockIdentifier} _identifier  hex string and BigInt are detected as block hashes.
+   * decimal string and number are detected as block numbers.
+   * text string are detected as block tag.
+   * null is considered as a 'latest' block tag.
+   */
+  constructor(_identifier) {
+    this.setIdentifier(_identifier);
+  }
+  // TODO: fix any
+  /**
+   * @returns {any} the identifier as a string
+   * @example
+   * ```typescript
+   * const result = new provider.Block(123456n).queryIdentifier;
+   * // result = "blockHash=0x1e240"
+   * ```
+   */
+  get queryIdentifier() {
+    if (this.number !== null) {
+      return `blockNumber=${this.number}`;
+    }
+    if (this.hash !== null) {
+      return `blockHash=${this.hash}`;
+    }
+    return `blockNumber=${this.tag}`;
+  }
+  // TODO: fix any
+  /**
+   * @returns {any} the identifier as an object
+   * @example
+   * ```typescript
+   * const result = new provider.Block(56789).identifier;
+   * // result = { block_number: 56789 }
+   * ```
+   */
+  get identifier() {
+    if (this.number !== null) {
+      return { block_number: this.number };
+    }
+    if (this.hash !== null) {
+      return { block_hash: this.hash };
+    }
+    return this.tag;
+  }
+  /**
+   * change the identifier of an existing Block instance
+   * @example
+   * ```typescript
+   * const myBlock = new provider.Block("latest");
+   * myBlock.identifier ="0x3456789abc";
+   * const result = myBlock.identifier;
+   * // result = { block_hash: '0x3456789abc' }
+   * ```
+   */
+  set identifier(_identifier) {
+    this.setIdentifier(_identifier);
+  }
+  valueOf = () => this.number;
+  toString = () => this.hash;
+};
+
+// src/utils/eventEmitter.ts
+var EventEmitter = class {
+  listeners = {};
+  on(event, listener) {
+    if (!this.listeners[event]) {
+      this.listeners[event] = [];
+    }
+    this.listeners[event].push(listener);
+  }
+  off(event, listener) {
+    if (!this.listeners[event]) {
+      return;
+    }
+    this.listeners[event] = this.listeners[event].filter((l) => l !== listener);
+  }
+  emit(event, data) {
+    if (this.listeners[event]) {
+      this.listeners[event].forEach((listener) => listener(data));
+    }
+  }
+  clear() {
+    this.listeners = {};
+  }
+};
+
+// src/channel/ws/subscription.ts
+var Subscription = class {
+  /**
+   * The channel that created this subscription.
+   * @internal
+   */
+  channel;
+  /**
+   * The JSON-RPC method used to create this subscription.
+   * @internal
+   */
+  method;
+  /**
+   * The parameters used to create this subscription.
+   * @internal
+   */
+  params;
+  /**
+   * The unique identifier for this subscription.
+   * @internal
+   */
+  id;
+  events = new EventEmitter();
+  buffer = [];
+  maxBufferSize;
+  handler = null;
+  _isClosed = false;
+  // The unsubscribe request currently on the wire, shared by concurrent callers.
+  pendingUnsubscribe = null;
+  /**
+   * @internal
+   * @param options - Subscription configuration options
+   */
+  constructor(options) {
+    this.channel = options.channel;
+    this.method = options.method;
+    this.params = options.params ?? {};
+    this.id = options.id;
+    this.maxBufferSize = options.maxBufferSize;
+  }
+  /**
+   * Indicates if the subscription has been closed.
+   * @returns {boolean} `true` if unsubscribed, `false` otherwise.
+   */
+  get isClosed() {
+    return this._isClosed;
+  }
+  /**
+   * Registers a listener for this subscription's closure, whatever causes it: an explicit
+   * `unsubscribe()`, or the channel giving up on re-establishing it after a reconnection.
+   *
+   * The second case is the reason this exists. A subscription killed by a refused restore stops
+   * delivering while the connection stays up, so the transport's `statechange` says nothing about
+   * it and a consumer would wait forever on events that can no longer come.
+   *
+   * @param listener - Called once, when the subscription closes.
+   * @returns the detach function, so the pair matches `useSyncExternalStore`'s subscribe contract.
+   */
+  onClose(listener) {
+    if (this._isClosed) {
+      listener();
+      return () => {
+      };
+    }
+    this.events.on("unsubscribe", listener);
+    return () => {
+      this.events.off("unsubscribe", listener);
+    };
+  }
+  /**
+   * Closes the subscription locally, without contacting the node.
+   *
+   * Used when the channel knows the subscription is gone and cannot be recovered — a
+   * re-subscribe refused after a reconnection, for instance. Without it the object would keep
+   * reporting itself as open while no event could ever reach its handler again.
+   * @internal
+   */
+  _markClosed() {
+    if (this._isClosed) return;
+    this._isClosed = true;
+    this.handler = null;
+    this.events.emit("unsubscribe", void 0);
+    this.events.clear();
+  }
+  /**
+   * Internal method to handle incoming events from the WebSocket channel.
+   * If a handler is attached, it's invoked immediately. Otherwise, the event is buffered.
+   * @internal
+   * @param {T} data - The event data.
+   */
+  _handleEvent(data) {
+    if (this.handler) {
+      this.handler(data);
+    } else {
+      if (this.buffer.length >= this.maxBufferSize) {
+        const droppedEvent = this.buffer.shift();
+        logger.warn(`Subscription ${this.id}: Buffer full. Dropping oldest event:`, droppedEvent);
+      }
+      this.buffer.push(data);
+    }
+  }
+  /**
+   * Attaches a handler function to be called for each event.
+   *
+   * When a handler is attached, any buffered events will be passed to it sequentially.
+   * Subsequent events will be passed directly as they arrive.
+   *
+   * Re-attaching the **same** handler is a no-op: React StrictMode invokes an effect twice, and
+   * throwing there would fail a correct component. A *different* handler while one is attached is
+   * still refused — that is a genuine mistake, not a lifecycle artefact.
+   *
+   * @param {(data: T) => void} handler - The function to call with event data.
+   * @throws {Error} If a different handler is already attached to this subscription.
+   */
+  on(handler) {
+    if (this._isClosed) return;
+    if (this.handler === handler) return;
+    if (this.handler) {
+      throw new Error("A handler is already attached to this subscription.");
+    }
+    this.handler = handler;
+    while (this.buffer.length > 0) {
+      const event = this.buffer.shift();
+      if (event) {
+        this.handler(event);
+      }
+    }
+  }
+  /**
+   * Detaches the current handler.
+   *
+   * Events arriving afterwards are buffered again, so a later `on()` receives them: the
+   * subscription itself is untouched, only the delivery is paused. This is what a React effect
+   * cleanup needs — dropping the handler without tearing down a subscription the component may
+   * re-attach to on its next mount.
+   */
+  off() {
+    this.handler = null;
+  }
+  /**
+   * Sends an unsubscribe request to the node and cleans up local resources.
+   * @returns {Promise<boolean>} A Promise that resolves to `true` if the unsubscription was successful.
+   */
+  async unsubscribe() {
+    if (this._isClosed) {
+      return true;
+    }
+    if (this.pendingUnsubscribe) {
+      return this.pendingUnsubscribe;
     }
-    return obj;
+    this.pendingUnsubscribe = (async () => {
+      try {
+        const success = await this.channel.unsubscribe(this.id);
+        if (success) {
+          this._isClosed = true;
+          this.handler = null;
+          this.channel.removeSubscription(this.id);
+          this.events.emit("unsubscribe", void 0);
+          this.events.clear();
+        }
+        return success;
+      } finally {
+        this.pendingUnsubscribe = null;
+      }
+    })();
+    return this.pendingUnsubscribe;
+  }
+};
+
+// src/channel/ws/subscriptionChannel.ts
+var isReconnectAware = (transport) => typeof transport.onReconnected === "function";
+var SubscriptionChannel = class {
+  id = "RPC0.10.2-subscriptions";
+  channelSpecVersion = _SupportedRpcVersion.v0_10_2;
+  transport;
+  maxBufferSize;
+  /** Live subscriptions, keyed by the id the node issued. Always a string — see spec §6. */
+  activeSubscriptions = /* @__PURE__ */ new Map();
+  /**
+   * Callers blocked in `waitForUnsubscription`, keyed by subscription id.
+   *
+   * Held here rather than as event listeners because an `unsubscribe` event only ever announces
+   * success: a waiter attached to it cannot learn that the node refused, or that the connection
+   * went away, and would wait forever with no timeout of its own to fall back on.
+   */
+  unsubscribeWaiters = /* @__PURE__ */ new Map();
+  /**
+   * Events that arrived before their subscription finished registering.
+   *
+   * The node can push the first event in the same burst as the reply carrying the subscription
+   * id, while the continuation that registers the handle has not run yet. Holding the event and
+   * handing it over at registration is deterministic; the alternative — waiting a fixed number
+   * of microtasks — only works for one particular call depth and breaks silently when a layer
+   * is added.
+   */
+  earlyEvents = /* @__PURE__ */ new Map();
+  /**
+   * Subscribe requests currently on the wire.
+   *
+   * An unknown subscription id is only worth holding while one of these is outstanding.
+   * Otherwise it belongs to a subscription that is already gone — the node pushing one last
+   * event after an unsubscribe — and holding it would leak.
+   */
+  pendingSubscribes = 0;
+  /** Its own request numbering, renumbered by the transport before it reaches the wire. */
+  requestId = 0;
+  detachNotifications;
+  detachState;
+  detachReconnected = () => {
   };
-  return convertBigIntToHex(resourceBoundsBN);
-}
-function resourceBoundsToBigInt(resourceBounds) {
-  const convertStringToBigInt = (obj) => {
-    if (isString(obj)) {
-      return BigInt(obj);
+  constructor(options) {
+    this.transport = options.transport;
+    this.maxBufferSize = options.maxBufferSize ?? 1e3;
+    this.detachNotifications = this.transport.on("notification", this.handleNotification);
+    this.detachState = this.transport.on("statechange", this.handleStateChange);
+    if (isReconnectAware(this.transport)) {
+      this.detachReconnected = this.transport.onReconnected(() => this.restore());
     }
-    if (isObject(obj)) {
-      const result = {};
-      Object.keys(obj).forEach((key) => {
-        result[key] = convertStringToBigInt(obj[key]);
+  }
+  /**
+   * Sends one JSON-RPC call and returns its result, applying the same error contract as
+   * `RpcChannel`: a protocol error becomes a typed `RpcError`.
+   */
+  async send(method, params) {
+    this.requestId += 1;
+    const response = await this.transport.request({
+      id: this.requestId,
+      jsonrpc: "2.0",
+      method,
+      ...params && { params }
+    });
+    if (response.error) {
+      throw new RpcError(response.error, method, params);
+    }
+    return response.result;
+  }
+  /** Registers a new subscription and returns the handle the caller keeps. */
+  async openSubscription(method, rpcParams) {
+    this.pendingSubscribes += 1;
+    try {
+      const subId = await this.send(method, rpcParams);
+      const subscription = new Subscription({
+        channel: this,
+        method,
+        params: rpcParams,
+        id: subId,
+        maxBufferSize: this.maxBufferSize
       });
-      return result;
+      this.activeSubscriptions.set(subId, subscription);
+      const early = this.earlyEvents.get(subId);
+      if (early) {
+        this.earlyEvents.delete(subId);
+        early.forEach((event) => subscription._handleEvent(event));
+      }
+      return subscription;
+    } finally {
+      this.pendingSubscribes -= 1;
+      if (this.pendingSubscribes === 0 && this.earlyEvents.size > 0) {
+        this.earlyEvents.forEach(
+          (_events, id) => logger.warn(`SubscriptionChannel: Received event for untracked subscription ID: ${id}.`)
+        );
+        this.earlyEvents.clear();
+      }
     }
-    return obj;
-  };
-  return convertStringToBigInt(resourceBounds);
-}
-
-// src/utils/contractLoader.ts
-function isFileSystemAvailable() {
-  try {
-    return typeof __require !== "undefined" && typeof __require.resolve === "function";
-  } catch {
-    logger.info("isFileSystemAvailable: false");
-    return false;
   }
-}
-function contractLoader(input, compiledClassHash) {
-  if (typeof File !== "undefined" && (input instanceof File || Array.isArray(input))) {
-    return loadFromFileAPI(input, compiledClassHash);
+  /**
+   * Subscribes to new block headers.
+   * @param params - Where to start from. Defaults to the latest block; a block number or hash
+   * replays from there, up to 1024 blocks back.
+   * @returns A `Subscription` delivering one block header per new block.
+   * @example
+   * ```typescript
+   * const sub = await channel.subscribeNewHeads();
+   * sub.on((header) => console.log(header.block_number, header.block_hash));
+   * ```
+   */
+  async subscribeNewHeads(params = {}) {
+    const method = "starknet_subscribeNewHeads";
+    const rpcParams = {
+      block_id: params.blockIdentifier ? new Block(params.blockIdentifier).identifier : void 0
+    };
+    return this.openSubscription(method, rpcParams);
   }
-  if (typeof input === "string") {
-    if (!isFileSystemAvailable()) {
-      throw new Error(
-        'contractLoader with string paths is only available in Node.js environments. In browsers, please use File objects from <input type="file"> or drag-and-drop. Example: await contractLoader(fileInput.files[0])'
-      );
+  /**
+   * Subscribes to events matching a given filter.
+   * @param params - Filters on the emitting address, the event keys, the starting block and the
+   * finality status. All are optional: without any, every event of the network is delivered.
+   * @returns A `Subscription` delivering one emitted event at a time.
+   * @example
+   * ```typescript
+   * const sub = await channel.subscribeEvents({
+   *   fromAddress: '0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7',
+   *   finalityStatus: 'ACCEPTED_ON_L2',
+   * });
+   * sub.on((event) => console.log(event.from_address, event.keys, event.data));
+   * ```
+   */
+  async subscribeEvents(params = {}) {
+    const method = "starknet_subscribeEvents";
+    let from_address;
+    if (params.fromAddress !== void 0) {
+      from_address = Array.isArray(params.fromAddress) ? bigNumberishArrayToHexadecimalStringArray(params.fromAddress) : toHex(params.fromAddress);
     }
-    return loadFromFileSystem(input, compiledClassHash);
+    const rpcParams = {
+      from_address,
+      keys: params.keys,
+      block_id: params.blockIdentifier ? new Block(params.blockIdentifier).identifier : void 0,
+      finality_status: params.finalityStatus
+    };
+    return this.openSubscription(method, rpcParams);
   }
-  throw new Error(
-    "Invalid input type. Expected string (Node.js path) or File/File[] (browser File API)"
-  );
-}
-function loadFromFileSystem(contractPath, compiledClassHash) {
-  const fs = __require("fs");
-  const path = __require("path");
-  const resolvedPath = path.resolve(contractPath);
-  let dirPath;
-  let specifiedSierraFile;
-  let specifiedCasmFile;
-  const stats = fs.statSync(resolvedPath);
-  if (stats.isFile()) {
-    dirPath = path.dirname(resolvedPath);
-    const fileName = path.basename(resolvedPath);
-    if (fileName.endsWith(".sierra.json") || fileName.endsWith(".json") && !fileName.endsWith(".casm")) {
-      specifiedSierraFile = fileName;
-    } else if (fileName.endsWith(".casm")) {
-      specifiedCasmFile = fileName;
-    } else {
-      throw new Error(
-        `Invalid file type. Expected .json, .sierra.json, or .casm file, got: ${fileName}`
+  /**
+   * Subscribes to status updates for a specific transaction.
+   * @param params - The `transactionHash` to follow, and optionally the block to start from.
+   * @returns A `Subscription` delivering the transaction's current status, then every change.
+   * @example
+   * ```typescript
+   * const sub = await channel.subscribeTransactionStatus({ transactionHash: '0x0123...' });
+   * sub.on((update) => console.log(update.status.finality_status));
+   * ```
+   */
+  async subscribeTransactionStatus(params) {
+    const method = "starknet_subscribeTransactionStatus";
+    const rpcParams = {
+      transaction_hash: toHex(params.transactionHash),
+      block_id: params.blockIdentifier ? new Block(params.blockIdentifier).identifier : void 0
+    };
+    return this.openSubscription(method, rpcParams);
+  }
+  /**
+   * Subscribes to new transaction receipts.
+   *
+   * Same filters as {@link subscribeNewTransactions}, but the full receipt is delivered instead of
+   * the transaction.
+   * @param params - Optional filters on the finality status and on the sender addresses.
+   * @returns A `Subscription` delivering one receipt per matching transaction.
+   * @example
+   * ```typescript
+   * const sub = await channel.subscribeNewTransactionReceipts({
+   *   finalityStatus: ['ACCEPTED_ON_L2'],
+   * });
+   * sub.on((receipt) => console.log(receipt.transaction_hash, receipt.execution_status));
+   * ```
+   */
+  async subscribeNewTransactionReceipts(params = {}) {
+    const method = "starknet_subscribeNewTransactionReceipts";
+    const rpcParams = {
+      finality_status: params.finalityStatus,
+      sender_address: params.senderAddress && bigNumberishArrayToHexadecimalStringArray(params.senderAddress)
+    };
+    return this.openSubscription(method, rpcParams);
+  }
+  /**
+   * Subscribes to new transactions and to their finality status changes.
+   *
+   * One event is fired per status update, so the same transaction can be delivered several times.
+   * @param params - Optional filters on the finality status (defaults to `['ACCEPTED_ON_L2']`) and
+   * on the sender addresses.
+   * @returns A `Subscription` delivering one transaction per matching status update.
+   * @example
+   * ```typescript
+   * const sub = await channel.subscribeNewTransactions({
+   *   finalityStatus: ['RECEIVED', 'ACCEPTED_ON_L2'],
+   * });
+   * sub.on((tx) => console.log(tx.transaction_hash, tx.finality_status));
+   * ```
+   */
+  async subscribeNewTransactions(params = {}) {
+    const method = "starknet_subscribeNewTransactions";
+    const rpcParams = {
+      finality_status: params.finalityStatus,
+      sender_address: params.senderAddress && bigNumberishArrayToHexadecimalStringArray(params.senderAddress),
+      tags: params.tags
+    };
+    return this.openSubscription(method, rpcParams);
+  }
+  handleNotification = (notification) => {
+    const { subscription_id: subscriptionId, result } = notification.params;
+    if (subscriptionId === void 0) return;
+    const subscription = this.activeSubscriptions.get(subscriptionId);
+    if (subscription) {
+      subscription._handleEvent(result);
+      return;
+    }
+    if (this.pendingSubscribes === 0) {
+      logger.warn(
+        `SubscriptionChannel: Received event for untracked subscription ID: ${subscriptionId}.`
       );
+      return;
     }
-  } else if (stats.isDirectory()) {
-    dirPath = resolvedPath;
-  } else {
-    throw new Error(`Path is neither a file nor a directory: ${contractPath}`);
-  }
-  const files = fs.readdirSync(dirPath);
-  let sierraFile;
-  let casmFile;
-  if (specifiedSierraFile) {
-    sierraFile = specifiedSierraFile;
-    const baseName = sierraFile.replace(/\.sierra\.json$/, "").replace(/\.json$/, "");
-    casmFile = files.find((f) => f === `${baseName}.casm`);
-  } else if (specifiedCasmFile) {
-    casmFile = specifiedCasmFile;
-    const baseName = casmFile.replace(/\.casm$/, "");
-    sierraFile = files.find((f) => f === `${baseName}.sierra.json`) || files.find((f) => f === `${baseName}.json`);
-  } else {
-    const sierraFiles = files.filter(
-      (f) => f.endsWith(".sierra.json") || f.endsWith(".json") && !f.endsWith(".casm")
+    const buffered = this.earlyEvents.get(subscriptionId) ?? [];
+    buffered.push(result);
+    this.earlyEvents.set(subscriptionId, buffered);
+  };
+  handleStateChange = () => {
+    const state = this.transport.getState();
+    if (state === "open" || state === "connecting") return;
+    this.rejectUnsubscribeWaiters("the connection was closed");
+  };
+  /**
+   * Re-issues every live subscription on a freshly reconnected socket.
+   *
+   * A subscription that cannot be re-established is **not** put back in the map, and its handle
+   * is closed: otherwise it would keep reporting itself as live while nothing could ever reach
+   * its handler again.
+   */
+  async restore() {
+    const previous = Array.from(this.activeSubscriptions.values());
+    this.activeSubscriptions.clear();
+    await Promise.all(
+      previous.map(async (subscription) => {
+        try {
+          const newId = await this.send(subscription.method, subscription.params);
+          subscription.id = newId;
+          this.activeSubscriptions.set(newId, subscription);
+          logger.info(`Subscription ${subscription.method} restored with new ID: ${newId}`);
+        } catch (error) {
+          logger.error(`Failed to restore subscription ${subscription.method}:`, error);
+          subscription._markClosed();
+        }
+      })
     );
-    if (sierraFiles.length === 0) {
-      throw new Error(`No .sierra.json file found in ${dirPath}. Sierra file is required.`);
+  }
+  /**
+   * Unsubscribes from a Starknet subscription.
+   *
+   * Prefer `subscription.unsubscribe()`.
+   * @internal
+   */
+  async unsubscribe(subscriptionId) {
+    let status;
+    try {
+      status = await this.send("starknet_unsubscribe", {
+        subscription_id: subscriptionId
+      });
+    } catch (error) {
+      this.settleUnsubscribeWaiters(subscriptionId, error);
+      throw error;
     }
-    if (sierraFiles.length > 1) {
-      throw new Error(
-        `Multiple .sierra.json files found in ${dirPath}: ${sierraFiles.join(", ")}. Please specify which file to use.`
+    if (status) {
+      this.settleUnsubscribeWaiters(subscriptionId);
+    } else {
+      this.settleUnsubscribeWaiters(
+        subscriptionId,
+        new Error(`Node refused to unsubscribe subscription ${subscriptionId}`)
       );
     }
-    [sierraFile] = sierraFiles;
-    const baseName = sierraFile.replace(/\.sierra\.json$/, "").replace(/\.json$/, "");
-    casmFile = files.find((f) => f === `${baseName}.casm`);
+    return status;
   }
-  if (!sierraFile) {
-    throw new Error(`No .sierra.json file found in ${dirPath}. Sierra file is required.`);
+  /**
+   * Removes a subscription from the active map.
+   * @internal
+   */
+  removeSubscription(subscriptionId) {
+    this.activeSubscriptions.delete(subscriptionId);
+  }
+  /**
+   * The live subscriptions, keyed by the id the node issued.
+   * @internal Exposed for the `WebSocketChannel` compatibility façade.
+   */
+  get subscriptions() {
+    return this.activeSubscriptions;
+  }
+  /** Resolves when a specific subscription is successfully unsubscribed. */
+  waitForUnsubscription(targetId) {
+    return new Promise((resolve, reject) => {
+      const waiters = this.unsubscribeWaiters.get(targetId) ?? /* @__PURE__ */ new Set();
+      waiters.add({ resolve, reject });
+      this.unsubscribeWaiters.set(targetId, waiters);
+    });
   }
-  const sierraPath = path.join(dirPath, sierraFile);
-  const sierraContent = parse2(fs.readFileSync(sierraPath, "utf8"));
-  if (casmFile) {
-    const casmPath = path.join(dirPath, casmFile);
-    const casmContent = parse2(fs.readFileSync(casmPath, "utf8"));
-    return {
-      sierra: sierraContent,
-      casm: casmContent,
-      compiler: casmContent.compiler_version
-    };
+  settleUnsubscribeWaiters(subscriptionId, error) {
+    const waiters = this.unsubscribeWaiters.get(subscriptionId);
+    if (!waiters) return;
+    this.unsubscribeWaiters.delete(subscriptionId);
+    waiters.forEach((waiter) => error ? waiter.reject(error) : waiter.resolve());
   }
-  if (!compiledClassHash) {
-    throw new Error(
-      `No .casm file found for ${sierraFile} and no compiledClassHash provided. Either provide a .casm file or pass compiledClassHash as second parameter.`
+  rejectUnsubscribeWaiters(reason) {
+    if (this.unsubscribeWaiters.size === 0) return;
+    Array.from(this.unsubscribeWaiters.keys()).forEach(
+      (id) => this.settleUnsubscribeWaiters(
+        id,
+        new WebSocketNotConnectedError(`Subscription ${id} was never unsubscribed: ${reason}`)
+      )
     );
   }
-  return {
-    sierra: sierraContent,
-    compiledClassHash
-  };
+  /**
+   * Stops listening to the transport and settles anything still waiting.
+   *
+   * Does **not** close the socket: this channel borrowed it.
+   */
+  close() {
+    this.detachNotifications();
+    this.detachState();
+    this.detachReconnected();
+    this.rejectUnsubscribeWaiters("the subscription channel was closed");
+    this.activeSubscriptions.forEach((subscription) => subscription._markClosed());
+    this.activeSubscriptions.clear();
+    this.earlyEvents.clear();
+  }
+};
+
+// src/channel/transport/http.ts
+function postJsonRpc(options, body) {
+  return options.baseFetch(options.nodeUrl, {
+    method: "POST",
+    body: stringify2(body),
+    headers: options.headers
+  });
 }
-async function loadFromFileAPI(input, compiledClassHash) {
-  const files = Array.isArray(input) ? input : [input];
-  if (files.length === 0) {
-    throw new Error("No files provided");
+var HttpTransport = class {
+  options;
+  constructor(options) {
+    this.options = options;
   }
-  const sierraFiles = files.filter(
-    (file) => file.name.endsWith(".sierra.json") || file.name.endsWith(".json") && !file.name.endsWith(".casm")
-  );
-  const casmFiles = files.filter((file) => file.name.endsWith(".casm"));
-  if (sierraFiles.length > 1) {
-    throw new Error(
-      `Multiple .sierra.json files provided: ${sierraFiles.map((f) => f.name).join(", ")}. Please provide only one sierra file.`
-    );
+  async request(body) {
+    const response = await postJsonRpc(this.options, body);
+    return response.json();
   }
-  if (casmFiles.length > 1) {
-    throw new Error(
-      `Multiple .casm files provided: ${casmFiles.map((f) => f.name).join(", ")}. Please provide only one casm file.`
+};
+
+// src/utils/connect/ws.ts
+var ws_default = typeof WebSocket !== "undefined" && WebSocket || typeof globalThis !== "undefined" && globalThis.WebSocket || typeof window !== "undefined" && window.WebSocket && window.WebSocket.bind(window) || typeof global !== "undefined" && global.WebSocket || class {
+  constructor() {
+    throw new LibraryError(
+      "WebSocket module not detected, use the 'websocket' constructor parameter to set a compatible connection"
     );
   }
-  const sierraFile = sierraFiles[0];
-  const casmFile = casmFiles[0];
-  if (!sierraFile) {
-    throw new Error(
-      `No .sierra.json file found in provided files. Sierra file is required. Provided files: ${files.map((f) => f.name).join(", ")}`
-    );
+};
+
+// src/channel/transport/ws.ts
+var WsTransport = class {
+  /** The URL of the WebSocket RPC node. */
+  nodeUrl;
+  /**
+   * The underlying socket. Owned by this transport — close it through `close()`.
+   *
+   * Not `readonly` because a subclass may replace it on a reconnection. This class never does:
+   * one `WsTransport` is one socket, which is what its own tests rely on.
+   */
+  socket;
+  /** Kept so a subclass can build a replacement socket the same way this one was built. */
+  WsImplementation;
+  requestTimeout;
+  state = "connecting";
+  listeners = {
+    statechange: /* @__PURE__ */ new Set(),
+    notification: /* @__PURE__ */ new Set(),
+    open: /* @__PURE__ */ new Set(),
+    close: /* @__PURE__ */ new Set(),
+    error: /* @__PURE__ */ new Set(),
+    message: /* @__PURE__ */ new Set()
+  };
+  /**
+   * Resolves once the socket is open, rejects if the connection never comes up.
+   *
+   * Created on first use rather than in the constructor, so the constructor starts no
+   * asynchronous work and a failed connection rejects inside a call the caller can wrap in
+   * `try/catch` instead of becoming an unhandled rejection.
+   */
+  ready;
+  /** One entry per request on the wire, keyed by the id this transport put on it. */
+  pending = /* @__PURE__ */ new Map();
+  /**
+   * Wire-level request counter.
+   *
+   * Owned here rather than by the channels: each channel starts numbering at 1, so two of them
+   * sharing one socket would both emit `1` and get cross-matched replies — silently, and
+   * non-deterministically.
+   */
+  wireId = 0;
+  constructor(options) {
+    this.nodeUrl = options.nodeUrl;
+    this.requestTimeout = options.requestTimeout ?? 6e4;
+    this.WsImplementation = options.websocket || config.get("websocket") || ws_default;
+    this.socket = new this.WsImplementation(this.nodeUrl);
+    if (this.socket.readyState === ws_default.OPEN) this.state = "open";
+    this.attach(this.socket);
   }
-  const sierraContent = parse2(await readFileAsText(sierraFile));
-  if (casmFile) {
-    const casmContent = parse2(await readFileAsText(casmFile));
-    return {
-      sierra: sierraContent,
-      casm: casmContent,
-      compiler: casmContent.compiler_version
-    };
+  attach(socket) {
+    socket.addEventListener("open", this.handleOpen);
+    socket.addEventListener("message", this.handleMessage);
+    socket.addEventListener("close", this.handleClose);
+    socket.addEventListener("error", this.handleError);
   }
-  if (!compiledClassHash) {
-    throw new Error(
-      "No .casm file found in provided files and no compiledClassHash provided. Either provide a .casm file or pass compiledClassHash as second parameter."
-    );
+  detach(socket) {
+    socket.removeEventListener("open", this.handleOpen);
+    socket.removeEventListener("message", this.handleMessage);
+    socket.removeEventListener("close", this.handleClose);
+    socket.removeEventListener("error", this.handleError);
   }
-  return {
-    sierra: sierraContent,
-    compiledClassHash
+  /**
+   * Adopts a replacement socket.
+   *
+   * The readiness latch is discarded with the old socket: it records that *that* connection came
+   * up, and reusing it would let a request be written to a socket still handshaking.
+   *
+   * Requests already on the wire are not settled here — `handleClose` has done that for the
+   * socket that went away, since nothing on a dead socket can still be answered.
+   */
+  swapSocket(next) {
+    this.detach(this.socket);
+    this.socket = next;
+    this.ready = void 0;
+    this.attach(next);
+  }
+  handleOpen = (event) => {
+    this.onOpened();
+    this.emit("open", event);
   };
-}
-function readFileAsText(file) {
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onload = (event) => {
-      const content = event.target?.result;
-      if (typeof content === "string") {
-        resolve(content);
-      } else {
-        reject(new Error(`Failed to read file ${file.name} as text`));
-      }
-    };
-    reader.onerror = () => {
-      reject(new Error(`Failed to read file ${file.name}: ${reader.error?.message}`));
-    };
-    reader.readAsText(file);
-  });
-}
-
-// src/utils/contract.ts
-function isSierra(contract) {
-  const compiledContract = isString(contract) ? parse2(contract) : contract;
-  return "sierra_program" in compiledContract;
-}
-function extractContractHashes(payload, starknetVersion) {
-  const response = { ...payload };
-  if (isSierra(payload.contract)) {
-    if (!payload.compiledClassHash && payload.casm) {
-      response.compiledClassHash = computeCompiledClassHash(payload.casm, starknetVersion);
-    }
-    if (!response.compiledClassHash)
-      throw new Error(
-        "Extract compiledClassHash failed, provide (CairoAssembly).casm file or compiledClassHash"
-      );
+  handleClose = (event) => {
+    this.detach(this.socket);
+    this.rejectPending("the connection was closed");
+    this.onClosed(event);
+    this.emit("close", event);
+  };
+  /**
+   * What happens once a socket is open. Overridden by a reconnecting subclass, which also has a
+   * retry counter to reset and a queue to flush.
+   */
+  onOpened() {
+    this.setState("open");
   }
-  response.classHash = payload.classHash ?? computeContractClassHash(payload.contract);
-  if (!response.classHash)
-    throw new Error("Extract classHash failed, provide (CompiledContract).json file or classHash");
-  return response;
-}
-async function contractClassResponseToLegacyCompiledContract(ccr) {
-  if (isSierra(ccr)) {
-    throw Error("ContractClassResponse need to be LegacyContractClass (cairo0 response class)");
+  /**
+   * What happens once a socket is gone. This class stays closed; a reconnecting subclass starts
+   * an attempt instead.
+   */
+  onClosed(_event) {
+    this.setState("closed");
   }
-  const contract = ccr;
-  return {
-    ...contract,
-    program: await decompressProgram(contract.program)
+  handleMessage = (event) => {
+    if (!isString(event.data)) {
+      logger.warn("WsTransport: received non-string message data:", event.data);
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(event.data);
+    } catch (error) {
+      logger.error(`WsTransport: error parsing incoming message: ${event.data}, Error: ${error}`);
+      return;
+    }
+    const frames = Array.isArray(parsed) ? parsed : [parsed];
+    frames.forEach((frame) => this.dispatch(frame));
+    this.emit("message", event);
   };
-}
-
-// src/utils/eth.ts
-var eth_exports = {};
-__export(eth_exports, {
-  ethRandomPrivateKey: () => ethRandomPrivateKey,
-  validateAndParseEthAddress: () => validateAndParseEthAddress
-});
-import { secp256k1 } from "@noble/curves/secp256k1";
-function ethRandomPrivateKey() {
-  return sanitizeHex(buf2hex(secp256k1.utils.randomPrivateKey()));
-}
-function validateAndParseEthAddress(address) {
-  assertInRange(address, ZERO, 2n ** 160n - 1n, "Ethereum Address ");
-  const result = addHexPrefix(removeHexPrefix(toHex(address)).padStart(40, "0"));
-  assert(Boolean(result.match(/^(0x)?[0-9a-f]{40}$/)), "Invalid Ethereum Address Format");
-  return result;
-}
-
-// src/utils/connect/fetch.ts
-var fetch_default = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" && globalThis.fetch.bind(globalThis) || typeof window !== "undefined" && typeof window.fetch !== "undefined" && window.fetch.bind(window) || typeof global !== "undefined" && typeof global.fetch !== "undefined" && global.fetch.bind(global) || (() => {
-  throw new LibraryError(
-    "'fetch()' not detected, use the 'baseFetch' constructor parameter to set it"
-  );
-});
-
-// src/utils/provider.ts
-var provider_exports = {};
-__export(provider_exports, {
-  Block: () => Block,
-  createSierraContractClass: () => createSierraContractClass,
-  extractAbi: () => extractAbi,
-  getDefaultNodeUrl: () => getDefaultNodeUrl,
-  getDefaultNodes: () => getDefaultNodes,
-  getSupportedRpcVersions: () => getSupportedRpcVersions,
-  parseContract: () => parseContract,
-  validBlockTags: () => validBlockTags,
-  wait: () => wait
-});
-function wait(delay) {
-  return new Promise((res) => {
-    setTimeout(res, delay);
-  });
-}
-async function createSierraContractClass(contract) {
-  const result = { ...contract };
-  delete result.sierra_program_debug_info;
-  result.abi = formatSpaces(stringify2(contract.abi));
-  result.sierra_program = formatSpaces(stringify2(contract.sierra_program));
-  result.sierra_program = await compressProgram(result.sierra_program);
-  return result;
-}
-async function parseContract(contract) {
-  const parsedContract = isString(contract) ? parse2(contract) : contract;
-  if (!isSierra(contract)) {
-    return {
-      ...parsedContract,
-      ..."program" in parsedContract && {
-        program: await compressProgram(parsedContract.program)
+  /** Routes one inbound frame: a reply to the request waiting for it, or a notification. */
+  dispatch(frame) {
+    if (isObject(frame) && "id" in frame) {
+      const waiter = this.pending.get(frame.id);
+      if (!waiter) {
+        if ("error" in frame) {
+          logger.error(
+            `WsTransport: node rejected a frame outright: ${stringify2(frame.error)}`
+          );
+          return;
+        }
+        logger.warn(`WsTransport: reply for unknown request id ${frame.id}, dropped.`);
+        return;
       }
-    };
+      this.pending.delete(frame.id);
+      clearTimeout(waiter.timer);
+      waiter.resolve(frame);
+      return;
+    }
+    if (isObject(frame) && "method" in frame) {
+      this.emit("notification", frame);
+      return;
+    }
+    logger.warn("WsTransport: frame is neither a reply nor a notification, dropped.");
+  }
+  handleError = (event) => {
+    logger.warn(`WsTransport: socket error on ${this.nodeUrl}: ${event.type}`);
+    this.onError(event);
+    this.emit("error", event);
+  };
+  /**
+   * What happens on a socket error. This class only logs; a reconnecting subclass treats it as a
+   * failed attempt, because a refused connection may produce an `error` with no `close` behind it.
+   */
+  onError(_event) {
+  }
+  setState(next) {
+    if (this.state === next) return;
+    this.state = next;
+    this.emit("statechange", void 0);
+  }
+  emit(event, payload) {
+    this.listeners[event].forEach((listener) => listener(payload));
+  }
+  /** The current connection state. The `getSnapshot` half of the `useSyncExternalStore` pair. */
+  getState() {
+    return this.state;
+  }
+  /** Whether the socket is open right now. */
+  isConnected() {
+    return this.socket.readyState === ws_default.OPEN;
   }
-  return await createSierraContractClass(parsedContract);
-}
-function extractAbi(contract) {
-  return isString(contract.abi) ? parse2(contract.abi) : contract.abi;
-}
-var getDefaultNodeUrl = (networkName, rpcVersion) => {
-  logger.info("Using default public node url, please provide nodeUrl in provider options!");
-  const rpcNodes = getDefaultNodes(rpcVersion ?? config.get("rpcVersion"));
-  const nodes = rpcNodes[networkName ?? _NetworkName.SN_SEPOLIA];
-  const randIdx = Math.floor(Math.random() * nodes.length);
-  return nodes[randIdx];
-};
-function getDefaultNodes(rpcVersion) {
-  const apiVersion = toApiVersion(rpcVersion);
-  return Object.fromEntries(
-    Object.entries(RPC_DEFAULT_NODES).map(([key, urls]) => [
-      key,
-      urls.map((url) => `${url}${apiVersion}`)
-    ])
-  );
-}
-function getSupportedRpcVersions() {
-  return [...new Set(Object.values(_SupportedRpcVersion))];
-}
-var validBlockTags = Object.values(BlockTag);
-var Block = class {
   /**
-   * @param {BlockIdentifier} hash if not null, contains the block hash
+   * Allocates the next wire id, starting at 0.
+   *
+   * Exposed because a caller may write to the socket itself rather than through `request` —
+   * `WebSocketChannel.send()` is fire-and-forget and correlates nothing. Drawing from this same
+   * sequence is what stops such a write from colliding with a request this transport is
+   * tracking, which would hand one caller the other's reply.
    */
-  hash = null;
+  allocateRequestId() {
+    const id = this.wireId;
+    this.wireId += 1;
+    return id;
+  }
   /**
-   * @param {BlockIdentifier} number if not null, contains the block number
+   * Subscribes to one of the transport's two streams.
+   *
+   * `'statechange'` fires on every connection state transition; `'notification'` fires for
+   * every frame the node pushes on its own.
+   *
+   * @returns the unsubscribe function, which is what `useSyncExternalStore` requires of its
+   * `subscribe` argument.
    */
-  number = null;
+  on(event, listener) {
+    const listeners = this.listeners[event];
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  }
   /**
-   * @param {BlockIdentifier} tag if not null, contains "pre_confirmed" or "latest"
+   * Waits for the socket to be usable.
+   *
+   * A refused connection surfaces as `error`, as `close`, or as both: a browser emits `error`
+   * then `close`, while a gateway turning the connection away may only close it. Settling on
+   * whichever arrives first is what keeps that last case from hanging until `requestTimeout`.
+   *
+   * Registered as listeners rather than assigned to `onopen` / `onerror`, so nothing the
+   * socket's owner installed gets clobbered.
    */
-  tag = null;
-  setIdentifier(__identifier) {
-    if (isString(__identifier)) {
-      if (isDecimalString2(__identifier)) {
-        this.number = parseInt(__identifier, 10);
-      } else if (isHex(__identifier)) {
-        this.hash = __identifier;
-      } else if (validBlockTags.includes(__identifier)) {
-        this.tag = __identifier;
-      } else {
-        throw TypeError(`Block identifier unmanaged: ${__identifier}`);
+  ensureReady() {
+    this.ready ??= new Promise((resolve, reject) => {
+      if (this.socket.readyState === ws_default.OPEN) {
+        resolve();
+        return;
       }
-    } else if (isBigInt(__identifier)) {
-      this.hash = toHex(__identifier);
-    } else if (isNumber(__identifier)) {
-      this.number = __identifier;
-    } else {
-      this.tag = BlockTag.LATEST;
-    }
-    if (isNumber(this.number) && this.number < 0) {
-      throw TypeError(`Block number (${this.number}) can't be negative`);
+      if (this.socket.readyState === ws_default.CLOSING || this.socket.readyState === ws_default.CLOSED) {
+        reject(
+          new WebSocketNotConnectedError(
+            `WebSocket connection to ${this.nodeUrl} is already closed`
+          )
+        );
+        return;
+      }
+      const detach = () => {
+        this.socket.removeEventListener("open", onOpen);
+        this.socket.removeEventListener("error", onFailure);
+        this.socket.removeEventListener("close", onFailure);
+      };
+      const onOpen = () => {
+        detach();
+        resolve();
+      };
+      const onFailure = () => {
+        detach();
+        reject(
+          new WebSocketNotConnectedError(
+            `WebSocket connection to ${this.nodeUrl} was not established`
+          )
+        );
+      };
+      this.socket.addEventListener("open", onOpen);
+      this.socket.addEventListener("error", onFailure);
+      this.socket.addEventListener("close", onFailure);
+    });
+    return this.ready;
+  }
+  async request(body) {
+    if (!this.isConnected()) await this.ensureReady();
+    if (!this.isConnected()) {
+      throw new WebSocketNotConnectedError(`WebSocket to ${this.nodeUrl} is not open`);
+    }
+    const isBatch = Array.isArray(body);
+    const entries = isBatch ? body : [body];
+    const callerIds = /* @__PURE__ */ new Map();
+    const wireEntries = entries.map((entry) => {
+      const wireId = this.allocateRequestId();
+      callerIds.set(wireId, entry.id);
+      return { ...entry, id: wireId };
+    });
+    const replies = wireEntries.map((entry) => this.expect(entry.id, entry.method));
+    try {
+      this.socket.send(stringify2(isBatch ? wireEntries : wireEntries[0]));
+    } catch (error) {
+      wireEntries.forEach(
+        (entry) => this.settle(
+          entry.id,
+          new WebSocketNotConnectedError(`Request ${entry.method} could not be sent: ${error}`)
+        )
+      );
     }
+    const settled = await Promise.all(replies);
+    const restored = settled.map(
+      (reply) => ({ ...reply, id: callerIds.get(reply.id) })
+    );
+    return isBatch ? restored : restored[0];
+  }
+  /** Registers a slot for one wire id and hands back the promise that settles when answered. */
+  expect(id, method) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(
+          new TimeoutError(`Request ${method} (id: ${id}) timed out after ${this.requestTimeout}ms`)
+        );
+      }, this.requestTimeout);
+      this.pending.set(id, { method, resolve, reject, timer });
+    });
+  }
+  /** Fails one pending request by wire id. */
+  settle(id, error) {
+    const waiter = this.pending.get(id);
+    if (!waiter) return;
+    this.pending.delete(id);
+    clearTimeout(waiter.timer);
+    waiter.reject(error);
   }
   /**
-   * Create a Block instance
-   * @param {BlockIdentifier} _identifier  hex string and BigInt are detected as block hashes.
-   * decimal string and number are detected as block numbers.
-   * text string are detected as block tag.
-   * null is considered as a 'latest' block tag.
+   * Fails every request still on the wire.
+   *
+   * Their only other exit is the `requestTimeout` timer, so without this the caller waits the
+   * whole timeout — 60s by default — for a reply that can no longer arrive, and that pending
+   * timer keeps the Node event loop alive for just as long.
+   */
+  rejectPending(reason) {
+    if (this.pending.size === 0) return;
+    const waiting = Array.from(this.pending.entries());
+    this.pending.clear();
+    logger.info(
+      `WsTransport: rejecting ${waiting.length} in-flight request(s). Reason: ${reason}.`
+    );
+    waiting.forEach(([id, { method, reject, timer }]) => {
+      clearTimeout(timer);
+      reject(
+        new WebSocketNotConnectedError(`Request ${method} (id: ${id}) went unanswered: ${reason}`)
+      );
+    });
+  }
+  /**
+   * Closes the socket.
+   *
+   * One object owns the socket and one object closes it. Dropping every reference to this
+   * transport does not close anything: an open socket is a libuv handle the Node event loop
+   * holds onto, so it must be closed explicitly.
    */
-  constructor(_identifier) {
-    this.setIdentifier(_identifier);
+  close(code, reason) {
+    this.rejectPending("the connection was closed by the user");
+    this.setState("closed");
+    this.socket.close(code, reason);
   }
-  // TODO: fix any
+};
+
+// src/channel/transport/reconnectingWs.ts
+var ReconnectingWsTransport = class extends WsTransport {
+  autoReconnect;
+  reconnectOptions;
+  isReconnecting = false;
+  reconnectAttempts = 0;
+  userInitiatedClose = false;
+  reconnectTimeoutId = null;
   /**
-   * @returns {any} the identifier as a string
-   * @example
-   * ```typescript
-   * const result = new provider.Block(123456n).queryIdentifier;
-   * // result = "blockHash=0x1e240"
-   * ```
+   * Fires once a connection has stayed open long enough to be considered stable, resetting the
+   * attempt counter. A gateway that accepts then immediately drops never reaches it, so its
+   * attempts keep accumulating toward the cap instead of resetting every cycle.
    */
-  get queryIdentifier() {
-    if (this.number !== null) {
-      return `blockNumber=${this.number}`;
+  reconnectStabilityTimeoutId = null;
+  /**
+   * Requests made while no usable connection existed. They carry no timeout of their own — the
+   * base class only arms one when a request reaches the wire — so the only ways out are being
+   * sent after a reconnection, or being rejected here.
+   */
+  requestQueue = [];
+  /** Guards against one failed attempt arming two retries when both `error` and `close` arrive. */
+  attemptSettled = false;
+  reconnectedHooks = /* @__PURE__ */ new Set();
+  constructor(options) {
+    super(options);
+    this.autoReconnect = options.autoReconnect ?? true;
+    this.reconnectOptions = {
+      retries: options.reconnectOptions?.retries ?? 5,
+      delay: options.reconnectOptions?.delay ?? 2e3,
+      exponential: options.reconnectOptions?.exponential ?? true,
+      stableConnectionThreshold: options.reconnectOptions?.stableConnectionThreshold ?? 5e3
+    };
+  }
+  /**
+   * Whether a request made right now would be held for a reconnection rather than sent.
+   *
+   * Exposed so the `WebSocketChannel` façade can reproduce the refusal its `send()` used to
+   * raise: it refused only when nothing was going to pick the request up later.
+   */
+  get queuesRequests() {
+    return this.isReconnecting || !this.isConnected() && this.autoReconnect && !this.userInitiatedClose;
+  }
+  /**
+   * Registers work to run after a reconnection opens, before the request queue is flushed.
+   * @returns the unregister function.
+   */
+  onReconnected(hook) {
+    this.reconnectedHooks.add(hook);
+    return () => {
+      this.reconnectedHooks.delete(hook);
+    };
+  }
+  onOpened() {
+    this.attemptSettled = true;
+    const wasReconnecting = this.isReconnecting;
+    this.isReconnecting = false;
+    this.scheduleReconnectAttemptsReset();
+    super.onOpened();
+    if (wasReconnecting) {
+      logger.info("WebSocket: Reconnection successful.");
+      this.completeReconnection();
+      return;
     }
-    if (this.hash !== null) {
-      return `blockHash=${this.hash}`;
+    this.processRequestQueue();
+  }
+  onClosed() {
+    if (this.userInitiatedClose || !this.autoReconnect) {
+      this.setState("closed");
+      return;
     }
-    return `blockNumber=${this.tag}`;
+    if (this.isReconnecting) {
+      this.scheduleRetry();
+      return;
+    }
+    this.startReconnect();
+  }
+  onError() {
+    if (this.isConnected()) return;
+    if (this.isReconnecting) this.scheduleRetry();
+  }
+  startReconnect() {
+    if (this.isReconnecting || !this.autoReconnect) return;
+    this.clearStabilityTimer();
+    this.isReconnecting = true;
+    this.setState("reconnecting");
+    this.tryReconnect();
+  }
+  tryReconnect = () => {
+    if (this.reconnectAttempts >= this.reconnectOptions.retries) {
+      logger.error("WebSocket: Maximum reconnection retries reached. Giving up.");
+      this.isReconnecting = false;
+      this.setState("closed");
+      this.rejectRequestQueue(
+        `reconnection gave up after ${this.reconnectOptions.retries} attempts`
+      );
+      return;
+    }
+    this.reconnectAttempts += 1;
+    logger.info(
+      `WebSocket: Connection lost. Attempting to reconnect... (${this.reconnectAttempts}/${this.reconnectOptions.retries})`
+    );
+    this.attemptSettled = false;
+    this.swapSocket(new this.WsImplementation(this.nodeUrl));
+  };
+  scheduleRetry() {
+    if (this.attemptSettled || !this.isReconnecting) return;
+    this.attemptSettled = true;
+    const delay = this.reconnectOptions.exponential ? this.reconnectOptions.delay * 2 ** (this.reconnectAttempts - 1) : this.reconnectOptions.delay;
+    logger.info(`WebSocket: Reconnect attempt failed. Retrying in ${delay}ms.`);
+    this.reconnectTimeoutId = setTimeout(this.tryReconnect, delay);
+  }
+  scheduleReconnectAttemptsReset() {
+    this.clearStabilityTimer();
+    this.reconnectStabilityTimeoutId = setTimeout(() => {
+      this.reconnectAttempts = 0;
+      this.reconnectStabilityTimeoutId = null;
+    }, this.reconnectOptions.stableConnectionThreshold);
+  }
+  clearStabilityTimer() {
+    if (!this.reconnectStabilityTimeoutId) return;
+    clearTimeout(this.reconnectStabilityTimeoutId);
+    this.reconnectStabilityTimeoutId = null;
+  }
+  completeReconnection() {
+    Promise.all(Array.from(this.reconnectedHooks).map((hook) => hook())).catch((error) => {
+      logger.error(`WebSocket: a reconnection hook failed: ${error}`);
+    }).then(() => this.processRequestQueue());
+  }
+  async request(body) {
+    if (this.isReconnecting || !this.isConnected() && this.autoReconnect && !this.userInitiatedClose) {
+      logger.info("WebSocket: Connection unavailable, queueing request.");
+      return new Promise((resolve, reject) => {
+        this.requestQueue.push({ body, resolve, reject });
+      });
+    }
+    return super.request(body);
+  }
+  processRequestQueue() {
+    const pending = this.requestQueue;
+    this.requestQueue = [];
+    logger.info(`WebSocket: Processing ${pending.length} queued requests.`);
+    pending.forEach(({ body, resolve, reject }) => {
+      this.request(body).then(resolve).catch(reject);
+    });
+  }
+  rejectRequestQueue(reason) {
+    if (this.requestQueue.length === 0) return;
+    const pending = this.requestQueue;
+    this.requestQueue = [];
+    logger.info(`WebSocket: Rejecting ${pending.length} queued request(s). Reason: ${reason}.`);
+    pending.forEach(({ body, reject }) => {
+      const method = Array.isArray(body) ? "batch" : body.method;
+      reject(new WebSocketNotConnectedError(`Request ${method} was never sent: ${reason}`));
+    });
   }
-  // TODO: fix any
   /**
-   * @returns {any} the identifier as an object
-   * @example
-   * ```typescript
-   * const result = new provider.Block(56789).identifier;
-   * // result = { block_number: 56789 }
-   * ```
+   * Manually opens a fresh connection, cancelling the effect of an earlier `close()`.
+   *
+   * Flagged as a reconnection so `onOpened` runs `completeReconnection()`: a manual reconnect owes
+   * the caller exactly what an automatic one delivers — subscriptions restored first, then the
+   * request queue flushed behind them. Without the flag the socket came back empty, which is the
+   * React StrictMode path: mount, cleanup `close()`, remount `reconnect()`, subscriptions
+   * silently lost.
+   *
+   * Reporting `'reconnecting'` rather than `'connecting'` is the honest label, and it keeps
+   * `queuesRequests` true for the gap, so a request issued before the socket opens is queued
+   * instead of refused.
    */
-  get identifier() {
-    if (this.number !== null) {
-      return { block_number: this.number };
+  reconnect() {
+    this.userInitiatedClose = false;
+    this.attemptSettled = false;
+    this.isReconnecting = true;
+    this.setState("reconnecting");
+    this.swapSocket(new this.WsImplementation(this.nodeUrl));
+  }
+  /**
+   * Closes the socket for good, and stops the automatic reconnection with it.
+   *
+   * Any request still queued is rejected rather than left waiting for a connection that is no
+   * longer coming. Call {@link reconnect} to start over afterwards.
+   * @param code - WebSocket close code sent to the node.
+   * @param reason - Human-readable close reason sent to the node.
+   */
+  close(code, reason) {
+    if (this.reconnectTimeoutId) {
+      clearTimeout(this.reconnectTimeoutId);
+      this.reconnectTimeoutId = null;
     }
-    if (this.hash !== null) {
-      return { block_hash: this.hash };
+    this.clearStabilityTimer();
+    this.userInitiatedClose = true;
+    this.isReconnecting = false;
+    this.rejectRequestQueue("the connection was closed by the user");
+    super.close(code, reason);
+  }
+};
+
+// src/utils/batch/index.ts
+var BatchClient = class {
+  nodeUrl;
+  headers;
+  interval;
+  requestId = 0;
+  pendingRequests = {};
+  batchPromises = {};
+  delayTimer;
+  delayPromise;
+  delayPromiseResolve;
+  transport;
+  rpcMethods;
+  constructor(options) {
+    this.nodeUrl = options.nodeUrl;
+    this.headers = options.headers;
+    this.interval = options.interval;
+    this.transport = options.transport ?? new HttpTransport({
+      nodeUrl: options.nodeUrl,
+      headers: options.headers,
+      baseFetch: options.baseFetch
+    });
+    this.rpcMethods = options.rpcMethods;
+  }
+  async wait() {
+    if (!this.delayPromise || !this.delayPromiseResolve) {
+      this.delayPromise = new Promise((resolve) => {
+        this.delayPromiseResolve = resolve;
+      });
     }
-    return this.tag;
+    if (this.delayTimer) {
+      clearTimeout(this.delayTimer);
+      this.delayTimer = void 0;
+    }
+    this.delayTimer = setTimeout(() => {
+      if (this.delayPromiseResolve) {
+        this.delayPromiseResolve();
+        this.delayPromise = void 0;
+        this.delayPromiseResolve = void 0;
+      }
+    }, this.interval);
+    return this.delayPromise;
+  }
+  addPendingRequest(method, params, id) {
+    const request = {
+      id: id ?? `batched_${this.requestId += 1}`,
+      jsonrpc: "2.0",
+      method: method.description || String(method),
+      params: params ?? void 0
+    };
+    this.pendingRequests[request.id] = request;
+    return request.id;
+  }
+  async sendBatch(requests) {
+    return this.transport.request(requests);
   }
   /**
-   * change the identifier of an existing Block instance
-   * @example
-   * ```typescript
-   * const myBlock = new provider.Block("latest");
-   * myBlock.identifier ="0x3456789abc";
-   * const result = myBlock.identifier;
-   * // result = { block_hash: '0x3456789abc' }
-   * ```
+   * Automatically batches and fetches JSON-RPC calls in a single request.
+   * @param method Method to call
+   * @param params Method parameters
+   * @param id JSON-RPC Request ID
+   * @returns JSON-RPC Response
    */
-  set identifier(_identifier) {
-    this.setIdentifier(_identifier);
+  async fetch(method, params, id) {
+    const requestId = this.addPendingRequest(method, params, id);
+    await this.wait();
+    const requests = this.pendingRequests;
+    this.pendingRequests = {};
+    if (!this.batchPromises[requestId]) {
+      const promise = this.sendBatch(Object.values(requests));
+      Object.keys(requests).forEach((key) => {
+        this.batchPromises[key] = promise;
+      });
+    }
+    const results = await this.batchPromises[requestId];
+    delete this.batchPromises[requestId];
+    const result = results.find((res) => res.id === requestId);
+    if (!result)
+      throw new Error(`Couldn't find the result for the request. Method: ${String(method)}`);
+    return result;
   }
-  valueOf = () => this.number;
-  toString = () => this.hash;
 };
 
+// src/utils/eth.ts
+var eth_exports = {};
+__export(eth_exports, {
+  ethRandomPrivateKey: () => ethRandomPrivateKey,
+  validateAndParseEthAddress: () => validateAndParseEthAddress
+});
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+function ethRandomPrivateKey() {
+  return sanitizeHex(buf2hex(secp256k1.utils.randomSecretKey()));
+}
+function validateAndParseEthAddress(address) {
+  assertInRange(address, ZERO, 2n ** 160n - 1n, "Ethereum Address ");
+  const result = addHexPrefix(removeHexPrefix(toHex(address)).padStart(40, "0"));
+  assert(Boolean(result.match(/^(0x)?[0-9a-f]{40}$/)), "Invalid Ethereum Address Format");
+  return result;
+}
+
+// src/utils/connect/fetch.ts
+var fetch_default = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" && globalThis.fetch.bind(globalThis) || typeof window !== "undefined" && typeof window.fetch !== "undefined" && window.fetch.bind(window) || typeof global !== "undefined" && typeof global.fetch !== "undefined" && global.fetch.bind(global) || (() => {
+  throw new LibraryError(
+    "'fetch()' not detected, use the 'baseFetch' constructor parameter to set it"
+  );
+});
+
 // src/utils/transaction/index.ts
 var transaction_exports = {};
 __export(transaction_exports, {
@@ -6064,6 +7159,8 @@ var RpcChannel = class {
   transactionRetryIntervalFallback;
   batchClient;
   baseFetch;
+  /** Carries envelopes to the node. `HttpTransport` unless the caller injected its own. */
+  transport;
   constructor(optionsOrProvider) {
     const {
       baseFetch,
@@ -6075,6 +7172,7 @@ var RpcChannel = class {
       retries,
       specVersion,
       transactionRetryIntervalFallback,
+      transport,
       waitMode
     } = optionsOrProvider || {};
     if (Object.values(_NetworkName).includes(nodeUrl)) {
@@ -6093,6 +7191,11 @@ var RpcChannel = class {
     this.specVersion = specVersion;
     this.transactionRetryIntervalFallback = transactionRetryIntervalFallback ?? channelDefaults.options.transactionRetryIntervalFallback;
     this.waitMode = waitMode ?? false;
+    this.transport = transport ?? new HttpTransport({
+      nodeUrl: this.nodeUrl,
+      headers: this.headers,
+      baseFetch: this.baseFetch
+    });
     this.requestId = 0;
     if (isNumber(batch)) {
       this.batchClient = new BatchClient({
@@ -6100,6 +7203,7 @@ var RpcChannel = class {
         headers: this.headers,
         interval: batch,
         baseFetch: this.baseFetch,
+        transport: this.transport,
         rpcMethods: {}
         // Type information only, not used at runtime
       });
@@ -6115,6 +7219,12 @@ var RpcChannel = class {
   setChainId(chainId) {
     this.chainId = chainId;
   }
+  /**
+   * Escape hatch: POSTs a single JSON-RPC call and hands back the raw HTTP response.
+   *
+   * No longer on the `fetchEndpoint` path — that one goes through the transport — but kept
+   * because it is public API and `RpcProvider.fetch()` is built on it.
+   */
   fetch(method, params, id = 0) {
     const rpcRequestBody = {
       id,
@@ -6122,11 +7232,10 @@ var RpcChannel = class {
       method,
       ...params && { params }
     };
-    return this.baseFetch(this.nodeUrl, {
-      method: "POST",
-      body: stringify2(rpcRequestBody),
-      headers: this.headers
-    });
+    return postJsonRpc(
+      { nodeUrl: this.nodeUrl, headers: this.headers, baseFetch: this.baseFetch },
+      rpcRequestBody
+    );
   }
   errorHandler(method, params, rpcError, otherError) {
     if (rpcError) {
@@ -6143,11 +7252,18 @@ var RpcChannel = class {
     try {
       let error;
       let result;
+      this.requestId += 1;
+      const id = this.requestId;
       if (this.batchClient) {
-        ({ error, result } = await this.batchClient.fetch(method, params, this.requestId += 1));
+        ({ error, result } = await this.batchClient.fetch(method, params, id));
       } else {
-        const rawResult = await this.fetch(method, params, this.requestId += 1);
-        ({ error, result } = await rawResult.json());
+        const response = await this.transport.request({
+          id,
+          jsonrpc: "2.0",
+          method,
+          ...params && { params }
+        });
+        ({ error, result } = response);
       }
       this.errorHandler(method, params, error);
       if (result === void 0) {
@@ -6598,11 +7714,20 @@ var RpcChannel = class {
   }
 };
 
-// src/channel/rpc_0_10_2.ts
-var rpc_0_10_2_exports = {};
-__export(rpc_0_10_2_exports, {
-  RpcChannel: () => RpcChannel2
+// src/channel/v0_9/index.ts
+var SubscriptionChannel2 = class extends SubscriptionChannel {
+  id = "RPC0.9.0-subscriptions";
+  channelSpecVersion = _SupportedRpcVersion.v0_9_0;
+};
+
+// src/channel/v0_10_2/index.ts
+var v0_10_2_exports = {};
+__export(v0_10_2_exports, {
+  RpcChannel: () => RpcChannel2,
+  SubscriptionChannel: () => SubscriptionChannel
 });
+
+// src/channel/rpc_0_10_2.ts
 import * as RPC from "@starknet-io/starknet-types-0101";
 var RpcChannel2 = class {
   id = "RPC0.10.2";
@@ -6625,6 +7750,8 @@ var RpcChannel2 = class {
   transactionRetryIntervalFallback;
   batchClient;
   baseFetch;
+  /** Carries envelopes to the node. `HttpTransport` unless the caller injected its own. */
+  transport;
   constructor(optionsOrProvider) {
     const {
       baseFetch,
@@ -6636,6 +7763,7 @@ var RpcChannel2 = class {
       retries,
       specVersion,
       transactionRetryIntervalFallback,
+      transport,
       waitMode
     } = optionsOrProvider || {};
     if (Object.values(_NetworkName).includes(nodeUrl)) {
@@ -6654,6 +7782,11 @@ var RpcChannel2 = class {
     this.specVersion = specVersion;
     this.transactionRetryIntervalFallback = transactionRetryIntervalFallback ?? channelDefaults.options.transactionRetryIntervalFallback;
     this.waitMode = waitMode ?? false;
+    this.transport = transport ?? new HttpTransport({
+      nodeUrl: this.nodeUrl,
+      headers: this.headers,
+      baseFetch: this.baseFetch
+    });
     this.requestId = 0;
     if (isNumber(batch)) {
       this.batchClient = new BatchClient({
@@ -6661,6 +7794,7 @@ var RpcChannel2 = class {
         headers: this.headers,
         interval: batch,
         baseFetch: this.baseFetch,
+        transport: this.transport,
         rpcMethods: {}
         // Type information only, not used at runtime
       });
@@ -6676,6 +7810,12 @@ var RpcChannel2 = class {
   setChainId(chainId) {
     this.chainId = chainId;
   }
+  /**
+   * Escape hatch: POSTs a single JSON-RPC call and hands back the raw HTTP response.
+   *
+   * No longer on the `fetchEndpoint` path — that one goes through the transport — but kept
+   * because it is public API and `RpcProvider.fetch()` is built on it.
+   */
   fetch(method, params, id = 0) {
     const rpcRequestBody = {
       id,
@@ -6683,11 +7823,10 @@ var RpcChannel2 = class {
       method,
       ...params && { params }
     };
-    return this.baseFetch(this.nodeUrl, {
-      method: "POST",
-      body: stringify2(rpcRequestBody),
-      headers: this.headers
-    });
+    return postJsonRpc(
+      { nodeUrl: this.nodeUrl, headers: this.headers, baseFetch: this.baseFetch },
+      rpcRequestBody
+    );
   }
   errorHandler(method, params, rpcError, otherError) {
     if (rpcError) {
@@ -6704,11 +7843,18 @@ var RpcChannel2 = class {
     try {
       let error;
       let result;
+      this.requestId += 1;
+      const id = this.requestId;
       if (this.batchClient) {
-        ({ error, result } = await this.batchClient.fetch(method, params, this.requestId += 1));
+        ({ error, result } = await this.batchClient.fetch(method, params, id));
       } else {
-        const rawResult = await this.fetch(method, params, this.requestId += 1);
-        ({ error, result } = await rawResult.json());
+        const response = await this.transport.request({
+          id,
+          jsonrpc: "2.0",
+          method,
+          ...params && { params }
+        });
+        ({ error, result } = response);
       }
       this.errorHandler(method, params, error);
       if (result === void 0) {
@@ -7221,176 +8367,23 @@ var RpcChannel2 = class {
   }
 };
 
-// src/channel/rpc_0_10_3.ts
-var rpc_0_10_3_exports = {};
-__export(rpc_0_10_3_exports, {
-  RpcChannel: () => RpcChannel3
+// src/channel/v0_10_3/index.ts
+var v0_10_3_exports = {};
+__export(v0_10_3_exports, {
+  RpcChannel: () => RpcChannel3,
+  SubscriptionChannel: () => SubscriptionChannel3
 });
+
+// src/channel/rpc_0_10_3.ts
 var RpcChannel3 = class extends RpcChannel2 {
   id = "RPC0.10.3";
   channelSpecVersion = _SupportedRpcVersion.v0_10_3;
 };
 
-// src/utils/eventEmitter.ts
-var EventEmitter = class {
-  listeners = {};
-  on(event, listener) {
-    if (!this.listeners[event]) {
-      this.listeners[event] = [];
-    }
-    this.listeners[event].push(listener);
-  }
-  off(event, listener) {
-    if (!this.listeners[event]) {
-      return;
-    }
-    this.listeners[event] = this.listeners[event].filter((l) => l !== listener);
-  }
-  emit(event, data) {
-    if (this.listeners[event]) {
-      this.listeners[event].forEach((listener) => listener(data));
-    }
-  }
-  clear() {
-    this.listeners = {};
-  }
-};
-
-// src/utils/connect/ws.ts
-var ws_default = typeof WebSocket !== "undefined" && WebSocket || typeof globalThis !== "undefined" && globalThis.WebSocket || typeof window !== "undefined" && window.WebSocket && window.WebSocket.bind(window) || typeof global !== "undefined" && global.WebSocket || class {
-  constructor() {
-    throw new LibraryError(
-      "WebSocket module not detected, use the 'websocket' constructor parameter to set a compatible connection"
-    );
-  }
-};
-
-// src/channel/ws/subscription.ts
-var Subscription = class {
-  /**
-   * The containing `WebSocketChannel` instance.
-   * @internal
-   */
-  channel;
-  /**
-   * The JSON-RPC method used to create this subscription.
-   * @internal
-   */
-  method;
-  /**
-   * The parameters used to create this subscription.
-   * @internal
-   */
-  params;
-  /**
-   * The unique identifier for this subscription.
-   * @internal
-   */
-  id;
-  events = new EventEmitter();
-  buffer = [];
-  maxBufferSize;
-  handler = null;
-  _isClosed = false;
-  // The unsubscribe request currently on the wire, shared by concurrent callers.
-  pendingUnsubscribe = null;
-  /**
-   * @internal
-   * @param options - Subscription configuration options
-   */
-  constructor(options) {
-    this.channel = options.channel;
-    this.method = options.method;
-    this.params = options.params ?? {};
-    this.id = options.id;
-    this.maxBufferSize = options.maxBufferSize;
-  }
-  /**
-   * Indicates if the subscription has been closed.
-   * @returns {boolean} `true` if unsubscribed, `false` otherwise.
-   */
-  get isClosed() {
-    return this._isClosed;
-  }
-  /**
-   * Closes the subscription locally, without contacting the node.
-   *
-   * Used when the channel knows the subscription is gone and cannot be recovered — a
-   * re-subscribe refused after a reconnection, for instance. Without it the object would keep
-   * reporting itself as open while no event could ever reach its handler again.
-   * @internal
-   */
-  _markClosed() {
-    if (this._isClosed) return;
-    this._isClosed = true;
-    this.events.emit("unsubscribe", void 0);
-    this.events.clear();
-  }
-  /**
-   * Internal method to handle incoming events from the WebSocket channel.
-   * If a handler is attached, it's invoked immediately. Otherwise, the event is buffered.
-   * @internal
-   * @param {T} data - The event data.
-   */
-  _handleEvent(data) {
-    if (this.handler) {
-      this.handler(data);
-    } else {
-      if (this.buffer.length >= this.maxBufferSize) {
-        const droppedEvent = this.buffer.shift();
-        logger.warn(`Subscription ${this.id}: Buffer full. Dropping oldest event:`, droppedEvent);
-      }
-      this.buffer.push(data);
-    }
-  }
-  /**
-   * Attaches a handler function to be called for each event.
-   *
-   * When a handler is attached, any buffered events will be passed to it sequentially.
-   * Subsequent events will be passed directly as they arrive.
-   *
-   * @param {(data: T) => void} handler - The function to call with event data.
-   * @throws {Error} If a handler is already attached to this subscription.
-   */
-  on(handler) {
-    if (this.handler) {
-      throw new Error("A handler is already attached to this subscription.");
-    }
-    this.handler = handler;
-    while (this.buffer.length > 0) {
-      const event = this.buffer.shift();
-      if (event) {
-        this.handler(event);
-      }
-    }
-  }
-  /**
-   * Sends an unsubscribe request to the node and cleans up local resources.
-   * @returns {Promise<boolean>} A Promise that resolves to `true` if the unsubscription was successful.
-   */
-  async unsubscribe() {
-    if (this._isClosed) {
-      return true;
-    }
-    if (this.pendingUnsubscribe) {
-      return this.pendingUnsubscribe;
-    }
-    this.pendingUnsubscribe = (async () => {
-      try {
-        const success = await this.channel.unsubscribe(this.id);
-        if (success) {
-          this._isClosed = true;
-          this.channel.removeSubscription(this.id);
-          this.events.emit("unsubscribe", void 0);
-          this.events.clear();
-        }
-        return success;
-      } finally {
-        this.pendingUnsubscribe = null;
-      }
-    })();
-    return this.pendingUnsubscribe;
-  }
+// src/channel/v0_10_3/index.ts
+var SubscriptionChannel3 = class extends SubscriptionChannel {
+  id = "RPC0.10.3-subscriptions";
+  channelSpecVersion = _SupportedRpcVersion.v0_10_3;
 };
 
 // src/channel/ws/ws_0_10.ts
@@ -7400,75 +8393,48 @@ var WebSocketChannel = class {
    * @example 'wss://starknet-sepolia.public.blastapi.io/rpc/v0_8'
    */
   nodeUrl;
-  /**
-   * The underlying WebSocket instance.
-   */
-  websocket;
-  // Store the WebSocket implementation class to allow for custom implementations.
-  WsImplementation;
-  // Map of active subscriptions, keyed by their ID.
-  activeSubscriptions = /* @__PURE__ */ new Map();
-  maxBufferSize;
-  autoReconnect;
-  reconnectOptions;
-  requestTimeout;
-  isReconnecting = false;
-  reconnectAttempts = 0;
-  userInitiatedClose = false;
-  reconnectTimeoutId = null;
-  // Fires once a (re)connection has stayed open long enough to be considered stable,
-  // resetting the reconnection attempt counter.
-  reconnectStabilityTimeoutId = null;
-  requestQueue = [];
-  /** Abort handles for the requests currently on the wire, one per pending `sendReceive`. */
-  inFlight = /* @__PURE__ */ new Set();
-  /**
-   * Callers blocked in `waitForUnsubscription`, keyed by subscription id.
-   *
-   * Held here rather than as `unsubscribe` event listeners because that event only ever
-   * announces success: a waiter attached to it cannot learn that the node refused the
-   * unsubscribe or that the connection went away, and would wait forever with no timeout of
-   * its own to fall back on.
-   */
-  unsubscribeWaiters = /* @__PURE__ */ new Map();
+  /** Carries the frames and owns the socket lifecycle. */
+  transport;
+  /** Owns `activeSubscriptions`, the unsubscribe waiters and the five subscribe methods. */
+  subscriptionChannel;
   events = new EventEmitter();
-  openListener = (ev) => {
-    this.scheduleReconnectAttemptsReset();
-    this.events.emit("open", ev);
-  };
-  closeListener = this.onCloseProxy.bind(this);
-  messageListener = this.onMessageProxy.bind(this);
-  errorListener = (ev) => this.events.emit("error", ev);
   /**
-   * JSON RPC latest sent message ID.
-   * The receiving message is expected to contain the same ID.
+   * The underlying WebSocket instance.
+   *
+   * A getter rather than a field: a reconnection replaces the socket, and callers — including
+   * the test suite, which spies on `channel.websocket.send` — must see the live one.
+   */
+  get websocket() {
+    return this.transport.socket;
+  }
+  /**
+   * Map of active subscriptions, keyed by their ID.
+   * @internal
    */
-  sendId = 0;
+  get activeSubscriptions() {
+    return this.subscriptionChannel.subscriptions;
+  }
   /**
    * Creates an instance of WebSocketChannel.
    * @param {WebSocketOptions} options - The options for configuring the channel.
    */
   constructor(options) {
     this.nodeUrl = options.nodeUrl;
-    this.maxBufferSize = options.maxBufferSize ?? 1e3;
-    this.autoReconnect = options.autoReconnect ?? true;
-    this.reconnectOptions = {
-      retries: options.reconnectOptions?.retries ?? 5,
-      delay: options.reconnectOptions?.delay ?? 2e3,
-      exponential: options.reconnectOptions?.exponential ?? true,
-      stableConnectionThreshold: options.reconnectOptions?.stableConnectionThreshold ?? 5e3
-    };
-    this.requestTimeout = options.requestTimeout ?? 6e4;
-    this.WsImplementation = options.websocket || config.get("websocket") || ws_default;
-    this.websocket = new this.WsImplementation(this.nodeUrl);
-    this.websocket.addEventListener("open", this.openListener);
-    this.websocket.addEventListener("close", this.closeListener);
-    this.websocket.addEventListener("message", this.messageListener);
-    this.websocket.addEventListener("error", this.errorListener);
-  }
-  idResolver(id) {
-    if (id !== void 0) return id;
-    return this.sendId++;
+    this.transport = new ReconnectingWsTransport({
+      nodeUrl: options.nodeUrl,
+      websocket: options.websocket,
+      requestTimeout: options.requestTimeout,
+      autoReconnect: options.autoReconnect,
+      reconnectOptions: options.reconnectOptions
+    });
+    this.subscriptionChannel = new SubscriptionChannel({
+      transport: this.transport,
+      maxBufferSize: options.maxBufferSize
+    });
+    this.transport.on("open", (event) => this.events.emit("open", event));
+    this.transport.on("close", (event) => this.events.emit("close", event));
+    this.transport.on("error", (event) => this.events.emit("error", event));
+    this.transport.on("message", (event) => this.events.emit("message", event));
   }
   /**
    * Sends a JSON-RPC request over the WebSocket connection without waiting for a response.
@@ -7485,7 +8451,7 @@ var WebSocketChannel = class {
         "WebSocketChannel.send() failed due to socket being disconnected"
       );
     }
-    const usedId = this.idResolver(id);
+    const usedId = id !== void 0 ? id : this.transport.allocateRequestId();
     const rpcRequestBody = {
       id: usedId,
       jsonrpc: "2.0",
@@ -7495,6 +8461,22 @@ var WebSocketChannel = class {
     this.websocket.send(stringify2(rpcRequestBody));
     return usedId;
   }
+  /**
+   * Refuses a call that has nowhere to go, the way `send()` used to.
+   *
+   * Every method below used to reach the socket through `send()`, which threw this exact error
+   * when the connection was down and nothing was going to pick the request up later. The refusal
+   * now originates in the transport, which is generic and rightly words it differently — so the
+   * decision is reproduced here instead, at the boundary where the legacy contract applies.
+   *
+   * The condition is the transport's own: it refuses only when the request would not be queued.
+   */
+  assertSendable() {
+    if (this.isConnected() || this.transport.queuesRequests) return;
+    throw new WebSocketNotConnectedError(
+      "WebSocketChannel.send() failed due to socket being disconnected"
+    );
+  }
   /**
    * Sends a JSON-RPC request and returns a Promise that resolves with the result.
    * This method abstracts the request/response cycle over WebSockets.
@@ -7506,84 +8488,25 @@ var WebSocketChannel = class {
    * @throws {TimeoutError} If the request does not receive a response within the configured `requestTimeout`.
    * @throws {WebSocketNotConnectedError} If the WebSocket is not connected and auto-reconnect is disabled.
    */
-  sendReceive(method, params) {
-    if (this.isReconnecting || !this.isConnected() && this.autoReconnect && !this.userInitiatedClose) {
-      logger.info(`WebSocket: Connection unavailable, queueing request: ${method}`);
-      return new Promise((resolve, reject) => {
-        this.requestQueue.push({ method, params, resolve, reject });
-      });
-    }
-    const sendId = this.send(method, params);
-    const socket = this.websocket;
-    return new Promise((resolve, reject) => {
-      if (socket.readyState !== ws_default.OPEN) {
-        reject(new WebSocketNotConnectedError("WebSocket not available or not connected."));
-        return;
-      }
-      let timeoutId;
-      const settle = () => {
-        clearTimeout(timeoutId);
-        socket.removeEventListener("message", messageHandler);
-        socket.removeEventListener("error", errorHandler);
-        this.inFlight.delete(abort);
-      };
-      const messageHandler = (event) => {
-        if (!isString(event.data)) {
-          logger.warn("WebSocket received non-string message data:", event.data);
-          return;
-        }
-        let message;
-        try {
-          message = JSON.parse(event.data);
-        } catch (error) {
-          logger.error(
-            `WebSocketChannel: Error parsing incoming message: ${event.data}, Error: ${error}`
-          );
-          return;
-        }
-        if (message.id !== sendId) return;
-        settle();
-        if ("result" in message) {
-          resolve(message.result);
-        } else {
-          reject(new Error(`Error on ${method} (id: ${sendId}): ${JSON.stringify(message.error)}`));
-        }
-      };
-      const errorHandler = (event) => {
-        settle();
-        reject(
-          new Error(
-            `WebSocket error during ${method} (id: ${sendId}): ${event.type || "Unknown error"}`
-          )
-        );
-      };
-      const abort = (reason) => {
-        settle();
-        reject(
-          new WebSocketNotConnectedError(
-            `Request ${method} (id: ${sendId}) went unanswered: ${reason}`
-          )
-        );
-      };
-      socket.addEventListener("message", messageHandler);
-      socket.addEventListener("error", errorHandler);
-      this.inFlight.add(abort);
-      timeoutId = setTimeout(() => {
-        settle();
-        reject(
-          new TimeoutError(
-            `Request ${method} (id: ${sendId}) timed out after ${this.requestTimeout}ms`
-          )
-        );
-      }, this.requestTimeout);
+  async sendReceive(method, params) {
+    this.assertSendable();
+    const response = await this.transport.request({
+      id: 0,
+      jsonrpc: "2.0",
+      method,
+      ...params && { params }
     });
+    if (response.error) {
+      throw new Error(`Error on ${method}: ${JSON.stringify(response.error)}`);
+    }
+    return response.result;
   }
   /**
    * Checks if the WebSocket connection is currently open.
    * @returns {boolean} `true` if the connection is open, `false` otherwise.
    */
   isConnected() {
-    return this.websocket.readyState === ws_default.OPEN;
+    return this.transport.isConnected();
   }
   /**
    * Returns a Promise that resolves when the WebSocket connection is open.
@@ -7597,16 +8520,21 @@ var WebSocketChannel = class {
    * ```
    */
   async waitForConnection() {
-    if (this.websocket.readyState !== ws_default.OPEN) {
-      return new Promise((resolve, reject) => {
-        if (!this.websocket) return;
-        this.websocket.onopen = () => resolve(this.websocket.readyState);
-        this.websocket.onerror = (error) => {
-          return reject(error);
-        };
+    if (this.isConnected()) return this.websocket.readyState;
+    return new Promise((resolve, reject) => {
+      const settle = () => {
+        offOpen();
+        offError();
+      };
+      const offOpen = this.transport.on("open", () => {
+        settle();
+        resolve(this.websocket.readyState);
       });
-    }
-    return this.websocket.readyState;
+      const offError = this.transport.on("error", (event) => {
+        settle();
+        reject(event);
+      });
+    });
   }
   /**
    * Closes the WebSocket connection.
@@ -7615,34 +8543,29 @@ var WebSocketChannel = class {
    * @param {string} [reason] - The WebSocket connection close reason.
    */
   disconnect(code, reason) {
-    if (this.reconnectTimeoutId) {
-      clearTimeout(this.reconnectTimeoutId);
-      this.reconnectTimeoutId = null;
-    }
-    if (this.reconnectStabilityTimeoutId) {
-      clearTimeout(this.reconnectStabilityTimeoutId);
-      this.reconnectStabilityTimeoutId = null;
-    }
-    this.userInitiatedClose = true;
-    this.isReconnecting = false;
-    this._rejectRequestQueue("the connection was closed by the user");
-    this._rejectInFlight("the connection was closed by the user");
-    this._rejectUnsubscribeWaiters("the connection was closed by the user");
-    this.websocket.close(code, reason);
+    this.transport.close(code, reason);
   }
   /**
    * Returns a Promise that resolves when the WebSocket connection is closed.
    * @returns {Promise<number | Event>} A Promise that resolves with the WebSocket's `readyState` or a `CloseEvent` when disconnected.
    */
   async waitForDisconnection() {
-    if (this.websocket.readyState !== ws_default.CLOSED) {
-      return new Promise((resolve, reject) => {
-        if (!this.websocket) return;
-        this.websocket.onclose = () => resolve(this.websocket.readyState);
-        this.websocket.onerror = reject;
+    if (this.websocket.readyState === ws_default.CLOSED) return this.websocket.readyState;
+    return new Promise((resolve, reject) => {
+      const settle = () => {
+        offClose();
+        offError();
+      };
+      const offClose = this.transport.on("close", () => {
+        settle();
+        resolve(this.websocket.readyState);
       });
-    }
-    return this.websocket.readyState;
+      const offError = this.transport.on("error", (event) => {
+        if (this.websocket.readyState !== ws_default.OPEN) return;
+        settle();
+        reject(event);
+      });
+    });
   }
   /**
    * Unsubscribes from a Starknet subscription.
@@ -7652,48 +8575,13 @@ var WebSocketChannel = class {
    * @returns {Promise<boolean>} A Promise that resolves with `true` if the unsubscription was successful.
    */
   async unsubscribe(subscriptionId) {
-    let status;
-    try {
-      status = await this.sendReceive("starknet_unsubscribe", {
-        subscription_id: subscriptionId
-      });
-    } catch (error) {
-      this._settleUnsubscribeWaiters(subscriptionId, error);
-      throw error;
-    }
+    this.assertSendable();
+    const status = await this.subscriptionChannel.unsubscribe(subscriptionId);
     if (status) {
       this.events.emit("unsubscribe", subscriptionId);
-      this._settleUnsubscribeWaiters(subscriptionId);
-    } else {
-      this._settleUnsubscribeWaiters(
-        subscriptionId,
-        new Error(`Node refused to unsubscribe subscription ${subscriptionId}`)
-      );
     }
     return status;
   }
-  /** Settles every caller waiting on one subscription id: resolved, or rejected with `error`. */
-  _settleUnsubscribeWaiters(subscriptionId, error) {
-    const waiters = this.unsubscribeWaiters.get(subscriptionId);
-    if (!waiters) return;
-    this.unsubscribeWaiters.delete(subscriptionId);
-    waiters.forEach((waiter) => error ? waiter.reject(error) : waiter.resolve());
-  }
-  /**
-   * Rejects every caller still waiting on any subscription.
-   *
-   * Once the connection is gone, no unsubscribe can be observed on it: a reconnection restores
-   * each subscription under a fresh id, so the id being waited on will never be announced.
-   */
-  _rejectUnsubscribeWaiters(reason) {
-    if (this.unsubscribeWaiters.size === 0) return;
-    Array.from(this.unsubscribeWaiters.keys()).forEach(
-      (id) => this._settleUnsubscribeWaiters(
-        id,
-        new WebSocketNotConnectedError(`Subscription ${id} was never unsubscribed: ${reason}`)
-      )
-    );
-  }
   /**
    * Returns a Promise that resolves when a specific subscription is successfully unsubscribed.
    * @param {SUBSCRIPTION_ID} targetId - The ID of the subscription to wait for.
@@ -7705,182 +8593,14 @@ var WebSocketChannel = class {
    * ```
    */
   waitForUnsubscription(targetId) {
-    return new Promise((resolve, reject) => {
-      const waiters = this.unsubscribeWaiters.get(targetId) ?? /* @__PURE__ */ new Set();
-      waiters.add({ resolve, reject });
-      this.unsubscribeWaiters.set(targetId, waiters);
-    });
+    return this.subscriptionChannel.waitForUnsubscription(targetId);
   }
   /**
    * Manually initiates a reconnection attempt.
    * This creates a new WebSocket instance and re-establishes listeners.
    */
   reconnect() {
-    this.userInitiatedClose = false;
-    this.websocket = new this.WsImplementation(this.nodeUrl);
-    this.websocket.addEventListener("open", this.openListener);
-    this.websocket.addEventListener("close", this.closeListener);
-    this.websocket.addEventListener("message", this.messageListener);
-    this.websocket.addEventListener("error", this.errorListener);
-  }
-  _processRequestQueue() {
-    const pending = this.requestQueue;
-    this.requestQueue = [];
-    logger.info(`WebSocket: Processing ${pending.length} queued requests.`);
-    pending.forEach(({ method, params, resolve, reject }) => {
-      this.sendReceive(method, params).then(resolve).catch(reject);
-    });
-  }
-  /**
-   * Reject every request still waiting in the queue.
-   *
-   * A queued request carries no timeout of its own: the `requestTimeout` timer is only
-   * armed once the request is actually put on the wire. So once the channel reaches a state
-   * where the queue can never be flushed — reconnection gave up, or the user closed the
-   * connection — the queued promises would stay pending forever, and no caller-side timeout
-   * could rescue them. Settling them here is the only way out.
-   */
-  _rejectRequestQueue(reason) {
-    if (this.requestQueue.length === 0) return;
-    const pending = this.requestQueue;
-    this.requestQueue = [];
-    logger.info(`WebSocket: Rejecting ${pending.length} queued request(s). Reason: ${reason}.`);
-    pending.forEach(({ method, reject }) => {
-      reject(new WebSocketNotConnectedError(`Request ${method} was never sent: ${reason}`));
-    });
-  }
-  /**
-   * Settle every request already on the wire.
-   *
-   * The counterpart of `_rejectRequestQueue`, for requests past the queue. Their only other
-   * exit is the `requestTimeout` timer, so without this the caller waits the whole timeout —
-   * 60s by default — for a reply that can no longer arrive, and that pending timer keeps the
-   * Node event loop alive for just as long.
-   */
-  _rejectInFlight(reason) {
-    if (this.inFlight.size === 0) return;
-    const pending = Array.from(this.inFlight);
-    this.inFlight.clear();
-    logger.info(`WebSocket: Rejecting ${pending.length} in-flight request(s). Reason: ${reason}.`);
-    pending.forEach((abort) => abort(reason));
-  }
-  async _restoreSubscriptions() {
-    const oldSubscriptions = Array.from(this.activeSubscriptions.values());
-    this.activeSubscriptions.clear();
-    const restorePromises = oldSubscriptions.map(async (sub) => {
-      try {
-        const newSubId = await this.sendReceive(sub.method, sub.params);
-        sub.id = newSubId;
-        this.activeSubscriptions.set(newSubId, sub);
-        logger.info(`Subscription ${sub.method} restored with new ID: ${newSubId}`);
-      } catch (error) {
-        logger.error(`Failed to restore subscription ${sub.method}:`, error);
-        sub._markClosed();
-      }
-    });
-    await Promise.all(restorePromises);
-  }
-  /**
-   * Reset the reconnection attempt counter, but only once the current connection has
-   * stayed open for `stableConnectionThreshold` ms. A connection that opens and then
-   * immediately drops (a flapping gateway) never reaches this point, so its attempts
-   * keep accumulating toward the retry cap instead of resetting every cycle.
-   */
-  scheduleReconnectAttemptsReset() {
-    if (this.reconnectStabilityTimeoutId) {
-      clearTimeout(this.reconnectStabilityTimeoutId);
-    }
-    this.reconnectStabilityTimeoutId = setTimeout(() => {
-      this.reconnectAttempts = 0;
-      this.reconnectStabilityTimeoutId = null;
-    }, this.reconnectOptions.stableConnectionThreshold);
-  }
-  _startReconnect() {
-    if (this.isReconnecting || !this.autoReconnect) {
-      return;
-    }
-    if (this.reconnectStabilityTimeoutId) {
-      clearTimeout(this.reconnectStabilityTimeoutId);
-      this.reconnectStabilityTimeoutId = null;
-    }
-    this.isReconnecting = true;
-    const tryReconnect = () => {
-      if (this.reconnectAttempts >= this.reconnectOptions.retries) {
-        logger.error("WebSocket: Maximum reconnection retries reached. Giving up.");
-        this.isReconnecting = false;
-        this._rejectRequestQueue(
-          `reconnection gave up after ${this.reconnectOptions.retries} attempts`
-        );
-        return;
-      }
-      this.reconnectAttempts += 1;
-      logger.info(
-        `WebSocket: Connection lost. Attempting to reconnect... (${this.reconnectAttempts}/${this.reconnectOptions.retries})`
-      );
-      this.reconnect();
-      let attemptSettled = false;
-      const scheduleRetry = () => {
-        if (attemptSettled || !this.isReconnecting) return;
-        attemptSettled = true;
-        const delay = this.reconnectOptions.exponential ? this.reconnectOptions.delay * 2 ** (this.reconnectAttempts - 1) : this.reconnectOptions.delay;
-        logger.info(`WebSocket: Reconnect attempt failed. Retrying in ${delay}ms.`);
-        this.reconnectTimeoutId = setTimeout(tryReconnect, delay);
-      };
-      this.websocket.onopen = async () => {
-        logger.info("WebSocket: Reconnection successful.");
-        attemptSettled = true;
-        this.isReconnecting = false;
-        await this._restoreSubscriptions();
-        this._processRequestQueue();
-        this.events.emit("open", new Event("open"));
-      };
-      this.websocket.onerror = scheduleRetry;
-      this.websocket.addEventListener("close", scheduleRetry);
-    };
-    tryReconnect();
-  }
-  onCloseProxy(ev) {
-    this.websocket.removeEventListener("open", this.openListener);
-    this.websocket.removeEventListener("close", this.closeListener);
-    this.websocket.removeEventListener("message", this.messageListener);
-    this.websocket.removeEventListener("error", this.errorListener);
-    this._rejectInFlight("the connection was closed");
-    this._rejectUnsubscribeWaiters("the connection was closed");
-    this.events.emit("close", ev);
-    if (!this.userInitiatedClose) {
-      this._startReconnect();
-    }
-  }
-  onMessageProxy(event) {
-    let message;
-    try {
-      message = JSON.parse(event.data);
-    } catch (error) {
-      logger.error(
-        `WebSocketChannel: Error parsing incoming message: ${event.data}, Error: ${error}`
-      );
-      return;
-    }
-    if (message.method && isObject(message.params) && "subscription_id" in message.params) {
-      const { result, subscription_id } = message.params;
-      const subscription = this.activeSubscriptions.get(subscription_id);
-      if (subscription) {
-        subscription._handleEvent(result);
-      } else {
-        queueMicrotask(() => {
-          const registered = this.activeSubscriptions.get(subscription_id);
-          if (registered) {
-            registered._handleEvent(result);
-          } else {
-            logger.warn(
-              `WebSocketChannel: Received event for untracked subscription ID: ${subscription_id}.`
-            );
-          }
-        });
-      }
-    }
-    logger.debug("onMessageProxy:", event.data);
-    this.events.emit("message", event);
+    this.transport.reconnect();
   }
   /**
    * Subscribes to new block headers.
@@ -7888,20 +8608,8 @@ var WebSocketChannel = class {
    * @returns {Promise<Subscription<BLOCK_HEADER>>} A Promise that resolves with a `Subscription` object for new block headers.
    */
   async subscribeNewHeads(params = {}) {
-    const method = "starknet_subscribeNewHeads";
-    const rpcParams = {
-      block_id: params.blockIdentifier ? new Block(params.blockIdentifier).identifier : void 0
-    };
-    const subId = await this.sendReceive(method, rpcParams);
-    const subscription = new Subscription({
-      channel: this,
-      method,
-      params: rpcParams,
-      id: subId,
-      maxBufferSize: this.maxBufferSize
-    });
-    this.activeSubscriptions.set(subId, subscription);
-    return subscription;
+    this.assertSendable();
+    return this.subscriptionChannel.subscribeNewHeads(params);
   }
   /**
    * Subscribes to events matching a given filter.
@@ -7909,27 +8617,8 @@ var WebSocketChannel = class {
    * @returns {Promise<Subscription<EMITTED_EVENT>>} A Promise that resolves with a `Subscription` object for the specified events.
    */
   async subscribeEvents(params = {}) {
-    const method = "starknet_subscribeEvents";
-    let from_address;
-    if (params.fromAddress !== void 0) {
-      from_address = Array.isArray(params.fromAddress) ? bigNumberishArrayToHexadecimalStringArray(params.fromAddress) : toHex(params.fromAddress);
-    }
-    const rpcParams = {
-      from_address,
-      keys: params.keys,
-      block_id: params.blockIdentifier ? new Block(params.blockIdentifier).identifier : void 0,
-      finality_status: params.finalityStatus
-    };
-    const subId = await this.sendReceive(method, rpcParams);
-    const subscription = new Subscription({
-      channel: this,
-      method,
-      params: rpcParams,
-      id: subId,
-      maxBufferSize: this.maxBufferSize
-    });
-    this.activeSubscriptions.set(subId, subscription);
-    return subscription;
+    this.assertSendable();
+    return this.subscriptionChannel.subscribeEvents(params);
   }
   /**
    * Subscribes to status updates for a specific transaction.
@@ -7937,21 +8626,8 @@ var WebSocketChannel = class {
    * @returns {Promise<Subscription<NEW_TXN_STATUS>>} A Promise that resolves with a `Subscription` object for the transaction's status.
    */
   async subscribeTransactionStatus(params) {
-    const method = "starknet_subscribeTransactionStatus";
-    const rpcParams = {
-      transaction_hash: toHex(params.transactionHash),
-      block_id: params.blockIdentifier ? new Block(params.blockIdentifier).identifier : void 0
-    };
-    const subId = await this.sendReceive(method, rpcParams);
-    const subscription = new Subscription({
-      channel: this,
-      method,
-      params: rpcParams,
-      id: subId,
-      maxBufferSize: this.maxBufferSize
-    });
-    this.activeSubscriptions.set(subId, subscription);
-    return subscription;
+    this.assertSendable();
+    return this.subscriptionChannel.subscribeTransactionStatus(params);
   }
   /**
    * Subscribes to new transaction receipts.
@@ -7959,21 +8635,8 @@ var WebSocketChannel = class {
    * @returns {Promise<Subscription<NewTransactionReceiptsEvent['result']>>} A Promise that resolves with a `Subscription` object for new transaction receipts.
    */
   async subscribeNewTransactionReceipts(params = {}) {
-    const method = "starknet_subscribeNewTransactionReceipts";
-    const rpcParams = {
-      finality_status: params.finalityStatus,
-      sender_address: params.senderAddress && bigNumberishArrayToHexadecimalStringArray(params.senderAddress)
-    };
-    const subId = await this.sendReceive(method, rpcParams);
-    const subscription = new Subscription({
-      channel: this,
-      method,
-      params: rpcParams,
-      id: subId,
-      maxBufferSize: this.maxBufferSize
-    });
-    this.activeSubscriptions.set(subId, subscription);
-    return subscription;
+    this.assertSendable();
+    return this.subscriptionChannel.subscribeNewTransactionReceipts(params);
   }
   /**
    * Subscribes to new transactions.
@@ -7981,29 +8644,15 @@ var WebSocketChannel = class {
    * @returns {Promise<Subscription<NewTransactionEvent['result']>>} A Promise that resolves with a `Subscription` object for new transactions.
    */
   async subscribeNewTransactions(params = {}) {
-    const method = "starknet_subscribeNewTransactions";
-    const rpcParams = {
-      finality_status: params.finalityStatus,
-      sender_address: params.senderAddress && bigNumberishArrayToHexadecimalStringArray(params.senderAddress),
-      tags: params.tags
-    };
-    const subId = await this.sendReceive(method, rpcParams);
-    const subscription = new Subscription({
-      channel: this,
-      method,
-      params: rpcParams,
-      id: subId,
-      maxBufferSize: this.maxBufferSize
-    });
-    this.activeSubscriptions.set(subId, subscription);
-    return subscription;
+    this.assertSendable();
+    return this.subscriptionChannel.subscribeNewTransactions(params);
   }
   /**
    * Internal method to remove subscription from active map.
    * @internal
    */
   removeSubscription(id) {
-    this.activeSubscriptions.delete(id);
+    this.subscriptionChannel.removeSubscription(id);
   }
   /**
    * Adds a listener for a given event.
@@ -9680,14 +10329,14 @@ var RpcProvider = class {
       const options = optionsOrProvider;
       if (options && options.specVersion) {
         if (isVersion("0.9", options.specVersion)) {
-          this.channel = new rpc_0_9_0_exports.RpcChannel({ ...options, waitMode: false });
+          this.channel = new v0_9_exports.RpcChannel({ ...options, waitMode: false });
         } else if (isVersion("0.10", options.specVersion)) {
-          this.channel = new rpc_0_10_3_exports.RpcChannel({ ...options, waitMode: false });
+          this.channel = new v0_10_3_exports.RpcChannel({ ...options, waitMode: false });
         } else throw new Error(`unsupported channel for spec version: ${options.specVersion}`);
       } else if (isVersion("0.9", config.get("rpcVersion"))) {
-        this.channel = new rpc_0_9_0_exports.RpcChannel({ ...options, waitMode: false });
+        this.channel = new v0_9_exports.RpcChannel({ ...options, waitMode: false });
       } else if (isVersion("0.10", config.get("rpcVersion"))) {
-        this.channel = new rpc_0_10_3_exports.RpcChannel({ ...options, waitMode: false });
+        this.channel = new v0_10_3_exports.RpcChannel({ ...options, waitMode: false });
       } else throw new Error("unable to define spec version for channel");
       this.responseParser = new RPCResponseParser(options?.resourceBoundsOverhead);
       const plugins = options?.plugins === false ? [] : options?.plugins ?? defaultPlugins;
@@ -9702,7 +10351,7 @@ var RpcProvider = class {
    */
   // NOTE: the generic T and 'this' reference are used so that the expanded class is generated when a mixin is applied
   static async create(optionsOrProvider) {
-    const channel = new rpc_0_9_0_exports.RpcChannel({ ...optionsOrProvider });
+    const channel = new v0_9_exports.RpcChannel({ ...optionsOrProvider });
     const spec = await channel.getSpecVersion();
     if (!isSupportedSpecVersion(spec)) {
       logger.warn(`Using incompatible node spec version ${spec}`);
@@ -9780,7 +10429,7 @@ var RpcProvider = class {
     return this.channel.getBlockWithTxHashes(blockIdentifier);
   }
   async getBlockWithTxs(blockIdentifier, options) {
-    if (this.channel instanceof rpc_0_10_2_exports.RpcChannel) {
+    if (this.channel instanceof v0_10_2_exports.RpcChannel) {
       return this.channel.getBlockWithTxs(blockIdentifier, options);
     }
     return this.channel.getBlockWithTxs(blockIdentifier);
@@ -9837,7 +10486,7 @@ var RpcProvider = class {
     return solidityUint256PackedKeccak256(params);
   }
   async getBlockWithReceipts(blockIdentifier, options) {
-    if (this.channel instanceof rpc_0_10_2_exports.RpcChannel) {
+    if (this.channel instanceof v0_10_2_exports.RpcChannel) {
       return this.channel.getBlockWithReceipts(blockIdentifier, options);
     }
     return this.channel.getBlockWithReceipts(blockIdentifier);
@@ -9847,7 +10496,7 @@ var RpcProvider = class {
     return this.channel.getBlockStateUpdate(blockIdentifier, contractAddresses);
   }
   async getBlockTransactionsTraces(blockIdentifier, options) {
-    if (this.channel instanceof rpc_0_10_2_exports.RpcChannel) {
+    if (this.channel instanceof v0_10_2_exports.RpcChannel) {
       return this.channel.getBlockTransactionsTraces(blockIdentifier, options);
     }
     return this.channel.getBlockTransactionsTraces(blockIdentifier);
@@ -9859,13 +10508,13 @@ var RpcProvider = class {
     return this.getTransactionByHash(txHash, options);
   }
   async getTransactionByHash(txHash, options) {
-    if (this.channel instanceof rpc_0_10_2_exports.RpcChannel) {
+    if (this.channel instanceof v0_10_2_exports.RpcChannel) {
       return this.channel.getTransactionByHash(txHash, options);
     }
     return this.channel.getTransactionByHash(txHash);
   }
   async getTransactionByBlockIdAndIndex(blockIdentifier, index, options) {
-    if (this.channel instanceof rpc_0_10_2_exports.RpcChannel) {
+    if (this.channel instanceof v0_10_2_exports.RpcChannel) {
       return this.channel.getTransactionByBlockIdAndIndex(blockIdentifier, index, options);
     }
     return this.channel.getTransactionByBlockIdAndIndex(blockIdentifier, index);
@@ -10001,10 +10650,10 @@ var RpcProvider = class {
     return this.channel.getSyncingStats();
   }
   async getEvents(eventFilter) {
-    if (this.channel instanceof rpc_0_10_2_exports.RpcChannel) {
+    if (this.channel instanceof v0_10_2_exports.RpcChannel) {
       return this.channel.getEvents(eventFilter);
     }
-    if (this.channel instanceof rpc_0_9_0_exports.RpcChannel) {
+    if (this.channel instanceof v0_9_exports.RpcChannel) {
       return this.channel.getEvents(eventFilter);
     }
     throw new Error("Unsupported channel type");
@@ -10081,6 +10730,92 @@ var RpcProvider = class {
 var ProviderInterface = class {
 };
 
+// src/provider/ws.ts
+var WebSocketProvider = class _WebSocketProvider extends RpcProvider {
+  /** The socket both channels write to. Owned by this provider only when it built it. */
+  transport;
+  /** The `starknet_subscribe*` surface, on the same spec version as `channel`. */
+  subscriptions;
+  constructor(options) {
+    const transport = options.transport ?? _WebSocketProvider.buildTransport(options);
+    super({ ...options, transport });
+    this.transport = transport;
+    this.subscriptions = _WebSocketProvider.buildSubscriptionChannel(options, transport);
+  }
+  /**
+   * Closes the socket when the provider leaves a `using` scope.
+   *
+   * Written as a normal method rather than a computed class member on purpose: a computed
+   * `[Symbol.dispose]` is evaluated while the class is being defined, so on a runtime without the
+   * symbol — older browsers the IIFE build targets — the whole module would throw on load, for
+   * callers who never asked for `using`. Assigning to the prototype behind a guard keeps the
+   * failure confined to the feature that needs it.
+   */
+  dispose() {
+    this.transport.close();
+  }
+  static buildTransport(options) {
+    if (!options.nodeUrl) {
+      throw new LibraryError("WebSocketProvider requires either a nodeUrl or a transport");
+    }
+    return new ReconnectingWsTransport({
+      ...options,
+      nodeUrl: options.nodeUrl
+    });
+  }
+  /**
+   * Resolves the subscription channel the same way `RpcProvider` resolves its request channel
+   * (`rpc.ts`), branch for branch including the `config.get('rpcVersion')` fallback. Any
+   * divergence here would pair channels of two different specs on one socket, which is exactly
+   * what the per-version namespaces exist to prevent.
+   */
+  static buildSubscriptionChannel(options, transport) {
+    const channelOptions = { transport, maxBufferSize: options.maxBufferSize };
+    const forVersion = (specVersion) => {
+      if (isVersion("0.9", specVersion)) return new v0_9_exports.SubscriptionChannel(channelOptions);
+      if (isVersion("0.10", specVersion)) return new v0_10_3_exports.SubscriptionChannel(channelOptions);
+      throw new LibraryError(`unsupported subscription channel for spec version: ${specVersion}`);
+    };
+    if (options.specVersion) return forVersion(options.specVersion);
+    return forVersion(config.get("rpcVersion"));
+  }
+  /**
+   * Probes the node for its spec version, then builds the matching pair of channels.
+   *
+   * The transport is created before the probe and handed to the result, so the socket survives
+   * the probe channel being discarded — the reason the transport is a separate value at all.
+   */
+  // `this` is deliberately untyped. The base declares `create` with a `this` constructor type so
+  // that a mixin-expanded class is generated; repeating that here with a narrower constructor
+  // makes the derived static side unassignable to the base's. Mirroring the base's parameter and
+  // return shapes keeps the override legal, and the cast below is checked by the tests.
+  //
+  // `T` defaults to `WebSocketProvider` because untying `this` also unties the inference: with no
+  // contextual type, `T` would otherwise fall back to its constraint and hand the caller a plain
+  // `RpcProvider`, on which `subscriptions` does not exist. An annotated target still wins.
+  static async create(optionsOrProvider) {
+    const options = optionsOrProvider ?? {};
+    const transport = options.transport ?? _WebSocketProvider.buildTransport(options);
+    const probe = new v0_9_exports.RpcChannel({ ...options, transport });
+    const spec = await probe.getSpecVersion();
+    if (!isSupportedSpecVersion(spec)) {
+      logger.warn(`Using incompatible node spec version ${spec}`);
+    }
+    if (isVersion("0.9", spec)) {
+      return new this({ ...options, transport, specVersion: _SupportedRpcVersion.v0_9_0 });
+    }
+    if (isVersion("0.10", spec)) {
+      return new this({ ...options, transport, specVersion: _SupportedRpcVersion.v0_10_3 });
+    }
+    throw new LibraryError(
+      `Provided RPC node specification version ${spec} is not compatible with the SDK. SDK supported RPC versions ${Object.keys(_SupportedRpcVersion).toString()}`
+    );
+  }
+};
+if (typeof Symbol.dispose !== "undefined") {
+  WebSocketProvider.prototype[Symbol.dispose] = WebSocketProvider.prototype.dispose;
+}
+
 // src/signer/interface.ts
 var SignerInterface = class {
 };
@@ -10155,7 +10890,7 @@ var Signer = class {
 };
 
 // src/signer/ethSigner.ts
-import { secp256k1 as secp256k12 } from "@noble/curves/secp256k1";
+import { secp256k1 as secp256k12 } from "@noble/curves/secp256k1.js";
 
 // src/utils/uint256.ts
 var uint256_exports = {};
@@ -10187,14 +10922,17 @@ var EthSigner = class {
    */
   async getPubKey() {
     return addHexPrefix(
-      buf2hex(secp256k12.getPublicKey(this.pk, false)).padStart(130, "0").slice(2)
+      buf2hex(secp256k12.getPublicKey(hexToBytes(addHexPrefix(this.pk)), false)).padStart(130, "0").slice(2)
     );
   }
   async signMessage(typedData, accountAddress) {
     const msgHash = getMessageHash(typedData, accountAddress);
-    const signature = secp256k12.sign(
-      removeHexPrefix(sanitizeHex(msgHash)),
-      this.pk
+    const signature = secp256k12.Signature.fromBytes(
+      secp256k12.sign(hexToBytes(sanitizeHex(msgHash)), hexToBytes(addHexPrefix(this.pk)), {
+        prehash: false,
+        format: "recovered"
+      }),
+      "recovered"
     );
     return this.formatEthSignature(signature);
   }
@@ -10214,9 +10952,12 @@ var EthSigner = class {
     } else {
       throw Error("unsupported signTransaction version");
     }
-    const signature = secp256k12.sign(
-      removeHexPrefix(sanitizeHex(msgHash)),
-      this.pk
+    const signature = secp256k12.Signature.fromBytes(
+      secp256k12.sign(hexToBytes(sanitizeHex(msgHash)), hexToBytes(addHexPrefix(this.pk)), {
+        prehash: false,
+        format: "recovered"
+      }),
+      "recovered"
     );
     return this.formatEthSignature(signature);
   }
@@ -10236,9 +10977,12 @@ var EthSigner = class {
     } else {
       throw Error("unsupported signDeployAccountTransaction version");
     }
-    const signature = secp256k12.sign(
-      removeHexPrefix(sanitizeHex(msgHash)),
-      this.pk
+    const signature = secp256k12.Signature.fromBytes(
+      secp256k12.sign(hexToBytes(sanitizeHex(msgHash)), hexToBytes(addHexPrefix(this.pk)), {
+        prehash: false,
+        format: "recovered"
+      }),
+      "recovered"
     );
     return this.formatEthSignature(signature);
   }
@@ -10255,9 +10999,12 @@ var EthSigner = class {
     } else {
       throw Error("unsupported signDeclareTransaction version");
     }
-    const signature = secp256k12.sign(
-      removeHexPrefix(sanitizeHex(msgHash)),
-      this.pk
+    const signature = secp256k12.Signature.fromBytes(
+      secp256k12.sign(hexToBytes(sanitizeHex(msgHash)), hexToBytes(addHexPrefix(this.pk)), {
+        prehash: false,
+        format: "recovered"
+      }),
+      "recovered"
     );
     return this.formatEthSignature(signature);
   }
@@ -10540,7 +11287,7 @@ function getLedgerPathBuffer111(accountId, applicationName = "LedgerW") {
 }
 
 // src/utils/address.ts
-import { hexToBytes as hexToBytes2 } from "@noble/curves/abstract/utils";
+import { hexToBytes as hexToBytes2 } from "@noble/curves/utils.js";
 function addAddressPadding(address) {
   const hex = toHex(isString(address) ? addHexPrefix(address) : address);
   const padded = removeHexPrefix(hex).padStart(64, "0");
@@ -11651,7 +12398,7 @@ var Deployer = class {
         }
         return CallData.compile(constructorCalldata);
       });
-      const deploySalt = salt ?? randomAddress();
+      const deploySalt = salt ?? randomFelt();
       return {
         call: {
           contractAddress: toHex(this.address),
@@ -12185,7 +12932,7 @@ var Account = class {
    * ```
    */
   async getSnip9Nonce() {
-    const nonce = randomAddress();
+    const nonce = randomFelt();
     const isValidNonce = await this.isValidSnip9Nonce(nonce);
     if (!isValidNonce) {
       return this.getSnip9Nonce();
@@ -13852,6 +14599,7 @@ export {
   ETxnResponseFlag,
   EntryPointType,
   EthSigner,
+  HttpTransport,
   Int,
   LedgerSigner111 as LedgerSigner,
   LedgerSigner111,
@@ -13870,11 +14618,12 @@ export {
   RpcProvider as Provider,
   ProviderInterface,
   api_exports as RPC,
-  rpc_0_10_2_exports as RPC0102,
-  rpc_0_10_3_exports as RPC0103,
-  rpc_0_9_0_exports as RPC09,
+  v0_10_2_exports as RPC0102,
+  v0_10_3_exports as RPC0103,
+  v0_9_exports as RPC09,
   RPCResponseParser,
   ReceiptTx,
+  ReconnectingWsTransport,
   ResponseParser,
   RpcChannel3 as RpcChannel,
   RpcError,
@@ -13905,6 +14654,8 @@ export {
   WalletAccountV6,
   WebSocketChannel,
   WebSocketNotConnectedError,
+  WebSocketProvider,
+  WsTransport,
   addAddressPadding,
   brotherId,
   byteArray_exports as byteArray,