starknet 6.11.0 → 6.12.0

package/dist/index.js

@@ -51,6 +51,7 @@ __export(src_exports, {
   EthSigner: () => EthSigner,
   GatewayError: () => GatewayError,
   HttpError: () => HttpError,
+  LedgerSigner: () => LedgerSigner,
   LibraryError: () => LibraryError,
   Literal: () => Literal,
   Provider: () => RpcProvider2,
@@ -99,6 +100,7 @@ __export(src_exports, {
   fixStack: () => fixStack,
   getCalldata: () => getCalldata,
   getChecksumAddress: () => getChecksumAddress,
+  getLedgerPathBuffer: () => getLedgerPathBuffer,
   hash: () => hash_exports,
   isSierra: () => isSierra,
   isUrl: () => isUrl,
@@ -134,6 +136,7 @@ __export(constants_exports, {
   FeeMarginPercentage: () => FeeMarginPercentage,
   IS_BROWSER: () => IS_BROWSER,
   MASK_250: () => MASK_250,
+  MASK_31: () => MASK_31,
   MAX_STORAGE_ITEM_SIZE: () => MAX_STORAGE_ITEM_SIZE,
   NetworkName: () => NetworkName,
   PRIME: () => PRIME,
@@ -251,10 +254,10 @@ var ETransactionVersion2 = /* @__PURE__ */ ((ETransactionVersion25) => {
   ETransactionVersion25["F2"] = "0x100000000000000000000000000000002";
   return ETransactionVersion25;
 })(ETransactionVersion2 || {});
-var ETransactionVersion3 = /* @__PURE__ */ ((ETransactionVersion36) => {
-  ETransactionVersion36["V3"] = "0x3";
-  ETransactionVersion36["F3"] = "0x100000000000000000000000000000003";
-  return ETransactionVersion36;
+var ETransactionVersion3 = /* @__PURE__ */ ((ETransactionVersion37) => {
+  ETransactionVersion37["V3"] = "0x3";
+  ETransactionVersion37["F3"] = "0x100000000000000000000000000000003";
+  return ETransactionVersion37;
 })(ETransactionVersion3 || {});
 
 // src/types/api/index.ts
@@ -271,6 +274,7 @@ __export(encode_exports, {
   btoaUniversal: () => btoaUniversal,
   buf2hex: () => buf2hex,
   calcByteLength: () => calcByteLength,
+  concatenateArrayBuffer: () => concatenateArrayBuffer,
   padLeft: () => padLeft,
   pascalToSnake: () => pascalToSnake,
   removeHexPrefix: () => removeHexPrefix,
@@ -335,11 +339,22 @@ function sanitizeHex(hex) {
   return hex;
 }
 var pascalToSnake = (text) => /[a-z]/.test(text) ? text.split(/(?=[A-Z])/).join("_").toUpperCase() : text;
+function concatenateArrayBuffer(uint8arrays) {
+  const totalLength = uint8arrays.reduce((total, uint8array) => total + uint8array.byteLength, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  uint8arrays.forEach((uint8array) => {
+    result.set(uint8array, offset);
+    offset += uint8array.byteLength;
+  });
+  return result;
+}
 
 // src/constants.ts
 var TEXT_TO_FELT_MAX_LEN = 31;
 var ZERO = 0n;
 var MASK_250 = 2n ** 250n - 1n;
+var MASK_31 = 2n ** 31n - 1n;
 var API_VERSION = ZERO;
 var PRIME = 2n ** 251n + 17n * 2n ** 192n + 1n;
 var MAX_STORAGE_ITEM_SIZE = 256n;
@@ -393,10 +408,6 @@ var RPC_NODES = {
   ]
 };
 
-// src/provider/rpc.ts
-var import_utils2 = require("@noble/curves/abstract/utils");
-var import_sha3 = require("@noble/hashes/sha3");
-
 // src/channel/rpc_0_6.ts
 var rpc_0_6_exports = {};
 __export(rpc_0_6_exports, {
@@ -535,6 +546,104 @@ var BlockTag = /* @__PURE__ */ ((BlockTag2) => {
 // src/types/typedData.ts
 var import_starknet_types_07 = require("starknet-types-07");
 
+// src/utils/json.ts
+var json_exports = {};
+__export(json_exports, {
+  parse: () => parse2,
+  parseAlwaysAsBig: () => parseAlwaysAsBig,
+  stringify: () => stringify2,
+  stringifyAlwaysAsBig: () => stringifyAlwaysAsBig
+});
+var json = __toESM(require("lossless-json"));
+var parseIntAsNumberOrBigInt = (str) => {
+  if (!json.isInteger(str)) return parseFloat(str);
+  const num = parseInt(str, 10);
+  return Number.isSafeInteger(num) ? num : BigInt(str);
+};
+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);
+var stringifyAlwaysAsBig = stringify2;
+
+// src/utils/batch/index.ts
+var BatchClient = class {
+  nodeUrl;
+  headers;
+  interval;
+  requestId = 0;
+  pendingRequests = {};
+  batchPromises = {};
+  delayTimer;
+  delayPromise;
+  delayPromiseResolve;
+  constructor(options) {
+    this.nodeUrl = options.nodeUrl;
+    this.headers = options.headers;
+    this.interval = options.interval;
+  }
+  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;
+  }
+  addPendingRequest(method, params, id) {
+    const request = {
+      id: id ?? `batched_${this.requestId += 1}`,
+      jsonrpc: "2.0",
+      method,
+      params: params ?? void 0
+    };
+    this.pendingRequests[request.id] = request;
+    return request.id;
+  }
+  async sendBatch(requests) {
+    const raw = await fetch(this.nodeUrl, {
+      method: "POST",
+      body: stringify2(requests),
+      headers: this.headers
+    });
+    return raw.json();
+  }
+  /**
+   * 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
+   */
+  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: ${method}`);
+    return result;
+  }
+};
+
 // src/utils/assert.ts
 function assert(condition, message) {
   if (!condition) {
@@ -560,6 +669,7 @@ __export(num_exports, {
   isHex: () => isHex,
   isNumber: () => isNumber,
   isStringWholeNumber: () => isStringWholeNumber,
+  stringToSha256ToArrayBuff4: () => stringToSha256ToArrayBuff4,
   toBigInt: () => toBigInt,
   toCairoBool: () => toCairoBool,
   toHex: () => toHex,
@@ -567,6 +677,7 @@ __export(num_exports, {
   toStorageKey: () => toStorageKey
 });
 var import_utils = require("@noble/curves/abstract/utils");
+var import_sha256 = require("@noble/hashes/sha256");
 function isHex(hex) {
   return /^0x[0-9a-f]*$/i.test(hex);
 }
@@ -633,8 +744,7 @@ function toCairoBool(value) {
   return (+value).toString();
 }
 function hexToBytes(str) {
-  if (!isHex(str))
-    throw new Error(`${str} needs to be a hex-string`);
+  if (!isHex(str)) throw new Error(`${str} needs to be a hex-string`);
   let adaptedValue = removeHexPrefix(str);
   if (adaptedValue.length % 2 !== 0) {
     adaptedValue = `0${adaptedValue}`;
@@ -651,16 +761,25 @@ function isNumber(value) {
 function isBoolean(value) {
   return typeof value === "boolean";
 }
+function stringToSha256ToArrayBuff4(str) {
+  const int31 = (n) => Number(n & MASK_31);
+  const result = int31(BigInt(addHexPrefix(buf2hex((0, import_sha256.sha256)(str)))));
+  return hexToBytes(toHex(result));
+}
 
 // src/utils/hash/selector.ts
 var selector_exports = {};
 __export(selector_exports, {
+  getL2MessageHash: () => getL2MessageHash,
   getSelector: () => getSelector,
   getSelectorFromName: () => getSelectorFromName,
   keccakBn: () => keccakBn,
+  solidityUint256PackedKeccak256: () => solidityUint256PackedKeccak256,
   starknetKeccak: () => starknetKeccak
 });
 var import_starknet = require("@scure/starknet");
+var import_sha3 = require("@noble/hashes/sha3");
+var import_utils2 = require("@noble/curves/abstract/utils");
 function keccakBn(value) {
   const hexWithoutPrefix = removeHexPrefix(toHex(BigInt(value)));
   const evenHex = hexWithoutPrefix.length % 2 === 0 ? hexWithoutPrefix : `0${hexWithoutPrefix}`;
@@ -677,14 +796,30 @@ function getSelectorFromName(funcName) {
   return toHex(starknetKeccak(funcName));
 }
 function getSelector(value) {
-  if (isHex(value)) {
-    return value;
-  }
-  if (isStringWholeNumber(value)) {
-    return toHexString(value);
-  }
+  if (isNumber(value) || isBigInt(value)) return toHex(value);
+  if (isHex(value)) return value;
+  if (isStringWholeNumber(value)) return toHex(value);
   return getSelectorFromName(value);
 }
+function solidityUint256PackedKeccak256(params) {
+  const myEncode = addHexPrefix(
+    params.reduce(
+      (res, par) => res + removeHexPrefix(toHex(par)).padStart(64, "0"),
+      ""
+    )
+  );
+  return addHexPrefix((0, import_utils2.bytesToHex)((0, import_sha3.keccak_256)(hexToBytes(myEncode))));
+}
+function getL2MessageHash(l1FromAddress, l2ToAddress, l2Selector, l2Calldata, l1Nonce) {
+  return solidityUint256PackedKeccak256([
+    l1FromAddress,
+    l2ToAddress,
+    l1Nonce,
+    l2Selector,
+    l2Calldata.length,
+    ...l2Calldata
+  ]);
+}
 
 // src/utils/shortString.ts
 var shortString_exports = {};
@@ -722,15 +857,12 @@ function splitLongString(longStr) {
   return longStr.match(regex) || [];
 }
 function encodeShortString(str) {
-  if (!isASCII(str))
-    throw new Error(`${str} is not an ASCII string`);
-  if (!isShortString(str))
-    throw new Error(`${str} is too long`);
+  if (!isASCII(str)) throw new Error(`${str} is not an ASCII string`);
+  if (!isShortString(str)) throw new Error(`${str} is too long`);
   return addHexPrefix(str.replace(/./g, (char) => char.charCodeAt(0).toString(16)));
 }
 function decodeShortString(str) {
-  if (!isASCII(str))
-    throw new Error(`${str} is not an ASCII string`);
+  if (!isASCII(str)) throw new Error(`${str} is not an ASCII string`);
   if (isHex(str)) {
     return removeHexPrefix(str).replace(/.{2}/g, (hex) => String.fromCharCode(parseInt(hex, 16)));
   }
@@ -858,10 +990,8 @@ var CairoUint256 = class _CairoUint256 {
    */
   static validate(bigNumberish) {
     const bigInt = BigInt(bigNumberish);
-    if (bigInt < UINT_256_MIN)
-      throw Error("bigNumberish is smaller than UINT_256_MIN");
-    if (bigInt > UINT_256_MAX)
-      throw new Error("bigNumberish is bigger than UINT_256_MAX");
+    if (bigInt < UINT_256_MIN) throw Error("bigNumberish is smaller than UINT_256_MIN");
+    if (bigInt > UINT_256_MAX) throw new Error("bigNumberish is bigger than UINT_256_MAX");
     return bigInt;
   }
   /**
@@ -972,10 +1102,8 @@ var CairoUint512 = class _CairoUint512 {
    */
   static validate(bigNumberish) {
     const bigInt = BigInt(bigNumberish);
-    if (bigInt < UINT_512_MIN)
-      throw Error("bigNumberish is smaller than UINT_512_MIN.");
-    if (bigInt > UINT_512_MAX)
-      throw Error("bigNumberish is bigger than UINT_512_MAX.");
+    if (bigInt < UINT_512_MIN) throw Error("bigNumberish is smaller than UINT_512_MIN.");
+    if (bigInt > UINT_512_MAX) throw Error("bigNumberish is bigger than UINT_512_MAX.");
     return bigInt;
   }
   /**
@@ -1412,10 +1540,8 @@ function createAbiParser(abi) {
   throw Error(`Unsupported ABI version ${version}`);
 }
 function getAbiVersion(abi) {
-  if (abi.find((it) => it.type === "interface"))
-    return 2;
-  if (isCairo1Abi(abi))
-    return 1;
+  if (abi.find((it) => it.type === "interface")) return 2;
+  if (isCairo1Abi(abi)) return 1;
   return 0;
 }
 function isNoConstructorValid(method, argsCalldata, abiMethod) {
@@ -1429,8 +1555,7 @@ function parseNamedTuple(namedTuple) {
   return { name, type };
 }
 function parseSubTuple(s) {
-  if (!s.includes("("))
-    return { subTuple: [], result: s };
+  if (!s.includes("(")) return { subTuple: [], result: s };
   const subTuple = [];
   let result = "";
   let i = 0;
@@ -1440,10 +1565,8 @@ function parseSubTuple(s) {
       const lBracket = i;
       i++;
       while (counter) {
-        if (s[i] === ")")
-          counter--;
-        if (s[i] === "(")
-          counter++;
+        if (s[i] === ")") counter--;
+        if (s[i] === "(") counter++;
         i++;
       }
       subTuple.push(s.substring(lBracket, i));
@@ -1750,8 +1873,7 @@ function parseCalldataValue(element, type, structs, enums) {
     }
     if (type === "core::starknet::eth_address::EthAddress")
       return parseBaseTypes(type, element);
-    if (type === "core::byte_array::ByteArray")
-      return parseByteArray(element);
+    if (type === "core::byte_array::ByteArray") return parseByteArray(element);
     const { members } = structs[type];
     const subElement = element;
     return members.reduce((acc, it) => {
@@ -2071,8 +2193,7 @@ var validateFelt = (parameter, input) => {
     isString(parameter) || isNumber(parameter) || isBigInt(parameter),
     `Validate: arg ${input.name} should be a felt typed as (String, Number or BigInt)`
   );
-  if (isString(parameter) && !isHex(parameter))
-    return;
+  if (isString(parameter) && !isHex(parameter)) return;
   const param = BigInt(parameter.toString(10));
   assert(
     // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1266
@@ -2378,8 +2499,7 @@ var CallData = class _CallData {
   validate(type, method, args = []) {
     if (type !== "DEPLOY" /* DEPLOY */) {
       const invocableFunctionNames = this.abi.filter((abi) => {
-        if (abi.type !== "function")
-          return false;
+        if (abi.type !== "function") return false;
         const isView = abi.stateMutability === "view" || abi.state_mutability === "view";
         return type === "INVOKE" /* INVOKE */ ? !isView : isView;
       }).map((abi) => abi.name);
@@ -2457,13 +2577,10 @@ var CallData = class _CallData {
         const oe = Array.isArray(o) ? [o.length.toString(), ...o] : o;
         return Object.entries(oe).flatMap(([k, v]) => {
           let value = v;
-          if (k === "entrypoint")
-            value = getSelectorFromName(value);
-          else if (isLongText(value))
-            value = byteArrayFromString(value);
+          if (k === "entrypoint") value = getSelectorFromName(value);
+          else if (isLongText(value)) value = byteArrayFromString(value);
           const kk = Array.isArray(oe) && k === "0" ? "$$len" : k;
-          if (isBigInt(value))
-            return [[`${prefix}${kk}`, felt(value)]];
+          if (isBigInt(value)) return [[`${prefix}${kk}`, felt(value)]];
           if (Object(value) === value) {
             const methodsKeys = Object.getOwnPropertyNames(Object.getPrototypeOf(value));
             const keys = [...Object.getOwnPropertyNames(value), ...methodsKeys];
@@ -2624,6 +2741,7 @@ __export(hash_exports, {
   calculateDeclareTransactionHash: () => calculateDeclareTransactionHash3,
   calculateDeployAccountTransactionHash: () => calculateDeployAccountTransactionHash3,
   calculateInvokeTransactionHash: () => calculateInvokeTransactionHash2,
+  calculateL2MessageTxHash: () => calculateL2MessageTxHash,
   computeCompiledClassHash: () => computeCompiledClassHash,
   computeContractClassHash: () => computeContractClassHash,
   computeHashOnElements: () => computeHashOnElements2,
@@ -2635,11 +2753,13 @@ __export(hash_exports, {
   computePoseidonHashOnElements: () => computePoseidonHashOnElements,
   computeSierraContractClassHash: () => computeSierraContractClassHash,
   formatSpaces: () => formatSpaces,
+  getL2MessageHash: () => getL2MessageHash,
   getSelector: () => getSelector,
   getSelectorFromName: () => getSelectorFromName,
   hashByteCodeSegments: () => hashByteCodeSegments,
   keccakBn: () => keccakBn,
   poseidon: () => poseidon,
+  solidityUint256PackedKeccak256: () => solidityUint256PackedKeccak256,
   starknetKeccak: () => starknetKeccak
 });
 var poseidon = __toESM(require("@noble/curves/abstract/poseidon"));
@@ -2649,6 +2769,7 @@ var v2_exports = {};
 __export(v2_exports, {
   calculateDeclareTransactionHash: () => calculateDeclareTransactionHash,
   calculateDeployAccountTransactionHash: () => calculateDeployAccountTransactionHash,
+  calculateL2MessageTxHash: () => calculateL2MessageTxHash,
   calculateTransactionHash: () => calculateTransactionHash,
   calculateTransactionHashCommon: () => calculateTransactionHashCommon,
   computeHashOnElements: () => computeHashOnElements
@@ -2718,6 +2839,19 @@ function calculateTransactionHash(contractAddress, version, calldata, maxFee, ch
     [nonce]
   );
 }
+function calculateL2MessageTxHash(l1FromAddress, l2ToAddress, l2Selector, l2Calldata, l2ChainId, l1Nonce) {
+  const payload = [l1FromAddress, ...l2Calldata];
+  return calculateTransactionHashCommon(
+    "0x6c315f68616e646c6572" /* L1_HANDLER */,
+    0,
+    l2ToAddress,
+    getSelector(l2Selector),
+    payload,
+    0,
+    l2ChainId,
+    [l1Nonce]
+  );
+}
 
 // src/utils/hash/transactionHash/v3.ts
 var v3_exports = {};
@@ -2900,28 +3034,6 @@ function calculateDeployAccountTransactionHash3(args) {
 
 // src/utils/hash/classHash.ts
 var import_starknet3 = require("@scure/starknet");
-
-// src/utils/json.ts
-var json_exports = {};
-__export(json_exports, {
-  parse: () => parse2,
-  parseAlwaysAsBig: () => parseAlwaysAsBig,
-  stringify: () => stringify2,
-  stringifyAlwaysAsBig: () => stringifyAlwaysAsBig
-});
-var json = __toESM(require("lossless-json"));
-var parseIntAsNumberOrBigInt = (str) => {
-  if (!json.isInteger(str))
-    return parseFloat(str);
-  const num = parseInt(str, 10);
-  return Number.isSafeInteger(num) ? num : BigInt(str);
-};
-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);
-var stringifyAlwaysAsBig = stringify2;
-
-// src/utils/hash/classHash.ts
 function computePedersenHash(a, b) {
   return starkCurve.pedersen(BigInt(a), BigInt(b));
 }
@@ -3108,8 +3220,7 @@ function compressProgram(jsonProgram) {
   return btoaUniversal(compressedProgram);
 }
 function decompressProgram(base642) {
-  if (Array.isArray(base642))
-    return base642;
+  if (Array.isArray(base642)) return base642;
   const decompressed = arrayBufferToString((0, import_pako.ungzip)(atobUniversal(base642)));
   return parse2(decompressed);
 }
@@ -3121,8 +3232,7 @@ function makeAddress(input) {
   return addHexPrefix(input).toLowerCase();
 }
 function formatSignature(sig) {
-  if (!sig)
-    throw Error("formatSignature: provided signature is undefined");
+  if (!sig) throw Error("formatSignature: provided signature is undefined");
   if (Array.isArray(sig)) {
     return sig.map((it) => toHex(it));
   }
@@ -3160,10 +3270,8 @@ function estimateFeeToBounds(estimate, amountOverhead = 50 /* L1_BOUND_MAX_AMOUN
   };
 }
 function intDAM(dam) {
-  if (dam === api_exports.EDataAvailabilityMode.L1)
-    return api_exports.EDAMode.L1;
-  if (dam === api_exports.EDataAvailabilityMode.L2)
-    return api_exports.EDAMode.L2;
+  if (dam === api_exports.EDataAvailabilityMode.L1) return api_exports.EDAMode.L1;
+  if (dam === api_exports.EDataAvailabilityMode.L2) return api_exports.EDAMode.L2;
   throw Error("EDAM conversion");
 }
 function toTransactionVersion(defaultVersion, providedVersion) {
@@ -3178,17 +3286,12 @@ function toTransactionVersion(defaultVersion, providedVersion) {
   return providedVersion ? providedVersion0xs : defaultVersion0xs;
 }
 function toFeeVersion(providedVersion) {
-  if (!providedVersion)
-    return void 0;
+  if (!providedVersion) return void 0;
   const version = toHex(providedVersion);
-  if (version === api_exports.ETransactionVersion.V0)
-    return api_exports.ETransactionVersion.F0;
-  if (version === api_exports.ETransactionVersion.V1)
-    return api_exports.ETransactionVersion.F1;
-  if (version === api_exports.ETransactionVersion.V2)
-    return api_exports.ETransactionVersion.F2;
-  if (version === api_exports.ETransactionVersion.V3)
-    return api_exports.ETransactionVersion.F3;
+  if (version === api_exports.ETransactionVersion.V0) return api_exports.ETransactionVersion.F0;
+  if (version === api_exports.ETransactionVersion.V1) return api_exports.ETransactionVersion.F1;
+  if (version === api_exports.ETransactionVersion.V2) return api_exports.ETransactionVersion.F2;
+  if (version === api_exports.ETransactionVersion.V3) return api_exports.ETransactionVersion.F3;
   throw Error(`toFeeVersion: ${version} is not supported`);
 }
 function v3Details(details) {
@@ -3202,10 +3305,8 @@ function v3Details(details) {
   };
 }
 function reduceV2(providedVersion) {
-  if (providedVersion === api_exports.ETransactionVersion.F2)
-    return api_exports.ETransactionVersion.F1;
-  if (providedVersion === api_exports.ETransactionVersion.V2)
-    return api_exports.ETransactionVersion.V1;
+  if (providedVersion === api_exports.ETransactionVersion.F2) return api_exports.ETransactionVersion.F1;
+  if (providedVersion === api_exports.ETransactionVersion.V2) return api_exports.ETransactionVersion.V1;
   return providedVersion;
 }
 
@@ -3545,8 +3646,9 @@ var RpcChannel = class {
   specVersion;
   waitMode;
   // behave like web2 rpc and return when tx is processed
+  batchClient;
   constructor(optionsOrProvider) {
-    const { nodeUrl, retries, headers, blockIdentifier, chainId, specVersion, waitMode } = optionsOrProvider || {};
+    const { nodeUrl, retries, headers, blockIdentifier, chainId, specVersion, waitMode, batch } = optionsOrProvider || {};
     if (Object.values(NetworkName).includes(nodeUrl)) {
       this.nodeUrl = getDefaultNodeUrl(nodeUrl, optionsOrProvider?.default);
     } else if (nodeUrl) {
@@ -3561,6 +3663,13 @@ var RpcChannel = class {
     this.specVersion = specVersion;
     this.waitMode = waitMode || false;
     this.requestId = 0;
+    if (typeof batch === "number") {
+      this.batchClient = new BatchClient({
+        nodeUrl: this.nodeUrl,
+        headers: this.headers,
+        interval: batch
+      });
+    }
   }
   setChainId(chainId) {
     this.chainId = chainId;
@@ -3596,6 +3705,15 @@ var RpcChannel = class {
   }
   async fetchEndpoint(method, params) {
     try {
+      if (this.batchClient) {
+        const { error: error2, result: result2 } = await this.batchClient.fetch(
+          method,
+          params,
+          this.requestId += 1
+        );
+        this.errorHandler(method, params, error2);
+        return result2;
+      }
       const rawResult = await this.fetch(method, params, this.requestId += 1);
       const { error, result } = await rawResult.json();
       this.errorHandler(method, params, error);
@@ -3695,10 +3813,8 @@ var RpcChannel = class {
     } = simulateTransactionOptions;
     const block_id = new Block(blockIdentifier).identifier;
     const simulationFlags = [];
-    if (skipValidate)
-      simulationFlags.push(rpcspec_0_6_exports.ESimulationFlag.SKIP_VALIDATE);
-    if (skipFeeCharge)
-      simulationFlags.push(rpcspec_0_6_exports.ESimulationFlag.SKIP_FEE_CHARGE);
+    if (skipValidate) simulationFlags.push(rpcspec_0_6_exports.ESimulationFlag.SKIP_VALIDATE);
+    if (skipFeeCharge) simulationFlags.push(rpcspec_0_6_exports.ESimulationFlag.SKIP_FEE_CHARGE);
     return this.fetchEndpoint("starknet_simulateTransactions", {
       block_id,
       transactions: invocations.map((it) => this.buildTransaction(it)),
@@ -4080,6 +4196,7 @@ var RpcChannel2 = class {
   transactionRetryIntervalFallback;
   waitMode;
   // behave like web2 rpc and return when tx is processed
+  batchClient;
   constructor(optionsOrProvider) {
     const {
       nodeUrl,
@@ -4089,7 +4206,8 @@ var RpcChannel2 = class {
       chainId,
       specVersion,
       waitMode,
-      transactionRetryIntervalFallback
+      transactionRetryIntervalFallback,
+      batch
     } = optionsOrProvider || {};
     if (Object.values(NetworkName).includes(nodeUrl)) {
       this.nodeUrl = getDefaultNodeUrl(nodeUrl, optionsOrProvider?.default);
@@ -4106,6 +4224,13 @@ var RpcChannel2 = class {
     this.waitMode = waitMode || false;
     this.requestId = 0;
     this.transactionRetryIntervalFallback = transactionRetryIntervalFallback;
+    if (typeof batch === "number") {
+      this.batchClient = new BatchClient({
+        nodeUrl: this.nodeUrl,
+        headers: this.headers,
+        interval: batch
+      });
+    }
   }
   get transactionRetryIntervalDefault() {
     return this.transactionRetryIntervalFallback ?? 5e3;
@@ -4144,6 +4269,15 @@ var RpcChannel2 = class {
   }
   async fetchEndpoint(method, params) {
     try {
+      if (this.batchClient) {
+        const { error: error2, result: result2 } = await this.batchClient.fetch(
+          method,
+          params,
+          this.requestId += 1
+        );
+        this.errorHandler(method, params, error2);
+        return result2;
+      }
       const rawResult = await this.fetch(method, params, this.requestId += 1);
       const { error, result } = await rawResult.json();
       this.errorHandler(method, params, error);
@@ -4247,10 +4381,8 @@ var RpcChannel2 = class {
     } = simulateTransactionOptions;
     const block_id = new Block(blockIdentifier).identifier;
     const simulationFlags = [];
-    if (skipValidate)
-      simulationFlags.push(RPCSPEC07.ESimulationFlag.SKIP_VALIDATE);
-    if (skipFeeCharge)
-      simulationFlags.push(RPCSPEC07.ESimulationFlag.SKIP_FEE_CHARGE);
+    if (skipValidate) simulationFlags.push(RPCSPEC07.ESimulationFlag.SKIP_VALIDATE);
+    if (skipFeeCharge) simulationFlags.push(RPCSPEC07.ESimulationFlag.SKIP_FEE_CHARGE);
     return this.fetchEndpoint("starknet_simulateTransactions", {
       block_id,
       transactions: invocations.map((it) => this.buildTransaction(it)),
@@ -4785,7 +4917,7 @@ var RpcProvider = class {
   }
   /**
    * Pause the execution of the script until a specified block is created.
-   * @param {BlockIdentifier} blockIdentifier bloc number (BigNumberisk) or 'pending' or 'latest'.
+   * @param {BlockIdentifier} blockIdentifier bloc number (BigNumberish) or 'pending' or 'latest'.
    * Use of 'latest" or of a block already created will generate no pause.
    * @param {number} [retryInterval] number of milliseconds between 2 requests to the node
    * @example
@@ -4795,12 +4927,10 @@ var RpcProvider = class {
    * ```
    */
   async waitForBlock(blockIdentifier = "pending", retryInterval = 5e3) {
-    if (blockIdentifier === "latest" /* LATEST */)
-      return;
+    if (blockIdentifier === "latest" /* LATEST */) return;
     const currentBlock = await this.getBlockNumber();
     const targetBlock = blockIdentifier === "pending" /* PENDING */ ? currentBlock + 1 : Number(toHex(blockIdentifier));
-    if (targetBlock <= currentBlock)
-      return;
+    if (targetBlock <= currentBlock) return;
     const { retries } = this.channel;
     let retriesCount = retries;
     let isTargetBlock = false;
@@ -4832,13 +4962,7 @@ var RpcProvider = class {
       calldata.length - 1,
       ...calldata.slice(1)
     ];
-    const myEncode = addHexPrefix(
-      params.reduce(
-        (res, par) => res + removeHexPrefix(toHex(par)).padStart(64, "0"),
-        ""
-      )
-    );
-    return addHexPrefix((0, import_utils2.bytesToHex)((0, import_sha3.keccak_256)(hexToBytes(myEncode))));
+    return solidityUint256PackedKeccak256(params);
   }
   async getBlockWithReceipts(blockIdentifier) {
     if (this.channel instanceof rpc_0_6_exports.RpcChannel)
@@ -5074,17 +5198,14 @@ function useDecoded(encoded) {
         if (nextSubdomain === ZERO) {
           const code2 = subdomain % bigAlphabetSizePlusOne;
           subdomain = nextSubdomain;
-          if (code2 === ZERO)
-            decoded += basicAlphabet[0];
-          else
-            decoded += bigAlphabet[Number(code2) - 1];
+          if (code2 === ZERO) decoded += basicAlphabet[0];
+          else decoded += bigAlphabet[Number(code2) - 1];
         } else {
           const code2 = subdomain % bigAlphabetSize;
           decoded += bigAlphabet[Number(code2)];
           subdomain /= bigAlphabetSize;
         }
-      } else
-        decoded += basicAlphabet[Number(code)];
+      } else decoded += basicAlphabet[Number(code)];
     }
     const [str, k] = extractStars(decoded);
     if (k)
@@ -5104,8 +5225,7 @@ function useEncoded(decoded) {
     decoded = str + bigAlphabet[bigAlphabet.length - 1].repeat(2 * (k + 1));
   } else {
     const [str, k] = extractStars(decoded);
-    if (k)
-      decoded = str + bigAlphabet[bigAlphabet.length - 1].repeat(1 + 2 * (k - 1));
+    if (k) decoded = str + bigAlphabet[bigAlphabet.length - 1].repeat(1 + 2 * (k - 1));
   }
   for (let i = 0; i < decoded.length; i += 1) {
     const char = decoded[i];
@@ -5760,8 +5880,7 @@ function encodeValue(types, type, data, ctx = {}, revision = import_starknet_typ
         const variantType = enumType.find((t) => t.name === variantKey);
         const variantIndex = enumType.indexOf(variantType);
         const encodedSubtypes = variantType.type.slice(1, -1).split(",").map((subtype, index) => {
-          if (!subtype)
-            return subtype;
+          if (!subtype) return subtype;
           const subtypeData = variantData[index];
           return encodeValue(types, subtype, subtypeData, void 0, revision)[1];
         });
@@ -6119,6 +6238,195 @@ var EthSigner = class {
   }
 };
 
+// src/signer/ledgerSigner.ts
+var LedgerSigner = class {
+  transporter;
+  accountID;
+  eip2645applicationName;
+  pathBuffer;
+  appVersion;
+  pubKey;
+  fullPubKey;
+  /**
+   * constructor of the LedgerSigner class.
+   * @param {Transport} transport 5 transports are available to handle USB, bluetooth, Node, Web, Mobile.
+   * See Guides for more details.
+   * @param {number} accountID ID of Ledger Nano (can handle 2**31 accounts).
+   * @param {string} [eip2645application='LedgerW'] A wallet is defined by an ERC2645 derivation path (6 items).
+   * One item is the `application`. Default value is `LedgerW`.
+   * @example
+   * ```typescript
+   * import TransportNodeHid from "@ledgerhq/hw-transport-node-hid";
+   * const myNodeTransport = await TransportNodeHid.create();
+   * const myLedgerSigner = new LedgerSigner(myNodeTransport, 0);
+   * ```
+   */
+  constructor(transport, accountID, eip2645application = "LedgerW") {
+    assert(accountID >= 0, "Ledger account ID shall not be a negative number.");
+    assert(accountID <= MASK_31, "Ledger account ID shall be < 2**31.");
+    assert(!!eip2645application, "Ledger application name shall not be empty.");
+    this.transporter = transport;
+    this.accountID = accountID;
+    this.pubKey = "";
+    this.fullPubKey = "";
+    this.eip2645applicationName = eip2645application;
+    this.appVersion = "";
+    this.pathBuffer = getLedgerPathBuffer(this.accountID, this.eip2645applicationName);
+  }
+  /**
+   * provides the Starknet public key
+   * @returns an hex string : 64 characters are Point X coordinate.
+   */
+  async getPubKey() {
+    if (!this.pubKey) await this.getPublicKeys();
+    return this.pubKey;
+  }
+  /**
+   * provides the full public key (with parity prefix)
+   * @returns an hex string : 2 first characters are the parity, the 64 following characters are Point X coordinate. 64 last characters are Point Y coordinate.
+   */
+  async getFullPubKey() {
+    if (!this.fullPubKey) await this.getPublicKeys();
+    return this.fullPubKey;
+  }
+  /**
+   * Returns the version of the Starknet APP implemented in the Ledger.
+   * @returns {string} version.
+   * @example
+   * ```typescript
+   * const result = await myLedgerSigner.getAppVersion();
+   * // result= "1.1.1"
+   * ```
+   */
+  async getAppVersion() {
+    if (!this.appVersion) {
+      const resp = await this.transporter.send(Number("0x5a"), 0, 0, 0);
+      this.appVersion = `${resp[0]}.${resp[1]}.${resp[2]}`;
+    }
+    return this.appVersion;
+  }
+  async signMessage(typedDataToHash, accountAddress) {
+    const msgHash = getMessageHash(typedDataToHash, accountAddress);
+    return this.signRaw(msgHash);
+  }
+  async signTransaction(transactions, transactionsDetail) {
+    const compiledCalldata = getExecuteCalldata(transactions, transactionsDetail.cairoVersion);
+    let msgHash;
+    if (Object.values(ETransactionVersion2).includes(transactionsDetail.version)) {
+      const det = transactionsDetail;
+      msgHash = calculateInvokeTransactionHash2({
+        ...det,
+        senderAddress: det.walletAddress,
+        compiledCalldata,
+        version: det.version
+      });
+    } else if (Object.values(api_exports.ETransactionVersion3).includes(transactionsDetail.version)) {
+      const det = transactionsDetail;
+      msgHash = calculateInvokeTransactionHash2({
+        ...det,
+        senderAddress: det.walletAddress,
+        compiledCalldata,
+        version: det.version,
+        nonceDataAvailabilityMode: intDAM(det.nonceDataAvailabilityMode),
+        feeDataAvailabilityMode: intDAM(det.feeDataAvailabilityMode)
+      });
+    } else {
+      throw Error("unsupported signTransaction version");
+    }
+    return this.signRaw(msgHash);
+  }
+  async signDeployAccountTransaction(details) {
+    const compiledConstructorCalldata = CallData.compile(details.constructorCalldata);
+    let msgHash;
+    if (Object.values(ETransactionVersion2).includes(details.version)) {
+      const det = details;
+      msgHash = calculateDeployAccountTransactionHash3({
+        ...det,
+        salt: det.addressSalt,
+        constructorCalldata: compiledConstructorCalldata,
+        version: det.version
+      });
+    } else if (Object.values(api_exports.ETransactionVersion3).includes(details.version)) {
+      const det = details;
+      msgHash = calculateDeployAccountTransactionHash3({
+        ...det,
+        salt: det.addressSalt,
+        compiledConstructorCalldata,
+        version: det.version,
+        nonceDataAvailabilityMode: intDAM(det.nonceDataAvailabilityMode),
+        feeDataAvailabilityMode: intDAM(det.feeDataAvailabilityMode)
+      });
+    } else {
+      throw Error("unsupported signDeployAccountTransaction version");
+    }
+    return this.signRaw(msgHash);
+  }
+  async signDeclareTransaction(details) {
+    let msgHash;
+    if (Object.values(ETransactionVersion2).includes(details.version)) {
+      const det = details;
+      msgHash = calculateDeclareTransactionHash3({
+        ...det,
+        version: det.version
+      });
+    } else if (Object.values(api_exports.ETransactionVersion3).includes(details.version)) {
+      const det = details;
+      msgHash = calculateDeclareTransactionHash3({
+        ...det,
+        version: det.version,
+        nonceDataAvailabilityMode: intDAM(det.nonceDataAvailabilityMode),
+        feeDataAvailabilityMode: intDAM(det.feeDataAvailabilityMode)
+      });
+    } else {
+      throw Error("unsupported signDeclareTransaction version");
+    }
+    return this.signRaw(msgHash);
+  }
+  async signRaw(msgHash) {
+    addHexPrefix(
+      buf2hex(await this.transporter.send(Number("0x5a"), 2, 0, 0, Buffer.from(this.pathBuffer)))
+    );
+    const shiftedHash = toHex(BigInt(msgHash) << 4n);
+    const buff2 = hexToBytes(shiftedHash);
+    const respSign2 = Uint8Array.from(
+      await this.transporter.send(Number("0x5a"), 2, 1, 0, Buffer.from(buff2))
+    );
+    const r = BigInt(addHexPrefix(buf2hex(respSign2.subarray(1, 33))));
+    const s = BigInt(addHexPrefix(buf2hex(respSign2.subarray(33, 65))));
+    const v = respSign2[65];
+    const sign0 = new starkCurve.Signature(r, s);
+    const sign1 = sign0.addRecoveryBit(v);
+    return sign1;
+  }
+  async getPublicKeys() {
+    const pathBuff = this.pathBuffer;
+    const respGetPublic = Uint8Array.from(
+      await this.transporter.send(Number("0x5a"), 1, 0, 0, Buffer.from(pathBuff))
+    );
+    this.pubKey = addHexPrefix(buf2hex(respGetPublic.subarray(1, 33)));
+    this.fullPubKey = addHexPrefix(buf2hex(respGetPublic.subarray(0, 65)));
+  }
+};
+function getLedgerPathBuffer(accountId, applicationName) {
+  const path0buff = new Uint8Array([128, 0, 10, 85]);
+  const path1buff = new Uint8Array([71, 65, 233, 201]);
+  const path2buff = applicationName === "LedgerW" ? new Uint8Array([43, 206, 231, 219]) : stringToSha256ToArrayBuff4(applicationName);
+  const path3buff = new Uint8Array([0, 0, 0, 0]);
+  const hex = toHex(accountId);
+  const padded = addHexPrefix(removeHexPrefix(hex).padStart(8, "0"));
+  const path4buff = hexToBytes(padded);
+  const path5buff = new Uint8Array([0, 0, 0, 0]);
+  const pathBuff = concatenateArrayBuffer([
+    path0buff,
+    path1buff,
+    path2buff,
+    path3buff,
+    path4buff,
+    path5buff
+  ]);
+  return pathBuff;
+}
+
 // src/utils/events/index.ts
 var events_exports = {};
 __export(events_exports, {
@@ -6152,19 +6460,16 @@ function getCairo1AbiEvents(abi) {
     const findName = (variant) => variant.type === name;
     while (true) {
       const eventEnum = abiEventsEnums.find((eventE) => eventE.variants.some(findName));
-      if (typeof eventEnum === "undefined")
-        break;
+      if (typeof eventEnum === "undefined") break;
       const variant = eventEnum.variants.find(findName);
       nameList.unshift(variant.name);
-      if (variant.kind === "flat")
-        flat = true;
+      if (variant.kind === "flat") flat = true;
       name = eventEnum.name;
     }
     if (nameList.length === 0) {
       throw new Error("inconsistency in ABI events definition.");
     }
-    if (flat)
-      nameList = [nameList[nameList.length - 1]];
+    if (flat) nameList = [nameList[nameList.length - 1]];
     const final = nameList.pop();
     let result = {
       [addHexPrefix(starkCurve.keccak(utf8ToArray(final)).toString(16))]: event
@@ -6190,10 +6495,8 @@ function mergeAbiEvents(target, source) {
   if (isObject(target) && isObject(source)) {
     Object.keys(source).forEach((key) => {
       if (isObject(source[key])) {
-        if (!(key in target))
-          Object.assign(output, { [key]: source[key] });
-        else
-          output[key] = mergeAbiEvents(target[key], source[key]);
+        if (!(key in target)) Object.assign(output, { [key]: source[key] });
+        else output[key] = mergeAbiEvents(target[key], source[key]);
       } else {
         Object.assign(output, { [key]: source[key] });
       }
@@ -6280,10 +6583,8 @@ var Account = class extends RpcProvider2 {
   }
   // provided version or contract based preferred transactionVersion
   getPreferredVersion(type12, type3) {
-    if (this.transactionVersion === api_exports.ETransactionVersion.V3)
-      return type3;
-    if (this.transactionVersion === api_exports.ETransactionVersion.V2)
-      return type12;
+    if (this.transactionVersion === api_exports.ETransactionVersion.V3) return type3;
+    if (this.transactionVersion === api_exports.ETransactionVersion.V2) return type12;
     return api_exports.ETransactionVersion.V3;
   }
   async getNonce(blockIdentifier) {
@@ -6989,13 +7290,11 @@ var WalletAccount = class extends Account {
     super(providerOrOptions, "", "", cairoVersion);
     this.walletProvider = walletProvider;
     this.walletProvider.on("accountsChanged", (res) => {
-      if (!res)
-        return;
+      if (!res) return;
       this.address = res[0].toLowerCase();
     });
     this.walletProvider.on("networkChanged", (res) => {
-      if (!res)
-        return;
+      if (!res) return;
       this.channel.setChainId(res);
     });
     walletProvider.request({
@@ -7135,8 +7434,7 @@ function buildEstimate(contract, functionAbi) {
   };
 }
 function getCalldata(args, callback) {
-  if (Array.isArray(args) && "__compiled__" in args)
-    return args;
+  if (Array.isArray(args) && "__compiled__" in args) return args;
   if (Array.isArray(args) && Array.isArray(args[0]) && "__compiled__" in args[0])
     return args[0];
   return callback();
@@ -7176,8 +7474,7 @@ var Contract = class {
       estimateFee: { enumerable: true, value: {}, writable: false }
     });
     this.abi.forEach((abiElement) => {
-      if (abiElement.type !== "function")
-        return;
+      if (abiElement.type !== "function") return;
       const signature = abiElement.name;
       if (!this[signature]) {
         Object.defineProperty(this, signature, {
@@ -7277,8 +7574,7 @@ var Contract = class {
         nonce
       });
     }
-    if (!nonce)
-      throw new Error(`Nonce is required when invoking a function without an account`);
+    if (!nonce) throw new Error(`Nonce is required when invoking a function without an account`);
     console.warn(`Invoking ${method} without an account. This will not work on a public node.`);
     return this.providerOrAccount.invokeFunction(
       {
@@ -7508,6 +7804,7 @@ var number = num_exports;
   EthSigner,
   GatewayError,
   HttpError,
+  LedgerSigner,
   LibraryError,
   Literal,
   Provider,
@@ -7556,6 +7853,7 @@ var number = num_exports;
   fixStack,
   getCalldata,
   getChecksumAddress,
+  getLedgerPathBuffer,
   hash,
   isSierra,
   isUrl,